1 /******************************************************************************
5 * Copyright(c) 2008 - 2011 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 #include "iwl-trans.h"
42 /* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
43 * sending probe req. This should be set long enough to hear probe responses
44 * from more than one AP. */
45 #define IWL_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */
46 #define IWL_ACTIVE_DWELL_TIME_52 (20)
48 #define IWL_ACTIVE_DWELL_FACTOR_24GHZ (3)
49 #define IWL_ACTIVE_DWELL_FACTOR_52GHZ (2)
51 /* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
52 * Must be set longer than active dwell time.
53 * For the most reliable scan, set > AP beacon interval (typically 100msec). */
54 #define IWL_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */
55 #define IWL_PASSIVE_DWELL_TIME_52 (10)
56 #define IWL_PASSIVE_DWELL_BASE (100)
57 #define IWL_CHANNEL_TUNE_TIME 5
59 static int iwl_send_scan_abort(struct iwl_priv
*priv
)
62 struct iwl_rx_packet
*pkt
;
63 struct iwl_host_cmd cmd
= {
64 .id
= REPLY_SCAN_ABORT_CMD
,
65 .flags
= CMD_SYNC
| CMD_WANT_SKB
,
68 /* Exit instantly with error when device is not ready
69 * to receive scan abort command or it does not perform
70 * hardware scan currently */
71 if (!test_bit(STATUS_READY
, &priv
->shrd
->status
) ||
72 !test_bit(STATUS_GEO_CONFIGURED
, &priv
->shrd
->status
) ||
73 !test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
) ||
74 test_bit(STATUS_FW_ERROR
, &priv
->shrd
->status
) ||
75 test_bit(STATUS_EXIT_PENDING
, &priv
->shrd
->status
))
78 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
82 pkt
= (struct iwl_rx_packet
*)cmd
.reply_page
;
83 if (pkt
->u
.status
!= CAN_ABORT_STATUS
) {
84 /* The scan abort will return 1 for success or
85 * 2 for "failure". A failure condition can be
86 * due to simply not being in an active scan which
87 * can occur if we send the scan abort before we
88 * the microcode has notified us that a scan is
90 IWL_DEBUG_SCAN(priv
, "SCAN_ABORT ret %d.\n", pkt
->u
.status
);
94 iwl_free_pages(priv
, cmd
.reply_page
);
98 static void iwl_complete_scan(struct iwl_priv
*priv
, bool aborted
)
100 /* check if scan was requested from mac80211 */
101 if (priv
->scan_request
) {
102 IWL_DEBUG_SCAN(priv
, "Complete scan in mac80211\n");
103 ieee80211_scan_completed(priv
->hw
, aborted
);
106 if (priv
->scan_type
== IWL_SCAN_ROC
) {
107 ieee80211_remain_on_channel_expired(priv
->hw
);
108 priv
->hw_roc_channel
= NULL
;
109 schedule_delayed_work(&priv
->hw_roc_disable_work
, 10 * HZ
);
112 priv
->scan_type
= IWL_SCAN_NORMAL
;
113 priv
->scan_vif
= NULL
;
114 priv
->scan_request
= NULL
;
117 void iwl_force_scan_end(struct iwl_priv
*priv
)
119 lockdep_assert_held(&priv
->shrd
->mutex
);
121 if (!test_bit(STATUS_SCANNING
, &priv
->shrd
->status
)) {
122 IWL_DEBUG_SCAN(priv
, "Forcing scan end while not scanning\n");
126 IWL_DEBUG_SCAN(priv
, "Forcing scan end\n");
127 clear_bit(STATUS_SCANNING
, &priv
->shrd
->status
);
128 clear_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
129 clear_bit(STATUS_SCAN_ABORTING
, &priv
->shrd
->status
);
130 iwl_complete_scan(priv
, true);
133 static void iwl_do_scan_abort(struct iwl_priv
*priv
)
137 lockdep_assert_held(&priv
->shrd
->mutex
);
139 if (!test_bit(STATUS_SCANNING
, &priv
->shrd
->status
)) {
140 IWL_DEBUG_SCAN(priv
, "Not performing scan to abort\n");
144 if (test_and_set_bit(STATUS_SCAN_ABORTING
, &priv
->shrd
->status
)) {
145 IWL_DEBUG_SCAN(priv
, "Scan abort in progress\n");
149 ret
= iwl_send_scan_abort(priv
);
151 IWL_DEBUG_SCAN(priv
, "Send scan abort failed %d\n", ret
);
152 iwl_force_scan_end(priv
);
154 IWL_DEBUG_SCAN(priv
, "Successfully send scan abort\n");
158 * iwl_scan_cancel - Cancel any currently executing HW scan
160 int iwl_scan_cancel(struct iwl_priv
*priv
)
162 IWL_DEBUG_SCAN(priv
, "Queuing abort scan\n");
163 queue_work(priv
->shrd
->workqueue
, &priv
->abort_scan
);
168 * iwl_scan_cancel_timeout - Cancel any currently executing HW scan
169 * @ms: amount of time to wait (in milliseconds) for scan to abort
172 int iwl_scan_cancel_timeout(struct iwl_priv
*priv
, unsigned long ms
)
174 unsigned long timeout
= jiffies
+ msecs_to_jiffies(ms
);
176 lockdep_assert_held(&priv
->shrd
->mutex
);
178 IWL_DEBUG_SCAN(priv
, "Scan cancel timeout\n");
180 iwl_do_scan_abort(priv
);
182 while (time_before_eq(jiffies
, timeout
)) {
183 if (!test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
))
188 return test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
191 /* Service response to REPLY_SCAN_CMD (0x80) */
192 static void iwl_rx_reply_scan(struct iwl_priv
*priv
,
193 struct iwl_rx_mem_buffer
*rxb
)
195 #ifdef CONFIG_IWLWIFI_DEBUG
196 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
197 struct iwl_scanreq_notification
*notif
=
198 (struct iwl_scanreq_notification
*)pkt
->u
.raw
;
200 IWL_DEBUG_SCAN(priv
, "Scan request status = 0x%x\n", notif
->status
);
204 /* Service SCAN_START_NOTIFICATION (0x82) */
205 static void iwl_rx_scan_start_notif(struct iwl_priv
*priv
,
206 struct iwl_rx_mem_buffer
*rxb
)
208 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
209 struct iwl_scanstart_notification
*notif
=
210 (struct iwl_scanstart_notification
*)pkt
->u
.raw
;
211 priv
->scan_start_tsf
= le32_to_cpu(notif
->tsf_low
);
212 IWL_DEBUG_SCAN(priv
, "Scan start: "
214 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
216 notif
->band
? "bg" : "a",
217 le32_to_cpu(notif
->tsf_high
),
218 le32_to_cpu(notif
->tsf_low
),
219 notif
->status
, notif
->beacon_timer
);
221 if (priv
->scan_type
== IWL_SCAN_ROC
)
222 ieee80211_ready_on_channel(priv
->hw
);
225 /* Service SCAN_RESULTS_NOTIFICATION (0x83) */
226 static void iwl_rx_scan_results_notif(struct iwl_priv
*priv
,
227 struct iwl_rx_mem_buffer
*rxb
)
229 #ifdef CONFIG_IWLWIFI_DEBUG
230 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
231 struct iwl_scanresults_notification
*notif
=
232 (struct iwl_scanresults_notification
*)pkt
->u
.raw
;
234 IWL_DEBUG_SCAN(priv
, "Scan ch.res: "
236 "(TSF: 0x%08X:%08X) - %d "
237 "elapsed=%lu usec\n",
239 notif
->band
? "bg" : "a",
240 le32_to_cpu(notif
->tsf_high
),
241 le32_to_cpu(notif
->tsf_low
),
242 le32_to_cpu(notif
->statistics
[0]),
243 le32_to_cpu(notif
->tsf_low
) - priv
->scan_start_tsf
);
247 /* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
248 static void iwl_rx_scan_complete_notif(struct iwl_priv
*priv
,
249 struct iwl_rx_mem_buffer
*rxb
)
251 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
252 struct iwl_scancomplete_notification
*scan_notif
= (void *)pkt
->u
.raw
;
254 IWL_DEBUG_SCAN(priv
, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
255 scan_notif
->scanned_channels
,
257 scan_notif
->tsf_high
, scan_notif
->status
);
259 /* The HW is no longer scanning */
260 clear_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
262 IWL_DEBUG_SCAN(priv
, "Scan on %sGHz took %dms\n",
263 (priv
->scan_band
== IEEE80211_BAND_2GHZ
) ? "2.4" : "5.2",
264 jiffies_to_msecs(jiffies
- priv
->scan_start
));
266 queue_work(priv
->shrd
->workqueue
, &priv
->scan_completed
);
268 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
&&
269 iwl_advanced_bt_coexist(priv
) &&
270 priv
->bt_status
!= scan_notif
->bt_status
) {
271 if (scan_notif
->bt_status
) {
273 if (!priv
->bt_ch_announce
)
274 priv
->bt_traffic_load
=
275 IWL_BT_COEX_TRAFFIC_LOAD_HIGH
;
277 * otherwise, no traffic load information provided
282 priv
->bt_traffic_load
=
283 IWL_BT_COEX_TRAFFIC_LOAD_NONE
;
285 priv
->bt_status
= scan_notif
->bt_status
;
286 queue_work(priv
->shrd
->workqueue
,
287 &priv
->bt_traffic_change_work
);
291 void iwl_setup_rx_scan_handlers(struct iwl_priv
*priv
)
294 priv
->rx_handlers
[REPLY_SCAN_CMD
] = iwl_rx_reply_scan
;
295 priv
->rx_handlers
[SCAN_START_NOTIFICATION
] = iwl_rx_scan_start_notif
;
296 priv
->rx_handlers
[SCAN_RESULTS_NOTIFICATION
] =
297 iwl_rx_scan_results_notif
;
298 priv
->rx_handlers
[SCAN_COMPLETE_NOTIFICATION
] =
299 iwl_rx_scan_complete_notif
;
302 inline u16
iwl_get_active_dwell_time(struct iwl_priv
*priv
,
303 enum ieee80211_band band
,
306 if (band
== IEEE80211_BAND_5GHZ
)
307 return IWL_ACTIVE_DWELL_TIME_52
+
308 IWL_ACTIVE_DWELL_FACTOR_52GHZ
* (n_probes
+ 1);
310 return IWL_ACTIVE_DWELL_TIME_24
+
311 IWL_ACTIVE_DWELL_FACTOR_24GHZ
* (n_probes
+ 1);
314 u16
iwl_get_passive_dwell_time(struct iwl_priv
*priv
,
315 enum ieee80211_band band
,
316 struct ieee80211_vif
*vif
)
318 struct iwl_rxon_context
*ctx
;
319 u16 passive
= (band
== IEEE80211_BAND_2GHZ
) ?
320 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_24
:
321 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_52
;
323 if (iwl_is_any_associated(priv
)) {
325 * If we're associated, we clamp the maximum passive
326 * dwell time to be 98% of the smallest beacon interval
327 * (minus 2 * channel tune time)
329 for_each_context(priv
, ctx
) {
332 if (!iwl_is_associated_ctx(ctx
))
334 value
= ctx
->vif
? ctx
->vif
->bss_conf
.beacon_int
: 0;
335 if ((value
> IWL_PASSIVE_DWELL_BASE
) || !value
)
336 value
= IWL_PASSIVE_DWELL_BASE
;
337 value
= (value
* 98) / 100 - IWL_CHANNEL_TUNE_TIME
* 2;
338 passive
= min(value
, passive
);
345 void iwl_init_scan_params(struct iwl_priv
*priv
)
347 u8 ant_idx
= fls(hw_params(priv
).valid_tx_ant
) - 1;
348 if (!priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
])
349 priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
] = ant_idx
;
350 if (!priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
])
351 priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
] = ant_idx
;
354 int __must_check
iwl_scan_initiate(struct iwl_priv
*priv
,
355 struct ieee80211_vif
*vif
,
356 enum iwl_scan_type scan_type
,
357 enum ieee80211_band band
)
361 lockdep_assert_held(&priv
->shrd
->mutex
);
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
->shrd
->status
)) {
372 "Multiple concurrent scan requests in parallel.\n");
376 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->shrd
->status
)) {
377 IWL_DEBUG_SCAN(priv
, "Scan request while abort pending.\n");
381 IWL_DEBUG_SCAN(priv
, "Starting %sscan...\n",
382 scan_type
== IWL_SCAN_NORMAL
? "" :
383 scan_type
== IWL_SCAN_ROC
? "remain-on-channel " :
386 set_bit(STATUS_SCANNING
, &priv
->shrd
->status
);
387 priv
->scan_type
= scan_type
;
388 priv
->scan_start
= jiffies
;
389 priv
->scan_band
= band
;
391 ret
= iwlagn_request_scan(priv
, vif
);
393 clear_bit(STATUS_SCANNING
, &priv
->shrd
->status
);
394 priv
->scan_type
= IWL_SCAN_NORMAL
;
398 queue_delayed_work(priv
->shrd
->workqueue
, &priv
->scan_check
,
399 IWL_SCAN_CHECK_WATCHDOG
);
404 int iwl_mac_hw_scan(struct ieee80211_hw
*hw
,
405 struct ieee80211_vif
*vif
,
406 struct cfg80211_scan_request
*req
)
408 struct iwl_priv
*priv
= hw
->priv
;
411 IWL_DEBUG_MAC80211(priv
, "enter\n");
413 if (req
->n_channels
== 0)
416 mutex_lock(&priv
->shrd
->mutex
);
418 if (test_bit(STATUS_SCANNING
, &priv
->shrd
->status
) &&
419 priv
->scan_type
!= IWL_SCAN_NORMAL
) {
420 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
425 /* mac80211 will only ask for one band at a time */
426 priv
->scan_request
= req
;
427 priv
->scan_vif
= vif
;
430 * If an internal scan is in progress, just set
431 * up the scan_request as per above.
433 if (priv
->scan_type
!= IWL_SCAN_NORMAL
) {
434 IWL_DEBUG_SCAN(priv
, "SCAN request during internal scan\n");
437 ret
= iwl_scan_initiate(priv
, vif
, IWL_SCAN_NORMAL
,
438 req
->channels
[0]->band
);
440 IWL_DEBUG_MAC80211(priv
, "leave\n");
443 mutex_unlock(&priv
->shrd
->mutex
);
449 * internal short scan, this function should only been called while associated.
450 * It will reset and tune the radio to prevent possible RF related problem
452 void iwl_internal_short_hw_scan(struct iwl_priv
*priv
)
454 queue_work(priv
->shrd
->workqueue
, &priv
->start_internal_scan
);
457 static void iwl_bg_start_internal_scan(struct work_struct
*work
)
459 struct iwl_priv
*priv
=
460 container_of(work
, struct iwl_priv
, start_internal_scan
);
462 IWL_DEBUG_SCAN(priv
, "Start internal scan\n");
464 mutex_lock(&priv
->shrd
->mutex
);
466 if (priv
->scan_type
== IWL_SCAN_RADIO_RESET
) {
467 IWL_DEBUG_SCAN(priv
, "Internal scan already in progress\n");
471 if (test_bit(STATUS_SCANNING
, &priv
->shrd
->status
)) {
472 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
476 if (iwl_scan_initiate(priv
, NULL
, IWL_SCAN_RADIO_RESET
, priv
->band
))
477 IWL_DEBUG_SCAN(priv
, "failed to start internal short scan\n");
479 mutex_unlock(&priv
->shrd
->mutex
);
482 static void iwl_bg_scan_check(struct work_struct
*data
)
484 struct iwl_priv
*priv
=
485 container_of(data
, struct iwl_priv
, scan_check
.work
);
487 IWL_DEBUG_SCAN(priv
, "Scan check work\n");
489 /* Since we are here firmware does not finish scan and
490 * most likely is in bad shape, so we don't bother to
491 * send abort command, just force scan complete to mac80211 */
492 mutex_lock(&priv
->shrd
->mutex
);
493 iwl_force_scan_end(priv
);
494 mutex_unlock(&priv
->shrd
->mutex
);
498 * iwl_fill_probe_req - fill in all required fields and IE for probe request
501 u16
iwl_fill_probe_req(struct iwl_priv
*priv
, struct ieee80211_mgmt
*frame
,
502 const u8
*ta
, const u8
*ies
, int ie_len
, int left
)
507 /* Make sure there is enough space for the probe request,
508 * two mandatory IEs and the data */
513 frame
->frame_control
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
514 memcpy(frame
->da
, iwl_bcast_addr
, ETH_ALEN
);
515 memcpy(frame
->sa
, ta
, ETH_ALEN
);
516 memcpy(frame
->bssid
, iwl_bcast_addr
, ETH_ALEN
);
522 pos
= &frame
->u
.probe_req
.variable
[0];
524 /* fill in our indirect SSID IE */
528 *pos
++ = WLAN_EID_SSID
;
533 if (WARN_ON(left
< ie_len
))
537 memcpy(pos
, ies
, ie_len
);
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
->shrd
->mutex
);
553 iwl_scan_cancel_timeout(priv
, 200);
554 mutex_unlock(&priv
->shrd
->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
);
563 IWL_DEBUG_SCAN(priv
, "Completed scan.\n");
565 cancel_delayed_work(&priv
->scan_check
);
567 mutex_lock(&priv
->shrd
->mutex
);
569 aborted
= test_and_clear_bit(STATUS_SCAN_ABORTING
, &priv
->shrd
->status
);
571 IWL_DEBUG_SCAN(priv
, "Aborted scan completed.\n");
573 if (!test_and_clear_bit(STATUS_SCANNING
, &priv
->shrd
->status
)) {
574 IWL_DEBUG_SCAN(priv
, "Scan already completed.\n");
578 if (priv
->scan_type
== IWL_SCAN_ROC
) {
579 ieee80211_remain_on_channel_expired(priv
->hw
);
580 priv
->hw_roc_channel
= NULL
;
581 schedule_delayed_work(&priv
->hw_roc_disable_work
, 10 * HZ
);
584 if (priv
->scan_type
!= IWL_SCAN_NORMAL
&& !aborted
) {
587 /* Check if mac80211 requested scan during our internal scan */
588 if (priv
->scan_request
== NULL
)
591 /* If so request a new scan */
592 err
= iwl_scan_initiate(priv
, priv
->scan_vif
, IWL_SCAN_NORMAL
,
593 priv
->scan_request
->channels
[0]->band
);
596 "failed to initiate pending scan: %d\n", err
);
605 iwl_complete_scan(priv
, aborted
);
608 /* Can we still talk to firmware ? */
609 if (!iwl_is_ready_rf(priv
))
612 iwlagn_post_scan(priv
);
615 mutex_unlock(&priv
->shrd
->mutex
);
618 void iwl_setup_scan_deferred_work(struct iwl_priv
*priv
)
620 INIT_WORK(&priv
->scan_completed
, iwl_bg_scan_completed
);
621 INIT_WORK(&priv
->abort_scan
, iwl_bg_abort_scan
);
622 INIT_WORK(&priv
->start_internal_scan
, iwl_bg_start_internal_scan
);
623 INIT_DELAYED_WORK(&priv
->scan_check
, iwl_bg_scan_check
);
626 void iwl_cancel_scan_deferred_work(struct iwl_priv
*priv
)
628 cancel_work_sync(&priv
->start_internal_scan
);
629 cancel_work_sync(&priv
->abort_scan
);
630 cancel_work_sync(&priv
->scan_completed
);
632 if (cancel_delayed_work_sync(&priv
->scan_check
)) {
633 mutex_lock(&priv
->shrd
->mutex
);
634 iwl_force_scan_end(priv
);
635 mutex_unlock(&priv
->shrd
->mutex
);