1 /******************************************************************************
5 * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *****************************************************************************/
28 #include <linux/slab.h>
29 #include <linux/types.h>
30 #include <linux/etherdevice.h>
31 #include <net/mac80211.h>
33 #include "iwl-eeprom.h"
38 #include "iwl-helpers.h"
40 /* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
41 * sending probe req. This should be set long enough to hear probe responses
42 * from more than one AP. */
43 #define IWL_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */
44 #define IWL_ACTIVE_DWELL_TIME_52 (20)
46 #define IWL_ACTIVE_DWELL_FACTOR_24GHZ (3)
47 #define IWL_ACTIVE_DWELL_FACTOR_52GHZ (2)
49 /* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
50 * Must be set longer than active dwell time.
51 * For the most reliable scan, set > AP beacon interval (typically 100msec). */
52 #define IWL_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */
53 #define IWL_PASSIVE_DWELL_TIME_52 (10)
54 #define IWL_PASSIVE_DWELL_BASE (100)
55 #define IWL_CHANNEL_TUNE_TIME 5
57 static int iwl_send_scan_abort(struct iwl_priv
*priv
)
60 struct iwl_rx_packet
*pkt
;
61 struct iwl_host_cmd cmd
= {
62 .id
= REPLY_SCAN_ABORT_CMD
,
63 .flags
= CMD_WANT_SKB
,
66 /* Exit instantly with error when device is not ready
67 * to receive scan abort command or it does not perform
68 * hardware scan currently */
69 if (!test_bit(STATUS_READY
, &priv
->status
) ||
70 !test_bit(STATUS_GEO_CONFIGURED
, &priv
->status
) ||
71 !test_bit(STATUS_SCAN_HW
, &priv
->status
) ||
72 test_bit(STATUS_FW_ERROR
, &priv
->status
) ||
73 test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
76 ret
= iwl_send_cmd_sync(priv
, &cmd
);
80 pkt
= (struct iwl_rx_packet
*)cmd
.reply_page
;
81 if (pkt
->u
.status
!= CAN_ABORT_STATUS
) {
82 /* The scan abort will return 1 for success or
83 * 2 for "failure". A failure condition can be
84 * due to simply not being in an active scan which
85 * can occur if we send the scan abort before we
86 * the microcode has notified us that a scan is
88 IWL_DEBUG_SCAN(priv
, "SCAN_ABORT ret %d.\n", pkt
->u
.status
);
92 iwl_free_pages(priv
, cmd
.reply_page
);
96 static void iwl_complete_scan(struct iwl_priv
*priv
, bool aborted
)
98 /* check if scan was requested from mac80211 */
99 if (priv
->scan_request
) {
100 IWL_DEBUG_SCAN(priv
, "Complete scan in mac80211\n");
101 ieee80211_scan_completed(priv
->hw
, aborted
);
104 priv
->is_internal_short_scan
= false;
105 priv
->scan_vif
= NULL
;
106 priv
->scan_request
= NULL
;
109 void iwl_force_scan_end(struct iwl_priv
*priv
)
111 lockdep_assert_held(&priv
->mutex
);
113 if (!test_bit(STATUS_SCANNING
, &priv
->status
)) {
114 IWL_DEBUG_SCAN(priv
, "Forcing scan end while not scanning\n");
118 IWL_DEBUG_SCAN(priv
, "Forcing scan end\n");
119 clear_bit(STATUS_SCANNING
, &priv
->status
);
120 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
121 clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
122 iwl_complete_scan(priv
, true);
124 EXPORT_SYMBOL(iwl_force_scan_end
);
126 static void iwl_do_scan_abort(struct iwl_priv
*priv
)
130 lockdep_assert_held(&priv
->mutex
);
132 if (!test_bit(STATUS_SCANNING
, &priv
->status
)) {
133 IWL_DEBUG_SCAN(priv
, "Not performing scan to abort\n");
137 if (test_and_set_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
138 IWL_DEBUG_SCAN(priv
, "Scan abort in progress\n");
142 ret
= iwl_send_scan_abort(priv
);
144 IWL_DEBUG_SCAN(priv
, "Send scan abort failed %d\n", ret
);
145 iwl_force_scan_end(priv
);
147 IWL_DEBUG_SCAN(priv
, "Sucessfully send scan abort\n");
151 * iwl_scan_cancel - Cancel any currently executing HW scan
153 int iwl_scan_cancel(struct iwl_priv
*priv
)
155 IWL_DEBUG_SCAN(priv
, "Queuing abort scan\n");
156 queue_work(priv
->workqueue
, &priv
->abort_scan
);
159 EXPORT_SYMBOL(iwl_scan_cancel
);
162 * iwl_scan_cancel_timeout - Cancel any currently executing HW scan
163 * @ms: amount of time to wait (in milliseconds) for scan to abort
166 int iwl_scan_cancel_timeout(struct iwl_priv
*priv
, unsigned long ms
)
168 unsigned long timeout
= jiffies
+ msecs_to_jiffies(ms
);
170 lockdep_assert_held(&priv
->mutex
);
172 IWL_DEBUG_SCAN(priv
, "Scan cancel timeout\n");
174 iwl_do_scan_abort(priv
);
176 while (time_before_eq(jiffies
, timeout
)) {
177 if (!test_bit(STATUS_SCAN_HW
, &priv
->status
))
182 return test_bit(STATUS_SCAN_HW
, &priv
->status
);
184 EXPORT_SYMBOL(iwl_scan_cancel_timeout
);
186 /* Service response to REPLY_SCAN_CMD (0x80) */
187 static void iwl_rx_reply_scan(struct iwl_priv
*priv
,
188 struct iwl_rx_mem_buffer
*rxb
)
190 #ifdef CONFIG_IWLWIFI_DEBUG
191 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
192 struct iwl_scanreq_notification
*notif
=
193 (struct iwl_scanreq_notification
*)pkt
->u
.raw
;
195 IWL_DEBUG_SCAN(priv
, "Scan request status = 0x%x\n", notif
->status
);
199 /* Service SCAN_START_NOTIFICATION (0x82) */
200 static void iwl_rx_scan_start_notif(struct iwl_priv
*priv
,
201 struct iwl_rx_mem_buffer
*rxb
)
203 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
204 struct iwl_scanstart_notification
*notif
=
205 (struct iwl_scanstart_notification
*)pkt
->u
.raw
;
206 priv
->scan_start_tsf
= le32_to_cpu(notif
->tsf_low
);
207 IWL_DEBUG_SCAN(priv
, "Scan start: "
209 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
211 notif
->band
? "bg" : "a",
212 le32_to_cpu(notif
->tsf_high
),
213 le32_to_cpu(notif
->tsf_low
),
214 notif
->status
, notif
->beacon_timer
);
217 /* Service SCAN_RESULTS_NOTIFICATION (0x83) */
218 static void iwl_rx_scan_results_notif(struct iwl_priv
*priv
,
219 struct iwl_rx_mem_buffer
*rxb
)
221 #ifdef CONFIG_IWLWIFI_DEBUG
222 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
223 struct iwl_scanresults_notification
*notif
=
224 (struct iwl_scanresults_notification
*)pkt
->u
.raw
;
226 IWL_DEBUG_SCAN(priv
, "Scan ch.res: "
228 "(TSF: 0x%08X:%08X) - %d "
229 "elapsed=%lu usec\n",
231 notif
->band
? "bg" : "a",
232 le32_to_cpu(notif
->tsf_high
),
233 le32_to_cpu(notif
->tsf_low
),
234 le32_to_cpu(notif
->statistics
[0]),
235 le32_to_cpu(notif
->tsf_low
) - priv
->scan_start_tsf
);
239 /* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
240 static void iwl_rx_scan_complete_notif(struct iwl_priv
*priv
,
241 struct iwl_rx_mem_buffer
*rxb
)
243 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
244 struct iwl_scancomplete_notification
*scan_notif
= (void *)pkt
->u
.raw
;
246 IWL_DEBUG_SCAN(priv
, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
247 scan_notif
->scanned_channels
,
249 scan_notif
->tsf_high
, scan_notif
->status
);
251 /* The HW is no longer scanning */
252 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
254 IWL_DEBUG_SCAN(priv
, "Scan on %sGHz took %dms\n",
255 (priv
->scan_band
== IEEE80211_BAND_2GHZ
) ? "2.4" : "5.2",
256 jiffies_to_msecs(elapsed_jiffies
257 (priv
->scan_start
, jiffies
)));
259 queue_work(priv
->workqueue
, &priv
->scan_completed
);
261 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
&&
262 priv
->cfg
->bt_params
&&
263 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
264 priv
->bt_status
!= scan_notif
->bt_status
) {
265 if (scan_notif
->bt_status
) {
267 if (!priv
->bt_ch_announce
)
268 priv
->bt_traffic_load
=
269 IWL_BT_COEX_TRAFFIC_LOAD_HIGH
;
271 * otherwise, no traffic load information provided
276 priv
->bt_traffic_load
=
277 IWL_BT_COEX_TRAFFIC_LOAD_NONE
;
279 priv
->bt_status
= scan_notif
->bt_status
;
280 queue_work(priv
->workqueue
, &priv
->bt_traffic_change_work
);
284 void iwl_setup_rx_scan_handlers(struct iwl_priv
*priv
)
287 priv
->rx_handlers
[REPLY_SCAN_CMD
] = iwl_rx_reply_scan
;
288 priv
->rx_handlers
[SCAN_START_NOTIFICATION
] = iwl_rx_scan_start_notif
;
289 priv
->rx_handlers
[SCAN_RESULTS_NOTIFICATION
] =
290 iwl_rx_scan_results_notif
;
291 priv
->rx_handlers
[SCAN_COMPLETE_NOTIFICATION
] =
292 iwl_rx_scan_complete_notif
;
294 EXPORT_SYMBOL(iwl_setup_rx_scan_handlers
);
296 inline u16
iwl_get_active_dwell_time(struct iwl_priv
*priv
,
297 enum ieee80211_band band
,
300 if (band
== IEEE80211_BAND_5GHZ
)
301 return IWL_ACTIVE_DWELL_TIME_52
+
302 IWL_ACTIVE_DWELL_FACTOR_52GHZ
* (n_probes
+ 1);
304 return IWL_ACTIVE_DWELL_TIME_24
+
305 IWL_ACTIVE_DWELL_FACTOR_24GHZ
* (n_probes
+ 1);
307 EXPORT_SYMBOL(iwl_get_active_dwell_time
);
309 u16
iwl_get_passive_dwell_time(struct iwl_priv
*priv
,
310 enum ieee80211_band band
,
311 struct ieee80211_vif
*vif
)
313 struct iwl_rxon_context
*ctx
;
314 u16 passive
= (band
== IEEE80211_BAND_2GHZ
) ?
315 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_24
:
316 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_52
;
318 if (iwl_is_any_associated(priv
)) {
320 * If we're associated, we clamp the maximum passive
321 * dwell time to be 98% of the smallest beacon interval
322 * (minus 2 * channel tune time)
324 for_each_context(priv
, ctx
) {
327 if (!iwl_is_associated_ctx(ctx
))
329 value
= ctx
->vif
? ctx
->vif
->bss_conf
.beacon_int
: 0;
330 if ((value
> IWL_PASSIVE_DWELL_BASE
) || !value
)
331 value
= IWL_PASSIVE_DWELL_BASE
;
332 value
= (value
* 98) / 100 - IWL_CHANNEL_TUNE_TIME
* 2;
333 passive
= min(value
, passive
);
339 EXPORT_SYMBOL(iwl_get_passive_dwell_time
);
341 void iwl_init_scan_params(struct iwl_priv
*priv
)
343 u8 ant_idx
= fls(priv
->hw_params
.valid_tx_ant
) - 1;
344 if (!priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
])
345 priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
] = ant_idx
;
346 if (!priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
])
347 priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
] = ant_idx
;
349 EXPORT_SYMBOL(iwl_init_scan_params
);
351 static int __must_check
iwl_scan_initiate(struct iwl_priv
*priv
,
352 struct ieee80211_vif
*vif
,
354 enum ieee80211_band band
)
358 lockdep_assert_held(&priv
->mutex
);
360 if (WARN_ON(!priv
->cfg
->ops
->utils
->request_scan
))
363 cancel_delayed_work(&priv
->scan_check
);
365 if (!iwl_is_ready_rf(priv
)) {
366 IWL_WARN(priv
, "Request scan called when driver not ready.\n");
370 if (test_bit(STATUS_SCAN_HW
, &priv
->status
)) {
372 "Multiple concurrent scan requests in parallel.\n");
376 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
377 IWL_DEBUG_SCAN(priv
, "Scan request while abort pending.\n");
381 IWL_DEBUG_SCAN(priv
, "Starting %sscan...\n",
382 internal
? "internal short " : "");
384 set_bit(STATUS_SCANNING
, &priv
->status
);
385 priv
->is_internal_short_scan
= internal
;
386 priv
->scan_start
= jiffies
;
387 priv
->scan_band
= band
;
389 ret
= priv
->cfg
->ops
->utils
->request_scan(priv
, vif
);
391 clear_bit(STATUS_SCANNING
, &priv
->status
);
392 priv
->is_internal_short_scan
= false;
396 queue_delayed_work(priv
->workqueue
, &priv
->scan_check
,
397 IWL_SCAN_CHECK_WATCHDOG
);
402 int iwl_mac_hw_scan(struct ieee80211_hw
*hw
,
403 struct ieee80211_vif
*vif
,
404 struct cfg80211_scan_request
*req
)
406 struct iwl_priv
*priv
= hw
->priv
;
409 IWL_DEBUG_MAC80211(priv
, "enter\n");
411 if (req
->n_channels
== 0)
414 mutex_lock(&priv
->mutex
);
416 if (test_bit(STATUS_SCANNING
, &priv
->status
) &&
417 !priv
->is_internal_short_scan
) {
418 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
423 /* mac80211 will only ask for one band at a time */
424 priv
->scan_request
= req
;
425 priv
->scan_vif
= vif
;
428 * If an internal scan is in progress, just set
429 * up the scan_request as per above.
431 if (priv
->is_internal_short_scan
) {
432 IWL_DEBUG_SCAN(priv
, "SCAN request during internal scan\n");
435 ret
= iwl_scan_initiate(priv
, vif
, false,
436 req
->channels
[0]->band
);
438 IWL_DEBUG_MAC80211(priv
, "leave\n");
441 mutex_unlock(&priv
->mutex
);
445 EXPORT_SYMBOL(iwl_mac_hw_scan
);
448 * internal short scan, this function should only been called while associated.
449 * It will reset and tune the radio to prevent possible RF related problem
451 void iwl_internal_short_hw_scan(struct iwl_priv
*priv
)
453 queue_work(priv
->workqueue
, &priv
->start_internal_scan
);
456 static void iwl_bg_start_internal_scan(struct work_struct
*work
)
458 struct iwl_priv
*priv
=
459 container_of(work
, struct iwl_priv
, start_internal_scan
);
461 IWL_DEBUG_SCAN(priv
, "Start internal scan\n");
463 mutex_lock(&priv
->mutex
);
465 if (priv
->is_internal_short_scan
== true) {
466 IWL_DEBUG_SCAN(priv
, "Internal scan already in progress\n");
470 if (test_bit(STATUS_SCANNING
, &priv
->status
)) {
471 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
475 if (iwl_scan_initiate(priv
, NULL
, true, priv
->band
))
476 IWL_DEBUG_SCAN(priv
, "failed to start internal short scan\n");
478 mutex_unlock(&priv
->mutex
);
481 static void iwl_bg_scan_check(struct work_struct
*data
)
483 struct iwl_priv
*priv
=
484 container_of(data
, struct iwl_priv
, scan_check
.work
);
486 IWL_DEBUG_SCAN(priv
, "Scan check work\n");
488 /* Since we are here firmware does not finish scan and
489 * most likely is in bad shape, so we don't bother to
490 * send abort command, just force scan complete to mac80211 */
491 mutex_lock(&priv
->mutex
);
492 iwl_force_scan_end(priv
);
493 mutex_unlock(&priv
->mutex
);
497 * iwl_fill_probe_req - fill in all required fields and IE for probe request
500 u16
iwl_fill_probe_req(struct iwl_priv
*priv
, struct ieee80211_mgmt
*frame
,
501 const u8
*ta
, const u8
*ies
, int ie_len
, int left
)
506 /* Make sure there is enough space for the probe request,
507 * two mandatory IEs and the data */
512 frame
->frame_control
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
513 memcpy(frame
->da
, iwl_bcast_addr
, ETH_ALEN
);
514 memcpy(frame
->sa
, ta
, ETH_ALEN
);
515 memcpy(frame
->bssid
, iwl_bcast_addr
, ETH_ALEN
);
521 pos
= &frame
->u
.probe_req
.variable
[0];
523 /* fill in our indirect SSID IE */
527 *pos
++ = WLAN_EID_SSID
;
532 if (WARN_ON(left
< ie_len
))
536 memcpy(pos
, ies
, ie_len
);
542 EXPORT_SYMBOL(iwl_fill_probe_req
);
544 static void iwl_bg_abort_scan(struct work_struct
*work
)
546 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, abort_scan
);
548 IWL_DEBUG_SCAN(priv
, "Abort scan work\n");
550 /* We keep scan_check work queued in case when firmware will not
551 * report back scan completed notification */
552 mutex_lock(&priv
->mutex
);
553 iwl_scan_cancel_timeout(priv
, 200);
554 mutex_unlock(&priv
->mutex
);
557 static void iwl_bg_scan_completed(struct work_struct
*work
)
559 struct iwl_priv
*priv
=
560 container_of(work
, struct iwl_priv
, scan_completed
);
562 struct iwl_rxon_context
*ctx
;
564 IWL_DEBUG_SCAN(priv
, "Completed %sscan.\n",
565 priv
->is_internal_short_scan
? "internal short " : "");
567 cancel_delayed_work(&priv
->scan_check
);
569 mutex_lock(&priv
->mutex
);
571 aborted
= test_and_clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
573 IWL_DEBUG_SCAN(priv
, "Aborted scan completed.\n");
575 if (!test_and_clear_bit(STATUS_SCANNING
, &priv
->status
)) {
576 IWL_DEBUG_SCAN(priv
, "Scan already completed.\n");
580 if (priv
->is_internal_short_scan
&& !aborted
) {
583 /* Check if mac80211 requested scan during our internal scan */
584 if (priv
->scan_request
== NULL
)
587 /* If so request a new scan */
588 err
= iwl_scan_initiate(priv
, priv
->scan_vif
, false,
589 priv
->scan_request
->channels
[0]->band
);
592 "failed to initiate pending scan: %d\n", err
);
601 iwl_complete_scan(priv
, aborted
);
604 /* Can we still talk to firmware ? */
605 if (!iwl_is_ready_rf(priv
))
608 /* Since setting the TXPOWER may have been deferred while
609 * performing the scan, fire one off */
610 iwl_set_tx_power(priv
, priv
->tx_power_user_lmt
, true);
613 * Since setting the RXON may have been deferred while
614 * performing the scan, fire one off if needed
616 for_each_context(priv
, ctx
)
617 iwlcore_commit_rxon(priv
, ctx
);
619 if (priv
->cfg
->ops
->hcmd
->set_pan_params
)
620 priv
->cfg
->ops
->hcmd
->set_pan_params(priv
);
623 mutex_unlock(&priv
->mutex
);
626 void iwl_setup_scan_deferred_work(struct iwl_priv
*priv
)
628 INIT_WORK(&priv
->scan_completed
, iwl_bg_scan_completed
);
629 INIT_WORK(&priv
->abort_scan
, iwl_bg_abort_scan
);
630 INIT_WORK(&priv
->start_internal_scan
, iwl_bg_start_internal_scan
);
631 INIT_DELAYED_WORK(&priv
->scan_check
, iwl_bg_scan_check
);
633 EXPORT_SYMBOL(iwl_setup_scan_deferred_work
);
635 void iwl_cancel_scan_deferred_work(struct iwl_priv
*priv
)
637 cancel_work_sync(&priv
->start_internal_scan
);
638 cancel_work_sync(&priv
->abort_scan
);
639 cancel_work_sync(&priv
->scan_completed
);
641 if (cancel_delayed_work_sync(&priv
->scan_check
)) {
642 mutex_lock(&priv
->mutex
);
643 iwl_force_scan_end(priv
);
644 mutex_unlock(&priv
->mutex
);
647 EXPORT_SYMBOL(iwl_cancel_scan_deferred_work
);