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
60 * iwl_scan_cancel - Cancel any currently executing HW scan
62 * NOTE: priv->mutex is not required before calling this function
64 int iwl_scan_cancel(struct iwl_priv
*priv
)
66 if (!test_bit(STATUS_SCAN_HW
, &priv
->status
)) {
67 clear_bit(STATUS_SCANNING
, &priv
->status
);
71 if (test_bit(STATUS_SCANNING
, &priv
->status
)) {
72 if (!test_and_set_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
73 IWL_DEBUG_SCAN(priv
, "Queuing scan abort.\n");
74 queue_work(priv
->workqueue
, &priv
->abort_scan
);
77 IWL_DEBUG_SCAN(priv
, "Scan abort already in progress.\n");
79 return test_bit(STATUS_SCANNING
, &priv
->status
);
84 EXPORT_SYMBOL(iwl_scan_cancel
);
86 * iwl_scan_cancel_timeout - Cancel any currently executing HW scan
87 * @ms: amount of time to wait (in milliseconds) for scan to abort
89 * NOTE: priv->mutex must be held before calling this function
91 int iwl_scan_cancel_timeout(struct iwl_priv
*priv
, unsigned long ms
)
93 unsigned long now
= jiffies
;
96 ret
= iwl_scan_cancel(priv
);
98 mutex_unlock(&priv
->mutex
);
99 while (!time_after(jiffies
, now
+ msecs_to_jiffies(ms
)) &&
100 test_bit(STATUS_SCANNING
, &priv
->status
))
102 mutex_lock(&priv
->mutex
);
104 return test_bit(STATUS_SCANNING
, &priv
->status
);
109 EXPORT_SYMBOL(iwl_scan_cancel_timeout
);
111 static int iwl_send_scan_abort(struct iwl_priv
*priv
)
114 struct iwl_rx_packet
*pkt
;
115 struct iwl_host_cmd cmd
= {
116 .id
= REPLY_SCAN_ABORT_CMD
,
117 .flags
= CMD_WANT_SKB
,
120 /* If there isn't a scan actively going on in the hardware
121 * then we are in between scan bands and not actually
122 * actively scanning, so don't send the abort command */
123 if (!test_bit(STATUS_SCAN_HW
, &priv
->status
)) {
124 clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
128 ret
= iwl_send_cmd_sync(priv
, &cmd
);
130 clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
134 pkt
= (struct iwl_rx_packet
*)cmd
.reply_page
;
135 if (pkt
->u
.status
!= CAN_ABORT_STATUS
) {
136 /* The scan abort will return 1 for success or
137 * 2 for "failure". A failure condition can be
138 * due to simply not being in an active scan which
139 * can occur if we send the scan abort before we
140 * the microcode has notified us that a scan is
142 IWL_DEBUG_INFO(priv
, "SCAN_ABORT returned %d.\n", pkt
->u
.status
);
143 clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
);
144 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
147 iwl_free_pages(priv
, cmd
.reply_page
);
152 /* Service response to REPLY_SCAN_CMD (0x80) */
153 static void iwl_rx_reply_scan(struct iwl_priv
*priv
,
154 struct iwl_rx_mem_buffer
*rxb
)
156 #ifdef CONFIG_IWLWIFI_DEBUG
157 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
158 struct iwl_scanreq_notification
*notif
=
159 (struct iwl_scanreq_notification
*)pkt
->u
.raw
;
161 IWL_DEBUG_RX(priv
, "Scan request status = 0x%x\n", notif
->status
);
165 /* Service SCAN_START_NOTIFICATION (0x82) */
166 static void iwl_rx_scan_start_notif(struct iwl_priv
*priv
,
167 struct iwl_rx_mem_buffer
*rxb
)
169 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
170 struct iwl_scanstart_notification
*notif
=
171 (struct iwl_scanstart_notification
*)pkt
->u
.raw
;
172 priv
->scan_start_tsf
= le32_to_cpu(notif
->tsf_low
);
173 IWL_DEBUG_SCAN(priv
, "Scan start: "
175 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
177 notif
->band
? "bg" : "a",
178 le32_to_cpu(notif
->tsf_high
),
179 le32_to_cpu(notif
->tsf_low
),
180 notif
->status
, notif
->beacon_timer
);
183 /* Service SCAN_RESULTS_NOTIFICATION (0x83) */
184 static void iwl_rx_scan_results_notif(struct iwl_priv
*priv
,
185 struct iwl_rx_mem_buffer
*rxb
)
187 #ifdef CONFIG_IWLWIFI_DEBUG
188 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
189 struct iwl_scanresults_notification
*notif
=
190 (struct iwl_scanresults_notification
*)pkt
->u
.raw
;
192 IWL_DEBUG_SCAN(priv
, "Scan ch.res: "
194 "(TSF: 0x%08X:%08X) - %d "
195 "elapsed=%lu usec\n",
197 notif
->band
? "bg" : "a",
198 le32_to_cpu(notif
->tsf_high
),
199 le32_to_cpu(notif
->tsf_low
),
200 le32_to_cpu(notif
->statistics
[0]),
201 le32_to_cpu(notif
->tsf_low
) - priv
->scan_start_tsf
);
205 /* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
206 static void iwl_rx_scan_complete_notif(struct iwl_priv
*priv
,
207 struct iwl_rx_mem_buffer
*rxb
)
209 #ifdef CONFIG_IWLWIFI_DEBUG
210 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
211 struct iwl_scancomplete_notification
*scan_notif
= (void *)pkt
->u
.raw
;
213 IWL_DEBUG_SCAN(priv
, "Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
214 scan_notif
->scanned_channels
,
216 scan_notif
->tsf_high
, scan_notif
->status
);
219 /* The HW is no longer scanning */
220 clear_bit(STATUS_SCAN_HW
, &priv
->status
);
222 IWL_DEBUG_INFO(priv
, "Scan on %sGHz took %dms\n",
223 (priv
->scan_band
== IEEE80211_BAND_2GHZ
) ? "2.4" : "5.2",
224 jiffies_to_msecs(elapsed_jiffies
225 (priv
->scan_start
, jiffies
)));
228 * If a request to abort was given, or the scan did not succeed
229 * then we reset the scan state machine and terminate,
230 * re-queuing another scan if one has been requested
232 if (test_and_clear_bit(STATUS_SCAN_ABORTING
, &priv
->status
))
233 IWL_DEBUG_INFO(priv
, "Aborted scan completed.\n");
235 IWL_DEBUG_INFO(priv
, "Setting scan to off\n");
237 clear_bit(STATUS_SCANNING
, &priv
->status
);
239 queue_work(priv
->workqueue
, &priv
->scan_completed
);
242 void iwl_setup_rx_scan_handlers(struct iwl_priv
*priv
)
245 priv
->rx_handlers
[REPLY_SCAN_CMD
] = iwl_rx_reply_scan
;
246 priv
->rx_handlers
[SCAN_START_NOTIFICATION
] = iwl_rx_scan_start_notif
;
247 priv
->rx_handlers
[SCAN_RESULTS_NOTIFICATION
] =
248 iwl_rx_scan_results_notif
;
249 priv
->rx_handlers
[SCAN_COMPLETE_NOTIFICATION
] =
250 iwl_rx_scan_complete_notif
;
252 EXPORT_SYMBOL(iwl_setup_rx_scan_handlers
);
254 inline u16
iwl_get_active_dwell_time(struct iwl_priv
*priv
,
255 enum ieee80211_band band
,
258 if (band
== IEEE80211_BAND_5GHZ
)
259 return IWL_ACTIVE_DWELL_TIME_52
+
260 IWL_ACTIVE_DWELL_FACTOR_52GHZ
* (n_probes
+ 1);
262 return IWL_ACTIVE_DWELL_TIME_24
+
263 IWL_ACTIVE_DWELL_FACTOR_24GHZ
* (n_probes
+ 1);
265 EXPORT_SYMBOL(iwl_get_active_dwell_time
);
267 u16
iwl_get_passive_dwell_time(struct iwl_priv
*priv
,
268 enum ieee80211_band band
,
269 struct ieee80211_vif
*vif
)
271 u16 passive
= (band
== IEEE80211_BAND_2GHZ
) ?
272 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_24
:
273 IWL_PASSIVE_DWELL_BASE
+ IWL_PASSIVE_DWELL_TIME_52
;
275 if (iwl_is_associated(priv
)) {
276 /* If we're associated, we clamp the maximum passive
277 * dwell time to be 98% of the beacon interval (minus
278 * 2 * channel tune time) */
279 passive
= vif
? vif
->bss_conf
.beacon_int
: 0;
280 if ((passive
> IWL_PASSIVE_DWELL_BASE
) || !passive
)
281 passive
= IWL_PASSIVE_DWELL_BASE
;
282 passive
= (passive
* 98) / 100 - IWL_CHANNEL_TUNE_TIME
* 2;
287 EXPORT_SYMBOL(iwl_get_passive_dwell_time
);
289 void iwl_init_scan_params(struct iwl_priv
*priv
)
291 u8 ant_idx
= fls(priv
->hw_params
.valid_tx_ant
) - 1;
292 if (!priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
])
293 priv
->scan_tx_ant
[IEEE80211_BAND_5GHZ
] = ant_idx
;
294 if (!priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
])
295 priv
->scan_tx_ant
[IEEE80211_BAND_2GHZ
] = ant_idx
;
297 EXPORT_SYMBOL(iwl_init_scan_params
);
299 static int iwl_scan_initiate(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
)
301 lockdep_assert_held(&priv
->mutex
);
303 IWL_DEBUG_INFO(priv
, "Starting scan...\n");
304 set_bit(STATUS_SCANNING
, &priv
->status
);
305 priv
->is_internal_short_scan
= false;
306 priv
->scan_start
= jiffies
;
308 if (WARN_ON(!priv
->cfg
->ops
->utils
->request_scan
))
311 priv
->cfg
->ops
->utils
->request_scan(priv
, vif
);
316 int iwl_mac_hw_scan(struct ieee80211_hw
*hw
,
317 struct ieee80211_vif
*vif
,
318 struct cfg80211_scan_request
*req
)
320 struct iwl_priv
*priv
= hw
->priv
;
323 IWL_DEBUG_MAC80211(priv
, "enter\n");
325 if (req
->n_channels
== 0)
328 mutex_lock(&priv
->mutex
);
330 if (!iwl_is_ready_rf(priv
)) {
332 IWL_DEBUG_MAC80211(priv
, "leave - not ready or exit pending\n");
336 if (test_bit(STATUS_SCANNING
, &priv
->status
) &&
337 !priv
->is_internal_short_scan
) {
338 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
343 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
344 IWL_DEBUG_SCAN(priv
, "Scan request while abort pending\n");
349 /* mac80211 will only ask for one band at a time */
350 priv
->scan_band
= req
->channels
[0]->band
;
351 priv
->scan_request
= req
;
352 priv
->scan_vif
= vif
;
355 * If an internal scan is in progress, just set
356 * up the scan_request as per above.
358 if (priv
->is_internal_short_scan
)
361 ret
= iwl_scan_initiate(priv
, vif
);
363 IWL_DEBUG_MAC80211(priv
, "leave\n");
366 mutex_unlock(&priv
->mutex
);
370 EXPORT_SYMBOL(iwl_mac_hw_scan
);
373 * internal short scan, this function should only been called while associated.
374 * It will reset and tune the radio to prevent possible RF related problem
376 void iwl_internal_short_hw_scan(struct iwl_priv
*priv
)
378 queue_work(priv
->workqueue
, &priv
->start_internal_scan
);
381 void iwl_bg_start_internal_scan(struct work_struct
*work
)
383 struct iwl_priv
*priv
=
384 container_of(work
, struct iwl_priv
, start_internal_scan
);
386 mutex_lock(&priv
->mutex
);
388 if (priv
->is_internal_short_scan
== true) {
389 IWL_DEBUG_SCAN(priv
, "Internal scan already in progress\n");
393 if (!iwl_is_ready_rf(priv
)) {
394 IWL_DEBUG_SCAN(priv
, "not ready or exit pending\n");
398 if (test_bit(STATUS_SCANNING
, &priv
->status
)) {
399 IWL_DEBUG_SCAN(priv
, "Scan already in progress.\n");
403 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
404 IWL_DEBUG_SCAN(priv
, "Scan request while abort pending\n");
408 priv
->scan_band
= priv
->band
;
410 IWL_DEBUG_SCAN(priv
, "Start internal short scan...\n");
411 set_bit(STATUS_SCANNING
, &priv
->status
);
412 priv
->is_internal_short_scan
= true;
414 if (WARN_ON(!priv
->cfg
->ops
->utils
->request_scan
))
417 priv
->cfg
->ops
->utils
->request_scan(priv
, NULL
);
419 mutex_unlock(&priv
->mutex
);
421 EXPORT_SYMBOL(iwl_bg_start_internal_scan
);
423 void iwl_bg_scan_check(struct work_struct
*data
)
425 struct iwl_priv
*priv
=
426 container_of(data
, struct iwl_priv
, scan_check
.work
);
428 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
431 mutex_lock(&priv
->mutex
);
432 if (test_bit(STATUS_SCANNING
, &priv
->status
) &&
433 !test_bit(STATUS_SCAN_ABORTING
, &priv
->status
)) {
434 IWL_DEBUG_SCAN(priv
, "Scan completion watchdog (%dms)\n",
435 jiffies_to_msecs(IWL_SCAN_CHECK_WATCHDOG
));
437 if (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
438 iwl_send_scan_abort(priv
);
440 mutex_unlock(&priv
->mutex
);
442 EXPORT_SYMBOL(iwl_bg_scan_check
);
445 * iwl_fill_probe_req - fill in all required fields and IE for probe request
448 u16
iwl_fill_probe_req(struct iwl_priv
*priv
, struct ieee80211_mgmt
*frame
,
449 const u8
*ta
, const u8
*ies
, int ie_len
, int left
)
454 /* Make sure there is enough space for the probe request,
455 * two mandatory IEs and the data */
460 frame
->frame_control
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
461 memcpy(frame
->da
, iwl_bcast_addr
, ETH_ALEN
);
462 memcpy(frame
->sa
, ta
, ETH_ALEN
);
463 memcpy(frame
->bssid
, iwl_bcast_addr
, ETH_ALEN
);
469 pos
= &frame
->u
.probe_req
.variable
[0];
471 /* fill in our indirect SSID IE */
475 *pos
++ = WLAN_EID_SSID
;
480 if (WARN_ON(left
< ie_len
))
484 memcpy(pos
, ies
, ie_len
);
490 EXPORT_SYMBOL(iwl_fill_probe_req
);
492 void iwl_bg_abort_scan(struct work_struct
*work
)
494 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, abort_scan
);
496 if (!test_bit(STATUS_READY
, &priv
->status
) ||
497 !test_bit(STATUS_GEO_CONFIGURED
, &priv
->status
))
500 cancel_delayed_work(&priv
->scan_check
);
502 mutex_lock(&priv
->mutex
);
503 if (test_bit(STATUS_SCAN_ABORTING
, &priv
->status
))
504 iwl_send_scan_abort(priv
);
505 mutex_unlock(&priv
->mutex
);
507 EXPORT_SYMBOL(iwl_bg_abort_scan
);
509 void iwl_bg_scan_completed(struct work_struct
*work
)
511 struct iwl_priv
*priv
=
512 container_of(work
, struct iwl_priv
, scan_completed
);
513 bool internal
= false;
515 IWL_DEBUG_SCAN(priv
, "SCAN complete scan\n");
517 cancel_delayed_work(&priv
->scan_check
);
519 mutex_lock(&priv
->mutex
);
520 if (priv
->is_internal_short_scan
) {
521 priv
->is_internal_short_scan
= false;
522 IWL_DEBUG_SCAN(priv
, "internal short scan completed\n");
525 priv
->scan_request
= NULL
;
526 priv
->scan_vif
= NULL
;
529 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
532 if (internal
&& priv
->scan_request
)
533 iwl_scan_initiate(priv
, priv
->scan_vif
);
535 /* Since setting the TXPOWER may have been deferred while
536 * performing the scan, fire one off */
537 iwl_set_tx_power(priv
, priv
->tx_power_user_lmt
, true);
540 * Since setting the RXON may have been deferred while
541 * performing the scan, fire one off if needed
543 if (memcmp(&priv
->active_rxon
,
544 &priv
->staging_rxon
, sizeof(priv
->staging_rxon
)))
545 iwlcore_commit_rxon(priv
);
548 mutex_unlock(&priv
->mutex
);
551 * Do not hold mutex here since this will cause mac80211 to call
552 * into driver again into functions that will attempt to take
556 ieee80211_scan_completed(priv
->hw
, false);
558 EXPORT_SYMBOL(iwl_bg_scan_completed
);
560 void iwl_setup_scan_deferred_work(struct iwl_priv
*priv
)
562 INIT_WORK(&priv
->scan_completed
, iwl_bg_scan_completed
);
563 INIT_WORK(&priv
->abort_scan
, iwl_bg_abort_scan
);
564 INIT_WORK(&priv
->start_internal_scan
, iwl_bg_start_internal_scan
);
565 INIT_DELAYED_WORK(&priv
->scan_check
, iwl_bg_scan_check
);
567 EXPORT_SYMBOL(iwl_setup_scan_deferred_work
);