2 * This file is part of wl1271
4 * Copyright (C) 2009-2010 Nokia Corporation
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/ieee80211.h>
34 void wl1271_scan_complete_work(struct work_struct
*work
)
36 struct delayed_work
*dwork
;
38 struct ieee80211_vif
*vif
;
39 struct wl12xx_vif
*wlvif
;
42 dwork
= container_of(work
, struct delayed_work
, work
);
43 wl
= container_of(dwork
, struct wl1271
, scan_complete_work
);
45 wl1271_debug(DEBUG_SCAN
, "Scanning complete");
47 mutex_lock(&wl
->mutex
);
49 if (wl
->state
== WL1271_STATE_OFF
)
52 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
56 wlvif
= wl12xx_vif_to_data(vif
);
59 * Rearm the tx watchdog just before idling scan. This
60 * prevents just-finished scans from triggering the watchdog
62 wl12xx_rearm_tx_watchdog_locked(wl
);
64 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
65 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
69 ret
= wl1271_ps_elp_wakeup(wl
);
73 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) {
74 /* restore hardware connection monitoring template */
75 wl1271_cmd_build_ap_probe_req(wl
, wlvif
, wlvif
->probereq
);
78 wl1271_ps_elp_sleep(wl
);
80 if (wl
->scan
.failed
) {
81 wl1271_info("Scan completed due to error.");
82 wl12xx_queue_recovery_work(wl
);
85 ieee80211_scan_completed(wl
->hw
, false);
88 mutex_unlock(&wl
->mutex
);
93 static int wl1271_get_scan_channels(struct wl1271
*wl
,
94 struct cfg80211_scan_request
*req
,
95 struct basic_scan_channel_params
*channels
,
96 enum ieee80211_band band
, bool passive
)
98 struct conf_scan_settings
*c
= &wl
->conf
.scan
;
103 i
< req
->n_channels
&& j
< WL1271_SCAN_MAX_CHANNELS
;
105 flags
= req
->channels
[i
]->flags
;
107 if (!test_bit(i
, wl
->scan
.scanned_ch
) &&
108 !(flags
& IEEE80211_CHAN_DISABLED
) &&
109 (req
->channels
[i
]->band
== band
) &&
111 * In passive scans, we scan all remaining
112 * channels, even if not marked as such.
113 * In active scans, we only scan channels not
116 (passive
|| !(flags
& IEEE80211_CHAN_PASSIVE_SCAN
))) {
117 wl1271_debug(DEBUG_SCAN
, "band %d, center_freq %d ",
118 req
->channels
[i
]->band
,
119 req
->channels
[i
]->center_freq
);
120 wl1271_debug(DEBUG_SCAN
, "hw_value %d, flags %X",
121 req
->channels
[i
]->hw_value
,
122 req
->channels
[i
]->flags
);
123 wl1271_debug(DEBUG_SCAN
,
124 "max_antenna_gain %d, max_power %d",
125 req
->channels
[i
]->max_antenna_gain
,
126 req
->channels
[i
]->max_power
);
127 wl1271_debug(DEBUG_SCAN
, "beacon_found %d",
128 req
->channels
[i
]->beacon_found
);
131 channels
[j
].min_duration
=
132 cpu_to_le32(c
->min_dwell_time_active
);
133 channels
[j
].max_duration
=
134 cpu_to_le32(c
->max_dwell_time_active
);
136 channels
[j
].min_duration
=
137 cpu_to_le32(c
->min_dwell_time_passive
);
138 channels
[j
].max_duration
=
139 cpu_to_le32(c
->max_dwell_time_passive
);
141 channels
[j
].early_termination
= 0;
142 channels
[j
].tx_power_att
= req
->channels
[i
]->max_power
;
143 channels
[j
].channel
= req
->channels
[i
]->hw_value
;
145 memset(&channels
[j
].bssid_lsb
, 0xff, 4);
146 memset(&channels
[j
].bssid_msb
, 0xff, 2);
148 /* Mark the channels we already used */
149 set_bit(i
, wl
->scan
.scanned_ch
);
158 #define WL1271_NOTHING_TO_SCAN 1
160 static int wl1271_scan_send(struct wl1271
*wl
, struct ieee80211_vif
*vif
,
161 enum ieee80211_band band
,
162 bool passive
, u32 basic_rate
)
164 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
165 struct wl1271_cmd_scan
*cmd
;
166 struct wl1271_cmd_trigger_scan_to
*trigger
;
168 u16 scan_options
= 0;
170 /* skip active scans if we don't have SSIDs */
171 if (!passive
&& wl
->scan
.req
->n_ssids
== 0)
172 return WL1271_NOTHING_TO_SCAN
;
174 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
175 trigger
= kzalloc(sizeof(*trigger
), GFP_KERNEL
);
176 if (!cmd
|| !trigger
) {
181 if (wl
->conf
.scan
.split_scan_timeout
)
182 scan_options
|= WL1271_SCAN_OPT_SPLIT_SCAN
;
185 scan_options
|= WL1271_SCAN_OPT_PASSIVE
;
187 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
||
188 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
189 cmd
->params
.role_id
= wlvif
->role_id
;
191 cmd
->params
.role_id
= wlvif
->dev_role_id
;
193 if (WARN_ON(cmd
->params
.role_id
== WL12XX_INVALID_ROLE_ID
)) {
198 cmd
->params
.scan_options
= cpu_to_le16(scan_options
);
200 cmd
->params
.n_ch
= wl1271_get_scan_channels(wl
, wl
->scan
.req
,
203 if (cmd
->params
.n_ch
== 0) {
204 ret
= WL1271_NOTHING_TO_SCAN
;
208 cmd
->params
.tx_rate
= cpu_to_le32(basic_rate
);
209 cmd
->params
.n_probe_reqs
= wl
->conf
.scan
.num_probe_reqs
;
210 cmd
->params
.tid_trigger
= CONF_TX_AC_ANY_TID
;
211 cmd
->params
.scan_tag
= WL1271_SCAN_DEFAULT_TAG
;
213 if (band
== IEEE80211_BAND_2GHZ
)
214 cmd
->params
.band
= WL1271_SCAN_BAND_2_4_GHZ
;
216 cmd
->params
.band
= WL1271_SCAN_BAND_5_GHZ
;
218 if (wl
->scan
.ssid_len
&& wl
->scan
.ssid
) {
219 cmd
->params
.ssid_len
= wl
->scan
.ssid_len
;
220 memcpy(cmd
->params
.ssid
, wl
->scan
.ssid
, wl
->scan
.ssid_len
);
223 memcpy(cmd
->addr
, vif
->addr
, ETH_ALEN
);
225 ret
= wl12xx_cmd_build_probe_req(wl
, wlvif
,
226 cmd
->params
.role_id
, band
,
227 wl
->scan
.ssid
, wl
->scan
.ssid_len
,
229 wl
->scan
.req
->ie_len
);
231 wl1271_error("PROBE request template failed");
235 trigger
->timeout
= cpu_to_le32(wl
->conf
.scan
.split_scan_timeout
);
236 ret
= wl1271_cmd_send(wl
, CMD_TRIGGER_SCAN_TO
, trigger
,
237 sizeof(*trigger
), 0);
239 wl1271_error("trigger scan to failed for hw scan");
243 wl1271_dump(DEBUG_SCAN
, "SCAN: ", cmd
, sizeof(*cmd
));
245 ret
= wl1271_cmd_send(wl
, CMD_SCAN
, cmd
, sizeof(*cmd
), 0);
247 wl1271_error("SCAN failed");
257 void wl1271_scan_stm(struct wl1271
*wl
, struct ieee80211_vif
*vif
)
259 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
261 enum ieee80211_band band
;
264 switch (wl
->scan
.state
) {
265 case WL1271_SCAN_STATE_IDLE
:
268 case WL1271_SCAN_STATE_2GHZ_ACTIVE
:
269 band
= IEEE80211_BAND_2GHZ
;
270 mask
= wlvif
->bitrate_masks
[band
];
271 if (wl
->scan
.req
->no_cck
) {
272 mask
&= ~CONF_TX_CCK_RATES
;
274 mask
= CONF_TX_RATE_MASK_BASIC_P2P
;
276 rate
= wl1271_tx_min_rate_get(wl
, mask
);
277 ret
= wl1271_scan_send(wl
, vif
, band
, false, rate
);
278 if (ret
== WL1271_NOTHING_TO_SCAN
) {
279 wl
->scan
.state
= WL1271_SCAN_STATE_2GHZ_PASSIVE
;
280 wl1271_scan_stm(wl
, vif
);
285 case WL1271_SCAN_STATE_2GHZ_PASSIVE
:
286 band
= IEEE80211_BAND_2GHZ
;
287 mask
= wlvif
->bitrate_masks
[band
];
288 if (wl
->scan
.req
->no_cck
) {
289 mask
&= ~CONF_TX_CCK_RATES
;
291 mask
= CONF_TX_RATE_MASK_BASIC_P2P
;
293 rate
= wl1271_tx_min_rate_get(wl
, mask
);
294 ret
= wl1271_scan_send(wl
, vif
, band
, true, rate
);
295 if (ret
== WL1271_NOTHING_TO_SCAN
) {
297 wl
->scan
.state
= WL1271_SCAN_STATE_5GHZ_ACTIVE
;
299 wl
->scan
.state
= WL1271_SCAN_STATE_DONE
;
300 wl1271_scan_stm(wl
, vif
);
305 case WL1271_SCAN_STATE_5GHZ_ACTIVE
:
306 band
= IEEE80211_BAND_5GHZ
;
307 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->bitrate_masks
[band
]);
308 ret
= wl1271_scan_send(wl
, vif
, band
, false, rate
);
309 if (ret
== WL1271_NOTHING_TO_SCAN
) {
310 wl
->scan
.state
= WL1271_SCAN_STATE_5GHZ_PASSIVE
;
311 wl1271_scan_stm(wl
, vif
);
316 case WL1271_SCAN_STATE_5GHZ_PASSIVE
:
317 band
= IEEE80211_BAND_5GHZ
;
318 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->bitrate_masks
[band
]);
319 ret
= wl1271_scan_send(wl
, vif
, band
, true, rate
);
320 if (ret
== WL1271_NOTHING_TO_SCAN
) {
321 wl
->scan
.state
= WL1271_SCAN_STATE_DONE
;
322 wl1271_scan_stm(wl
, vif
);
327 case WL1271_SCAN_STATE_DONE
:
328 wl
->scan
.failed
= false;
329 cancel_delayed_work(&wl
->scan_complete_work
);
330 ieee80211_queue_delayed_work(wl
->hw
, &wl
->scan_complete_work
,
331 msecs_to_jiffies(0));
335 wl1271_error("invalid scan state");
340 cancel_delayed_work(&wl
->scan_complete_work
);
341 ieee80211_queue_delayed_work(wl
->hw
, &wl
->scan_complete_work
,
342 msecs_to_jiffies(0));
346 int wl1271_scan(struct wl1271
*wl
, struct ieee80211_vif
*vif
,
347 const u8
*ssid
, size_t ssid_len
,
348 struct cfg80211_scan_request
*req
)
351 * cfg80211 should guarantee that we don't get more channels
352 * than what we have registered.
354 BUG_ON(req
->n_channels
> WL1271_MAX_CHANNELS
);
356 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
)
359 wl
->scan
.state
= WL1271_SCAN_STATE_2GHZ_ACTIVE
;
361 if (ssid_len
&& ssid
) {
362 wl
->scan
.ssid_len
= ssid_len
;
363 memcpy(wl
->scan
.ssid
, ssid
, ssid_len
);
365 wl
->scan
.ssid_len
= 0;
370 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
372 /* we assume failure so that timeout scenarios are handled correctly */
373 wl
->scan
.failed
= true;
374 ieee80211_queue_delayed_work(wl
->hw
, &wl
->scan_complete_work
,
375 msecs_to_jiffies(WL1271_SCAN_TIMEOUT
));
377 wl1271_scan_stm(wl
, vif
);
382 int wl1271_scan_stop(struct wl1271
*wl
)
384 struct wl1271_cmd_header
*cmd
= NULL
;
387 if (WARN_ON(wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
))
390 wl1271_debug(DEBUG_CMD
, "cmd scan stop");
392 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
398 ret
= wl1271_cmd_send(wl
, CMD_STOP_SCAN
, cmd
,
401 wl1271_error("cmd stop_scan failed");
410 wl1271_scan_get_sched_scan_channels(struct wl1271
*wl
,
411 struct cfg80211_sched_scan_request
*req
,
412 struct conn_scan_ch_params
*channels
,
413 u32 band
, bool radar
, bool passive
,
414 int start
, int max_channels
)
416 struct conf_sched_scan_settings
*c
= &wl
->conf
.sched_scan
;
419 bool force_passive
= !req
->n_ssids
;
420 u32 min_dwell_time_active
, max_dwell_time_active
, delta_per_probe
;
421 u32 dwell_time_passive
, dwell_time_dfs
;
423 if (band
== IEEE80211_BAND_5GHZ
)
424 delta_per_probe
= c
->dwell_time_delta_per_probe_5
;
426 delta_per_probe
= c
->dwell_time_delta_per_probe
;
428 min_dwell_time_active
= c
->base_dwell_time
+
429 req
->n_ssids
* c
->num_probe_reqs
* delta_per_probe
;
431 max_dwell_time_active
= min_dwell_time_active
+ c
->max_dwell_time_delta
;
433 min_dwell_time_active
= DIV_ROUND_UP(min_dwell_time_active
, 1000);
434 max_dwell_time_active
= DIV_ROUND_UP(max_dwell_time_active
, 1000);
435 dwell_time_passive
= DIV_ROUND_UP(c
->dwell_time_passive
, 1000);
436 dwell_time_dfs
= DIV_ROUND_UP(c
->dwell_time_dfs
, 1000);
438 for (i
= 0, j
= start
;
439 i
< req
->n_channels
&& j
< max_channels
;
441 flags
= req
->channels
[i
]->flags
;
444 flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
446 if ((req
->channels
[i
]->band
== band
) &&
447 !(flags
& IEEE80211_CHAN_DISABLED
) &&
448 (!!(flags
& IEEE80211_CHAN_RADAR
) == radar
) &&
449 /* if radar is set, we ignore the passive flag */
451 !!(flags
& IEEE80211_CHAN_PASSIVE_SCAN
) == passive
)) {
452 wl1271_debug(DEBUG_SCAN
, "band %d, center_freq %d ",
453 req
->channels
[i
]->band
,
454 req
->channels
[i
]->center_freq
);
455 wl1271_debug(DEBUG_SCAN
, "hw_value %d, flags %X",
456 req
->channels
[i
]->hw_value
,
457 req
->channels
[i
]->flags
);
458 wl1271_debug(DEBUG_SCAN
, "max_power %d",
459 req
->channels
[i
]->max_power
);
460 wl1271_debug(DEBUG_SCAN
, "min_dwell_time %d max dwell time %d",
461 min_dwell_time_active
,
462 max_dwell_time_active
);
464 if (flags
& IEEE80211_CHAN_RADAR
) {
465 channels
[j
].flags
|= SCAN_CHANNEL_FLAGS_DFS
;
467 channels
[j
].passive_duration
=
468 cpu_to_le16(dwell_time_dfs
);
470 channels
[j
].passive_duration
=
471 cpu_to_le16(dwell_time_passive
);
474 channels
[j
].min_duration
=
475 cpu_to_le16(min_dwell_time_active
);
476 channels
[j
].max_duration
=
477 cpu_to_le16(max_dwell_time_active
);
479 channels
[j
].tx_power_att
= req
->channels
[i
]->max_power
;
480 channels
[j
].channel
= req
->channels
[i
]->hw_value
;
490 wl1271_scan_sched_scan_channels(struct wl1271
*wl
,
491 struct cfg80211_sched_scan_request
*req
,
492 struct wl1271_cmd_sched_scan_config
*cfg
)
495 wl1271_scan_get_sched_scan_channels(wl
, req
, cfg
->channels_2
,
500 wl1271_scan_get_sched_scan_channels(wl
, req
, cfg
->channels_2
,
506 wl1271_scan_get_sched_scan_channels(wl
, req
, cfg
->channels_5
,
511 wl1271_scan_get_sched_scan_channels(wl
, req
, cfg
->channels_5
,
517 wl1271_scan_get_sched_scan_channels(wl
, req
, cfg
->channels_5
,
520 cfg
->passive
[1] + cfg
->dfs
,
522 /* 802.11j channels are not supported yet */
526 wl1271_debug(DEBUG_SCAN
, " 2.4GHz: active %d passive %d",
527 cfg
->active
[0], cfg
->passive
[0]);
528 wl1271_debug(DEBUG_SCAN
, " 5GHz: active %d passive %d",
529 cfg
->active
[1], cfg
->passive
[1]);
530 wl1271_debug(DEBUG_SCAN
, " DFS: %d", cfg
->dfs
);
532 return cfg
->passive
[0] || cfg
->active
[0] ||
533 cfg
->passive
[1] || cfg
->active
[1] || cfg
->dfs
||
534 cfg
->passive
[2] || cfg
->active
[2];
537 /* Returns the scan type to be used or a negative value on error */
539 wl12xx_scan_sched_scan_ssid_list(struct wl1271
*wl
,
540 struct cfg80211_sched_scan_request
*req
)
542 struct wl1271_cmd_sched_scan_ssid_list
*cmd
= NULL
;
543 struct cfg80211_match_set
*sets
= req
->match_sets
;
544 struct cfg80211_ssid
*ssids
= req
->ssids
;
545 int ret
= 0, type
, i
, j
, n_match_ssids
= 0;
547 wl1271_debug(DEBUG_CMD
, "cmd sched scan ssid list");
549 /* count the match sets that contain SSIDs */
550 for (i
= 0; i
< req
->n_match_sets
; i
++)
551 if (sets
[i
].ssid
.ssid_len
> 0)
554 /* No filter, no ssids or only bcast ssid */
555 if (!n_match_ssids
&&
557 (req
->n_ssids
== 1 && req
->ssids
[0].ssid_len
== 0))) {
558 type
= SCAN_SSID_FILTER_ANY
;
562 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
568 if (!n_match_ssids
) {
569 /* No filter, with ssids */
570 type
= SCAN_SSID_FILTER_DISABLED
;
572 for (i
= 0; i
< req
->n_ssids
; i
++) {
573 cmd
->ssids
[cmd
->n_ssids
].type
= (ssids
[i
].ssid_len
) ?
574 SCAN_SSID_TYPE_HIDDEN
: SCAN_SSID_TYPE_PUBLIC
;
575 cmd
->ssids
[cmd
->n_ssids
].len
= ssids
[i
].ssid_len
;
576 memcpy(cmd
->ssids
[cmd
->n_ssids
].ssid
, ssids
[i
].ssid
,
581 type
= SCAN_SSID_FILTER_LIST
;
583 /* Add all SSIDs from the filters */
584 for (i
= 0; i
< req
->n_match_sets
; i
++) {
585 /* ignore sets without SSIDs */
586 if (!sets
[i
].ssid
.ssid_len
)
589 cmd
->ssids
[cmd
->n_ssids
].type
= SCAN_SSID_TYPE_PUBLIC
;
590 cmd
->ssids
[cmd
->n_ssids
].len
= sets
[i
].ssid
.ssid_len
;
591 memcpy(cmd
->ssids
[cmd
->n_ssids
].ssid
,
592 sets
[i
].ssid
.ssid
, sets
[i
].ssid
.ssid_len
);
595 if ((req
->n_ssids
> 1) ||
596 (req
->n_ssids
== 1 && req
->ssids
[0].ssid_len
> 0)) {
598 * Mark all the SSIDs passed in the SSID list as HIDDEN,
599 * so they're used in probe requests.
601 for (i
= 0; i
< req
->n_ssids
; i
++) {
602 if (!req
->ssids
[i
].ssid_len
)
605 for (j
= 0; j
< cmd
->n_ssids
; j
++)
606 if (!memcmp(req
->ssids
[i
].ssid
,
608 req
->ssids
[i
].ssid_len
)) {
610 SCAN_SSID_TYPE_HIDDEN
;
613 /* Fail if SSID isn't present in the filters */
614 if (j
== cmd
->n_ssids
) {
622 wl1271_dump(DEBUG_SCAN
, "SSID_LIST: ", cmd
, sizeof(*cmd
));
624 ret
= wl1271_cmd_send(wl
, CMD_CONNECTION_SCAN_SSID_CFG
, cmd
,
627 wl1271_error("cmd sched scan ssid list failed");
639 int wl1271_scan_sched_scan_config(struct wl1271
*wl
,
640 struct wl12xx_vif
*wlvif
,
641 struct cfg80211_sched_scan_request
*req
,
642 struct ieee80211_sched_scan_ies
*ies
)
644 struct wl1271_cmd_sched_scan_config
*cfg
= NULL
;
645 struct conf_sched_scan_settings
*c
= &wl
->conf
.sched_scan
;
647 bool force_passive
= !req
->n_ssids
;
649 wl1271_debug(DEBUG_CMD
, "cmd sched_scan scan config");
651 cfg
= kzalloc(sizeof(*cfg
), GFP_KERNEL
);
655 cfg
->rssi_threshold
= c
->rssi_threshold
;
656 cfg
->snr_threshold
= c
->snr_threshold
;
657 cfg
->n_probe_reqs
= c
->num_probe_reqs
;
658 /* cycles set to 0 it means infinite (until manually stopped) */
660 /* report APs when at least 1 is found */
661 cfg
->report_after
= 1;
662 /* don't stop scanning automatically when something is found */
664 cfg
->tag
= WL1271_SCAN_DEFAULT_TAG
;
665 /* don't filter on BSS type */
666 cfg
->bss_type
= SCAN_BSS_TYPE_ANY
;
667 /* currently NL80211 supports only a single interval */
668 for (i
= 0; i
< SCAN_MAX_CYCLE_INTERVALS
; i
++)
669 cfg
->intervals
[i
] = cpu_to_le32(req
->interval
);
672 ret
= wl12xx_scan_sched_scan_ssid_list(wl
, req
);
676 cfg
->filter_type
= ret
;
678 wl1271_debug(DEBUG_SCAN
, "filter_type = %d", cfg
->filter_type
);
680 if (!wl1271_scan_sched_scan_channels(wl
, req
, cfg
)) {
681 wl1271_error("scan channel list is empty");
686 if (!force_passive
&& cfg
->active
[0]) {
687 u8 band
= IEEE80211_BAND_2GHZ
;
688 ret
= wl12xx_cmd_build_probe_req(wl
, wlvif
,
689 wlvif
->dev_role_id
, band
,
691 req
->ssids
[0].ssid_len
,
695 wl1271_error("2.4GHz PROBE request template failed");
700 if (!force_passive
&& cfg
->active
[1]) {
701 u8 band
= IEEE80211_BAND_5GHZ
;
702 ret
= wl12xx_cmd_build_probe_req(wl
, wlvif
,
703 wlvif
->dev_role_id
, band
,
705 req
->ssids
[0].ssid_len
,
709 wl1271_error("5GHz PROBE request template failed");
714 wl1271_dump(DEBUG_SCAN
, "SCAN_CFG: ", cfg
, sizeof(*cfg
));
716 ret
= wl1271_cmd_send(wl
, CMD_CONNECTION_SCAN_CFG
, cfg
,
719 wl1271_error("SCAN configuration failed");
727 int wl1271_scan_sched_scan_start(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
729 struct wl1271_cmd_sched_scan_start
*start
;
732 wl1271_debug(DEBUG_CMD
, "cmd periodic scan start");
734 if (wlvif
->bss_type
!= BSS_TYPE_STA_BSS
)
737 if (test_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
))
740 start
= kzalloc(sizeof(*start
), GFP_KERNEL
);
744 start
->tag
= WL1271_SCAN_DEFAULT_TAG
;
746 ret
= wl1271_cmd_send(wl
, CMD_START_PERIODIC_SCAN
, start
,
749 wl1271_error("failed to send scan start command");
758 void wl1271_scan_sched_scan_results(struct wl1271
*wl
)
760 wl1271_debug(DEBUG_SCAN
, "got periodic scan results");
762 ieee80211_sched_scan_results(wl
->hw
);
765 void wl1271_scan_sched_scan_stop(struct wl1271
*wl
)
767 struct wl1271_cmd_sched_scan_stop
*stop
;
770 wl1271_debug(DEBUG_CMD
, "cmd periodic scan stop");
772 /* FIXME: what to do if alloc'ing to stop fails? */
773 stop
= kzalloc(sizeof(*stop
), GFP_KERNEL
);
775 wl1271_error("failed to alloc memory to send sched scan stop");
779 stop
->tag
= WL1271_SCAN_DEFAULT_TAG
;
781 ret
= wl1271_cmd_send(wl
, CMD_STOP_PERIODIC_SCAN
, stop
,
784 wl1271_error("failed to send sched scan stop command");