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_INFO(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 static void iwl_do_scan_abort(struct iwl_priv
*priv
)
113 lockdep_assert_held(&priv
->mutex
);
115 if (!test_bit(STATUS_SCANNING
, &priv
->status
)) {
116 IWL_DEBUG_SCAN(priv
, "Not performing scan to abort\n");
120 if (test_and_set_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
121 IWL_DEBUG_SCAN(priv
, "Scan abort in progress\n");
125 ret
= iwl_send_scan_abort(priv
);
127 IWL_DEBUG_SCAN(priv
, "Send scan abort failed %d\n", ret
);
128 clear_bit(STATUS_SCANNING
, &priv
->status
);
129 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
130 clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
131 iwl_complete_scan(priv
, true);
133 IWL_DEBUG_SCAN(priv
, "Sucessfully send scan abort\n");
137 * iwl_scan_cancel - Cancel any currently executing HW scan
139 int iwl_scan_cancel(struct iwl_priv
*priv
)
141 IWL_DEBUG_SCAN(priv
, "Queuing abort scan\n");
142 queue_work(priv
->workqueue
, &priv
->abort_scan
);
145 EXPORT_SYMBOL(iwl_scan_cancel
);
148 * iwl_scan_cancel_timeout - Cancel any currently executing HW scan
149 * @ms: amount of time to wait (in milliseconds) for scan to abort
152 int iwl_scan_cancel_timeout(struct iwl_priv
*priv
, unsigned long ms
)
154 unsigned long timeout
= jiffies
+ msecs_to_jiffies(ms
);
156 lockdep_assert_held(&priv
->mutex
);
158 IWL_DEBUG_SCAN(priv
, "Scan cancel timeout\n");
160 iwl_do_scan_abort(priv
);
162 while (time_before_eq(jiffies
, timeout
)) {
163 if (!test_bit(STATUS_SCAN_HW
, &priv
->status
))
168 return test_bit(STATUS_SCAN_HW
, &priv
->status
);
170 EXPORT_SYMBOL(iwl_scan_cancel_timeout
);
172 /* Service response to REPLY_SCAN_CMD (0x80) */
173 static void iwl_rx_reply_scan(struct iwl_priv
*priv
,
174 struct iwl_rx_mem_buffer
*rxb
)
176 #ifdef CONFIG_IWLWIFI_DEBUG
177 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
178 struct iwl_scanreq_notification
*notif
=
179 (struct iwl_scanreq_notification
*)pkt
->u
.raw
;
181 IWL_DEBUG_RX(priv
, "Scan request status = 0x%x\n", notif
->status
);
185 /* Service SCAN_START_NOTIFICATION (0x82) */
186 static void iwl_rx_scan_start_notif(struct iwl_priv
*priv
,
187 struct iwl_rx_mem_buffer
*rxb
)
189 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
190 struct iwl_scanstart_notification
*notif
=
191 (struct iwl_scanstart_notification
*)pkt
->u
.raw
;
192 priv
->scan_start_tsf
= le32_to_cpu(notif
->tsf_low
);
193 IWL_DEBUG_SCAN(priv
, "Scan start: "
195 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
197 notif
->band
? "bg" : "a",
198 le32_to_cpu(notif
->tsf_high
),
199 le32_to_cpu(notif
->tsf_low
),
200 notif
->status
, notif
->beacon_timer
);
203 /* Service SCAN_RESULTS_NOTIFICATION (0x83) */
204 static void iwl_rx_scan_results_notif(struct iwl_priv
*priv
,
205 struct iwl_rx_mem_buffer
*rxb
)
207 #ifdef CONFIG_IWLWIFI_DEBUG
208 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
209 struct iwl_scanresults_notification
*notif
=
210 (struct iwl_scanresults_notification
*)pkt
->u
.raw
;
212 IWL_DEBUG_SCAN(priv
, "Scan ch.res: "
214 "(TSF: 0x%08X:%08X) - %d "
215 "elapsed=%lu usec\n",
217 notif
->band
? "bg" : "a",
218 le32_to_cpu(notif
->tsf_high
),
219 le32_to_cpu(notif
->tsf_low
),
220 le32_to_cpu(notif
->statistics
[0]),
221 le32_to_cpu(notif
->tsf_low
) - priv
->scan_start_tsf
);
225 /* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
226 static void iwl_rx_scan_complete_notif(struct iwl_priv
*priv
,
227 struct iwl_rx_mem_buffer
*rxb
)
229 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
230 struct iwl_scancomplete_notification
*scan_notif
= (void *)pkt
->u
.raw
;
232 IWL_DEBUG_SCAN(priv
, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
233 scan_notif
->scanned_channels
,
235 scan_notif
->tsf_high
, scan_notif
->status
);
237 /* The HW is no longer scanning */
238 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
240 IWL_DEBUG_INFO(priv
, "Scan on %sGHz took %dms\n",
241 (priv
->scan_band
== IEEE80211_BAND_2GHZ
) ? "2.4" : "5.2",
242 jiffies_to_msecs(elapsed_jiffies
243 (priv
->scan_start
, jiffies
)));
245 queue_work(priv
->workqueue
, &priv
->scan_completed
);
247 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
&&
248 priv
->cfg
->advanced_bt_coexist
&&
249 priv
->bt_status
!= scan_notif
->bt_status
) {
250 if (scan_notif
->bt_status
) {
252 if (!priv
->bt_ch_announce
)
253 priv
->bt_traffic_load
=
254 IWL_BT_COEX_TRAFFIC_LOAD_HIGH
;
256 * otherwise, no traffic load information provided
261 priv
->bt_traffic_load
=
262 IWL_BT_COEX_TRAFFIC_LOAD_NONE
;
264 priv
->bt_status
= scan_notif
->bt_status
;
265 queue_work(priv
->workqueue
, &priv
->bt_traffic_change_work
);
269 void iwl_setup_rx_scan_handlers(struct iwl_priv
*priv
)
272 priv
->rx_handlers
[REPLY_SCAN_CMD
] = iwl_rx_reply_scan
;
273 priv
->rx_handlers
[SCAN_START_NOTIFICATION
] = iwl_rx_scan_start_notif
;
274 priv
->rx_handlers
[SCAN_RESULTS_NOTIFICATION
] =
275 iwl_rx_scan_results_notif
;
276 priv
->rx_handlers
[SCAN_COMPLETE_NOTIFICATION
] =
277 iwl_rx_scan_complete_notif
;
279 EXPORT_SYMBOL(iwl_setup_rx_scan_handlers
);
281 inline u16
iwl_get_active_dwell_time(struct iwl_priv
*priv
,
282 enum ieee80211_band band
,
285 if (band
== IEEE80211_BAND_5GHZ
)
286 return IWL_ACTIVE_DWELL_TIME_52
+
287 IWL_ACTIVE_DWELL_FACTOR_52GHZ
* (n_probes
+ 1);
289 return IWL_ACTIVE_DWELL_TIME_24
+
290 IWL_ACTIVE_DWELL_FACTOR_24GHZ
* (n_probes
+ 1);
292 EXPORT_SYMBOL(iwl_get_active_dwell_time
);
294 u16
iwl_get_passive_dwell_time(struct iwl_priv
*priv
,
295 enum ieee80211_band band
,
296 struct ieee80211_vif
*vif
)
298 struct iwl_rxon_context
*ctx
;
299 u16 passive
= (band
== IEEE80211_BAND_2GHZ
) ?
300 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_24
:
301 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_52
;
303 if (iwl_is_any_associated(priv
)) {
305 * If we're associated, we clamp the maximum passive
306 * dwell time to be 98% of the smallest beacon interval
307 * (minus 2 * channel tune time)
309 for_each_context(priv
, ctx
) {
312 if (!iwl_is_associated_ctx(ctx
))
314 value
= ctx
->vif
? ctx
->vif
->bss_conf
.beacon_int
: 0;
315 if ((value
> IWL_PASSIVE_DWELL_BASE
) || !value
)
316 value
= IWL_PASSIVE_DWELL_BASE
;
317 value
= (value
* 98) / 100 - IWL_CHANNEL_TUNE_TIME
* 2;
318 passive
= min(value
, passive
);
324 EXPORT_SYMBOL(iwl_get_passive_dwell_time
);
326 void iwl_init_scan_params(struct iwl_priv
*priv
)
328 u8 ant_idx
= fls(priv
->hw_params
.valid_tx_ant
) - 1;
329 if (!priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
])
330 priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
] = ant_idx
;
331 if (!priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
])
332 priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
] = ant_idx
;
334 EXPORT_SYMBOL(iwl_init_scan_params
);
336 static int __must_check
iwl_scan_initiate(struct iwl_priv
*priv
,
337 struct ieee80211_vif
*vif
,
339 enum nl80211_band band
)
343 lockdep_assert_held(&priv
->mutex
);
345 if (WARN_ON(!priv
->cfg
->ops
->utils
->request_scan
))
348 cancel_delayed_work(&priv
->scan_check
);
350 if (!iwl_is_ready(priv
)) {
351 IWL_WARN(priv
, "request scan called when driver not ready.\n");
355 if (test_bit(STATUS_SCAN_HW
, &priv
->status
)) {
357 "Multiple concurrent scan requests in parallel.\n");
361 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
)) {
362 IWL_DEBUG_SCAN(priv
, "Aborting scan due to device shutdown\n");
366 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
367 IWL_DEBUG_HC(priv
, "Scan request while abort pending.\n");
371 if (iwl_is_rfkill(priv
)) {
372 IWL_DEBUG_HC(priv
, "Aborting scan due to RF Kill activation\n");
376 if (!test_bit(STATUS_READY
, &priv
->status
)) {
377 IWL_DEBUG_HC(priv
, "Scan request while uninitialized.\n");
381 IWL_DEBUG_INFO(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
)
434 ret
= iwl_scan_initiate(priv
, vif
, false,
435 req
->channels
[0]->band
);
437 IWL_DEBUG_MAC80211(priv
, "leave\n");
440 mutex_unlock(&priv
->mutex
);
444 EXPORT_SYMBOL(iwl_mac_hw_scan
);
447 * internal short scan, this function should only been called while associated.
448 * It will reset and tune the radio to prevent possible RF related problem
450 void iwl_internal_short_hw_scan(struct iwl_priv
*priv
)
452 queue_work(priv
->workqueue
, &priv
->start_internal_scan
);
455 static void iwl_bg_start_internal_scan(struct work_struct
*work
)
457 struct iwl_priv
*priv
=
458 container_of(work
, struct iwl_priv
, start_internal_scan
);
460 mutex_lock(&priv
->mutex
);
462 if (priv
->is_internal_short_scan
== true) {
463 IWL_DEBUG_SCAN(priv
, "Internal scan already in progress\n");
467 if (test_bit(STATUS_SCANNING
, &priv
->status
)) {
468 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
472 if (iwl_scan_initiate(priv
, NULL
, true, priv
->band
))
473 IWL_DEBUG_SCAN(priv
, "failed to start internal short scan\n");
475 mutex_unlock(&priv
->mutex
);
478 static void iwl_bg_scan_check(struct work_struct
*data
)
480 struct iwl_priv
*priv
=
481 container_of(data
, struct iwl_priv
, scan_check
.work
);
483 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
486 mutex_lock(&priv
->mutex
);
487 if (test_bit(STATUS_SCANNING
, &priv
->status
) &&
488 !test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
489 IWL_DEBUG_SCAN(priv
, "Scan completion watchdog (%dms)\n",
490 jiffies_to_msecs(IWL_SCAN_CHECK_WATCHDOG
));
492 if (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
493 iwl_send_scan_abort(priv
);
495 mutex_unlock(&priv
->mutex
);
499 * iwl_fill_probe_req - fill in all required fields and IE for probe request
502 u16
iwl_fill_probe_req(struct iwl_priv
*priv
, struct ieee80211_mgmt
*frame
,
503 const u8
*ta
, const u8
*ies
, int ie_len
, int left
)
508 /* Make sure there is enough space for the probe request,
509 * two mandatory IEs and the data */
514 frame
->frame_control
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
515 memcpy(frame
->da
, iwl_bcast_addr
, ETH_ALEN
);
516 memcpy(frame
->sa
, ta
, ETH_ALEN
);
517 memcpy(frame
->bssid
, iwl_bcast_addr
, ETH_ALEN
);
523 pos
= &frame
->u
.probe_req
.variable
[0];
525 /* fill in our indirect SSID IE */
529 *pos
++ = WLAN_EID_SSID
;
534 if (WARN_ON(left
< ie_len
))
538 memcpy(pos
, ies
, ie_len
);
544 EXPORT_SYMBOL(iwl_fill_probe_req
);
546 static void iwl_bg_abort_scan(struct work_struct
*work
)
548 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, abort_scan
);
550 cancel_delayed_work(&priv
->scan_check
);
552 mutex_lock(&priv
->mutex
);
553 iwl_do_scan_abort(priv
);
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_INFO(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_INFO(priv
, "Aborted scan completed.\n");
575 if (!test_and_clear_bit(STATUS_SCANNING
, &priv
->status
)) {
576 IWL_DEBUG_INFO(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
);
603 /* Can we still talk to firmware ? */
604 if (!iwl_is_ready_rf(priv
))
607 /* Since setting the TXPOWER may have been deferred while
608 * performing the scan, fire one off */
609 iwl_set_tx_power(priv
, priv
->tx_power_user_lmt
, true);
612 * Since setting the RXON may have been deferred while
613 * performing the scan, fire one off if needed
615 for_each_context(priv
, ctx
)
616 iwlcore_commit_rxon(priv
, ctx
);
618 if (priv
->cfg
->ops
->hcmd
->set_pan_params
)
619 priv
->cfg
->ops
->hcmd
->set_pan_params(priv
);
622 mutex_unlock(&priv
->mutex
);
625 void iwl_setup_scan_deferred_work(struct iwl_priv
*priv
)
627 INIT_WORK(&priv
->scan_completed
, iwl_bg_scan_completed
);
628 INIT_WORK(&priv
->abort_scan
, iwl_bg_abort_scan
);
629 INIT_WORK(&priv
->start_internal_scan
, iwl_bg_start_internal_scan
);
630 INIT_DELAYED_WORK(&priv
->scan_check
, iwl_bg_scan_check
);
632 EXPORT_SYMBOL(iwl_setup_scan_deferred_work
);