1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * This file is part of wl12xx |
4 | * |
5 | * Copyright (C) 2012 Texas Instruments. All rights reserved. |
6 | */ |
7 | |
8 | #include <linux/ieee80211.h> |
9 | #include "scan.h" |
10 | #include "../wlcore/debug.h" |
11 | #include "../wlcore/tx.h" |
12 | |
13 | static int wl1271_get_scan_channels(struct wl1271 *wl, |
14 | struct cfg80211_scan_request *req, |
15 | struct basic_scan_channel_params *channels, |
16 | enum nl80211_band band, bool passive) |
17 | { |
18 | struct conf_scan_settings *c = &wl->conf.scan; |
19 | int i, j; |
20 | u32 flags; |
21 | |
22 | for (i = 0, j = 0; |
23 | i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS; |
24 | i++) { |
25 | flags = req->channels[i]->flags; |
26 | |
27 | if (!test_bit(i, wl->scan.scanned_ch) && |
28 | !(flags & IEEE80211_CHAN_DISABLED) && |
29 | (req->channels[i]->band == band) && |
30 | /* |
31 | * In passive scans, we scan all remaining |
32 | * channels, even if not marked as such. |
33 | * In active scans, we only scan channels not |
34 | * marked as passive. |
35 | */ |
36 | (passive || !(flags & IEEE80211_CHAN_NO_IR))) { |
37 | wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d " , |
38 | req->channels[i]->band, |
39 | req->channels[i]->center_freq); |
40 | wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X" , |
41 | req->channels[i]->hw_value, |
42 | req->channels[i]->flags); |
43 | wl1271_debug(DEBUG_SCAN, |
44 | "max_antenna_gain %d, max_power %d" , |
45 | req->channels[i]->max_antenna_gain, |
46 | req->channels[i]->max_power); |
47 | wl1271_debug(DEBUG_SCAN, "beacon_found %d" , |
48 | req->channels[i]->beacon_found); |
49 | |
50 | if (!passive) { |
51 | channels[j].min_duration = |
52 | cpu_to_le32(c->min_dwell_time_active); |
53 | channels[j].max_duration = |
54 | cpu_to_le32(c->max_dwell_time_active); |
55 | } else { |
56 | channels[j].min_duration = |
57 | cpu_to_le32(c->dwell_time_passive); |
58 | channels[j].max_duration = |
59 | cpu_to_le32(c->dwell_time_passive); |
60 | } |
61 | channels[j].early_termination = 0; |
62 | channels[j].tx_power_att = req->channels[i]->max_power; |
63 | channels[j].channel = req->channels[i]->hw_value; |
64 | |
65 | memset(&channels[j].bssid_lsb, 0xff, 4); |
66 | memset(&channels[j].bssid_msb, 0xff, 2); |
67 | |
68 | /* Mark the channels we already used */ |
69 | set_bit(nr: i, addr: wl->scan.scanned_ch); |
70 | |
71 | j++; |
72 | } |
73 | } |
74 | |
75 | return j; |
76 | } |
77 | |
78 | #define WL1271_NOTHING_TO_SCAN 1 |
79 | |
80 | static int wl1271_scan_send(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
81 | enum nl80211_band band, |
82 | bool passive, u32 basic_rate) |
83 | { |
84 | struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif); |
85 | struct wl1271_cmd_scan *cmd; |
86 | struct wl1271_cmd_trigger_scan_to *trigger; |
87 | int ret; |
88 | u16 scan_options = 0; |
89 | |
90 | /* skip active scans if we don't have SSIDs */ |
91 | if (!passive && wl->scan.req->n_ssids == 0) |
92 | return WL1271_NOTHING_TO_SCAN; |
93 | |
94 | cmd = kzalloc(size: sizeof(*cmd), GFP_KERNEL); |
95 | trigger = kzalloc(size: sizeof(*trigger), GFP_KERNEL); |
96 | if (!cmd || !trigger) { |
97 | ret = -ENOMEM; |
98 | goto out; |
99 | } |
100 | |
101 | if (wl->conf.scan.split_scan_timeout) |
102 | scan_options |= WL1271_SCAN_OPT_SPLIT_SCAN; |
103 | |
104 | if (passive) |
105 | scan_options |= WL1271_SCAN_OPT_PASSIVE; |
106 | |
107 | /* scan on the dev role if the regular one is not started */ |
108 | if (wlcore_is_p2p_mgmt(wlvif)) |
109 | cmd->params.role_id = wlvif->dev_role_id; |
110 | else |
111 | cmd->params.role_id = wlvif->role_id; |
112 | |
113 | if (WARN_ON(cmd->params.role_id == WL12XX_INVALID_ROLE_ID)) { |
114 | ret = -EINVAL; |
115 | goto out; |
116 | } |
117 | |
118 | cmd->params.scan_options = cpu_to_le16(scan_options); |
119 | |
120 | cmd->params.n_ch = wl1271_get_scan_channels(wl, req: wl->scan.req, |
121 | channels: cmd->channels, |
122 | band, passive); |
123 | if (cmd->params.n_ch == 0) { |
124 | ret = WL1271_NOTHING_TO_SCAN; |
125 | goto out; |
126 | } |
127 | |
128 | cmd->params.tx_rate = cpu_to_le32(basic_rate); |
129 | cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs; |
130 | cmd->params.tid_trigger = CONF_TX_AC_ANY_TID; |
131 | cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG; |
132 | |
133 | if (band == NL80211_BAND_2GHZ) |
134 | cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ; |
135 | else |
136 | cmd->params.band = WL1271_SCAN_BAND_5_GHZ; |
137 | |
138 | if (wl->scan.ssid_len) { |
139 | cmd->params.ssid_len = wl->scan.ssid_len; |
140 | memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len); |
141 | } |
142 | |
143 | memcpy(cmd->addr, vif->addr, ETH_ALEN); |
144 | |
145 | ret = wl12xx_cmd_build_probe_req(wl, wlvif, |
146 | role_id: cmd->params.role_id, band, |
147 | ssid: wl->scan.ssid, ssid_len: wl->scan.ssid_len, |
148 | ie: wl->scan.req->ie, |
149 | ie_len: wl->scan.req->ie_len, NULL, common_ie_len: 0, sched_scan: false); |
150 | if (ret < 0) { |
151 | wl1271_error("PROBE request template failed" ); |
152 | goto out; |
153 | } |
154 | |
155 | trigger->timeout = cpu_to_le32(wl->conf.scan.split_scan_timeout); |
156 | ret = wl1271_cmd_send(wl, id: CMD_TRIGGER_SCAN_TO, buf: trigger, |
157 | len: sizeof(*trigger), res_len: 0); |
158 | if (ret < 0) { |
159 | wl1271_error("trigger scan to failed for hw scan" ); |
160 | goto out; |
161 | } |
162 | |
163 | wl1271_dump(DEBUG_SCAN, "SCAN: " , cmd, sizeof(*cmd)); |
164 | |
165 | ret = wl1271_cmd_send(wl, id: CMD_SCAN, buf: cmd, len: sizeof(*cmd), res_len: 0); |
166 | if (ret < 0) { |
167 | wl1271_error("SCAN failed" ); |
168 | goto out; |
169 | } |
170 | |
171 | out: |
172 | kfree(objp: cmd); |
173 | kfree(objp: trigger); |
174 | return ret; |
175 | } |
176 | |
177 | int wl12xx_scan_stop(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
178 | { |
179 | struct wl1271_cmd_header *cmd = NULL; |
180 | int ret = 0; |
181 | |
182 | if (WARN_ON(wl->scan.state == WL1271_SCAN_STATE_IDLE)) |
183 | return -EINVAL; |
184 | |
185 | wl1271_debug(DEBUG_CMD, "cmd scan stop" ); |
186 | |
187 | cmd = kzalloc(size: sizeof(*cmd), GFP_KERNEL); |
188 | if (!cmd) { |
189 | ret = -ENOMEM; |
190 | goto out; |
191 | } |
192 | |
193 | ret = wl1271_cmd_send(wl, id: CMD_STOP_SCAN, buf: cmd, |
194 | len: sizeof(*cmd), res_len: 0); |
195 | if (ret < 0) { |
196 | wl1271_error("cmd stop_scan failed" ); |
197 | goto out; |
198 | } |
199 | out: |
200 | kfree(objp: cmd); |
201 | return ret; |
202 | } |
203 | |
204 | void wl1271_scan_stm(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
205 | { |
206 | int ret = 0; |
207 | enum nl80211_band band; |
208 | u32 rate, mask; |
209 | |
210 | switch (wl->scan.state) { |
211 | case WL1271_SCAN_STATE_IDLE: |
212 | break; |
213 | |
214 | case WL1271_SCAN_STATE_2GHZ_ACTIVE: |
215 | band = NL80211_BAND_2GHZ; |
216 | mask = wlvif->bitrate_masks[band]; |
217 | if (wl->scan.req->no_cck) { |
218 | mask &= ~CONF_TX_CCK_RATES; |
219 | if (!mask) |
220 | mask = CONF_TX_RATE_MASK_BASIC_P2P; |
221 | } |
222 | rate = wl1271_tx_min_rate_get(wl, rate_set: mask); |
223 | ret = wl1271_scan_send(wl, wlvif, band, passive: false, basic_rate: rate); |
224 | if (ret == WL1271_NOTHING_TO_SCAN) { |
225 | wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE; |
226 | wl1271_scan_stm(wl, wlvif); |
227 | } |
228 | |
229 | break; |
230 | |
231 | case WL1271_SCAN_STATE_2GHZ_PASSIVE: |
232 | band = NL80211_BAND_2GHZ; |
233 | mask = wlvif->bitrate_masks[band]; |
234 | if (wl->scan.req->no_cck) { |
235 | mask &= ~CONF_TX_CCK_RATES; |
236 | if (!mask) |
237 | mask = CONF_TX_RATE_MASK_BASIC_P2P; |
238 | } |
239 | rate = wl1271_tx_min_rate_get(wl, rate_set: mask); |
240 | ret = wl1271_scan_send(wl, wlvif, band, passive: true, basic_rate: rate); |
241 | if (ret == WL1271_NOTHING_TO_SCAN) { |
242 | if (wl->enable_11a) |
243 | wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE; |
244 | else |
245 | wl->scan.state = WL1271_SCAN_STATE_DONE; |
246 | wl1271_scan_stm(wl, wlvif); |
247 | } |
248 | |
249 | break; |
250 | |
251 | case WL1271_SCAN_STATE_5GHZ_ACTIVE: |
252 | band = NL80211_BAND_5GHZ; |
253 | rate = wl1271_tx_min_rate_get(wl, rate_set: wlvif->bitrate_masks[band]); |
254 | ret = wl1271_scan_send(wl, wlvif, band, passive: false, basic_rate: rate); |
255 | if (ret == WL1271_NOTHING_TO_SCAN) { |
256 | wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE; |
257 | wl1271_scan_stm(wl, wlvif); |
258 | } |
259 | |
260 | break; |
261 | |
262 | case WL1271_SCAN_STATE_5GHZ_PASSIVE: |
263 | band = NL80211_BAND_5GHZ; |
264 | rate = wl1271_tx_min_rate_get(wl, rate_set: wlvif->bitrate_masks[band]); |
265 | ret = wl1271_scan_send(wl, wlvif, band, passive: true, basic_rate: rate); |
266 | if (ret == WL1271_NOTHING_TO_SCAN) { |
267 | wl->scan.state = WL1271_SCAN_STATE_DONE; |
268 | wl1271_scan_stm(wl, wlvif); |
269 | } |
270 | |
271 | break; |
272 | |
273 | case WL1271_SCAN_STATE_DONE: |
274 | wl->scan.failed = false; |
275 | cancel_delayed_work(dwork: &wl->scan_complete_work); |
276 | ieee80211_queue_delayed_work(hw: wl->hw, dwork: &wl->scan_complete_work, |
277 | delay: msecs_to_jiffies(m: 0)); |
278 | break; |
279 | |
280 | default: |
281 | wl1271_error("invalid scan state" ); |
282 | break; |
283 | } |
284 | |
285 | if (ret < 0) { |
286 | cancel_delayed_work(dwork: &wl->scan_complete_work); |
287 | ieee80211_queue_delayed_work(hw: wl->hw, dwork: &wl->scan_complete_work, |
288 | delay: msecs_to_jiffies(m: 0)); |
289 | } |
290 | } |
291 | |
292 | static void wl12xx_adjust_channels(struct wl1271_cmd_sched_scan_config *cmd, |
293 | struct wlcore_scan_channels *cmd_channels) |
294 | { |
295 | memcpy(cmd->passive, cmd_channels->passive, sizeof(cmd->passive)); |
296 | memcpy(cmd->active, cmd_channels->active, sizeof(cmd->active)); |
297 | cmd->dfs = cmd_channels->dfs; |
298 | cmd->n_pactive_ch = cmd_channels->passive_active; |
299 | |
300 | memcpy(cmd->channels_2, cmd_channels->channels_2, |
301 | sizeof(cmd->channels_2)); |
302 | memcpy(cmd->channels_5, cmd_channels->channels_5, |
303 | sizeof(cmd->channels_5)); |
304 | /* channels_4 are not supported, so no need to copy them */ |
305 | } |
306 | |
307 | int wl1271_scan_sched_scan_config(struct wl1271 *wl, |
308 | struct wl12xx_vif *wlvif, |
309 | struct cfg80211_sched_scan_request *req, |
310 | struct ieee80211_scan_ies *ies) |
311 | { |
312 | struct wl1271_cmd_sched_scan_config *cfg = NULL; |
313 | struct wlcore_scan_channels *cfg_channels = NULL; |
314 | struct conf_sched_scan_settings *c = &wl->conf.sched_scan; |
315 | int i, ret; |
316 | bool force_passive = !req->n_ssids; |
317 | |
318 | wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config" ); |
319 | |
320 | cfg = kzalloc(size: sizeof(*cfg), GFP_KERNEL); |
321 | if (!cfg) |
322 | return -ENOMEM; |
323 | |
324 | cfg->role_id = wlvif->role_id; |
325 | cfg->rssi_threshold = c->rssi_threshold; |
326 | cfg->snr_threshold = c->snr_threshold; |
327 | cfg->n_probe_reqs = c->num_probe_reqs; |
328 | /* cycles set to 0 it means infinite (until manually stopped) */ |
329 | cfg->cycles = 0; |
330 | /* report APs when at least 1 is found */ |
331 | cfg->report_after = 1; |
332 | /* don't stop scanning automatically when something is found */ |
333 | cfg->terminate = 0; |
334 | cfg->tag = WL1271_SCAN_DEFAULT_TAG; |
335 | /* don't filter on BSS type */ |
336 | cfg->bss_type = SCAN_BSS_TYPE_ANY; |
337 | /* currently NL80211 supports only a single interval */ |
338 | for (i = 0; i < SCAN_MAX_CYCLE_INTERVALS; i++) |
339 | cfg->intervals[i] = cpu_to_le32(req->scan_plans[0].interval * |
340 | MSEC_PER_SEC); |
341 | |
342 | cfg->ssid_len = 0; |
343 | ret = wlcore_scan_sched_scan_ssid_list(wl, wlvif, req); |
344 | if (ret < 0) |
345 | goto out; |
346 | |
347 | cfg->filter_type = ret; |
348 | |
349 | wl1271_debug(DEBUG_SCAN, "filter_type = %d" , cfg->filter_type); |
350 | |
351 | cfg_channels = kzalloc(size: sizeof(*cfg_channels), GFP_KERNEL); |
352 | if (!cfg_channels) { |
353 | ret = -ENOMEM; |
354 | goto out; |
355 | } |
356 | |
357 | if (!wlcore_set_scan_chan_params(wl, cfg: cfg_channels, channels: req->channels, |
358 | n_channels: req->n_channels, n_ssids: req->n_ssids, |
359 | scan_type: SCAN_TYPE_PERIODIC)) { |
360 | wl1271_error("scan channel list is empty" ); |
361 | ret = -EINVAL; |
362 | goto out; |
363 | } |
364 | wl12xx_adjust_channels(cmd: cfg, cmd_channels: cfg_channels); |
365 | |
366 | if (!force_passive && cfg->active[0]) { |
367 | u8 band = NL80211_BAND_2GHZ; |
368 | ret = wl12xx_cmd_build_probe_req(wl, wlvif, |
369 | role_id: wlvif->role_id, band, |
370 | ssid: req->ssids[0].ssid, |
371 | ssid_len: req->ssids[0].ssid_len, |
372 | ie: ies->ies[band], |
373 | ie_len: ies->len[band], |
374 | common_ie: ies->common_ies, |
375 | common_ie_len: ies->common_ie_len, |
376 | sched_scan: true); |
377 | if (ret < 0) { |
378 | wl1271_error("2.4GHz PROBE request template failed" ); |
379 | goto out; |
380 | } |
381 | } |
382 | |
383 | if (!force_passive && cfg->active[1]) { |
384 | u8 band = NL80211_BAND_5GHZ; |
385 | ret = wl12xx_cmd_build_probe_req(wl, wlvif, |
386 | role_id: wlvif->role_id, band, |
387 | ssid: req->ssids[0].ssid, |
388 | ssid_len: req->ssids[0].ssid_len, |
389 | ie: ies->ies[band], |
390 | ie_len: ies->len[band], |
391 | common_ie: ies->common_ies, |
392 | common_ie_len: ies->common_ie_len, |
393 | sched_scan: true); |
394 | if (ret < 0) { |
395 | wl1271_error("5GHz PROBE request template failed" ); |
396 | goto out; |
397 | } |
398 | } |
399 | |
400 | wl1271_dump(DEBUG_SCAN, "SCAN_CFG: " , cfg, sizeof(*cfg)); |
401 | |
402 | ret = wl1271_cmd_send(wl, id: CMD_CONNECTION_SCAN_CFG, buf: cfg, |
403 | len: sizeof(*cfg), res_len: 0); |
404 | if (ret < 0) { |
405 | wl1271_error("SCAN configuration failed" ); |
406 | goto out; |
407 | } |
408 | out: |
409 | kfree(objp: cfg_channels); |
410 | kfree(objp: cfg); |
411 | return ret; |
412 | } |
413 | |
414 | int wl1271_scan_sched_scan_start(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
415 | { |
416 | struct wl1271_cmd_sched_scan_start *start; |
417 | int ret = 0; |
418 | |
419 | wl1271_debug(DEBUG_CMD, "cmd periodic scan start" ); |
420 | |
421 | if (wlvif->bss_type != BSS_TYPE_STA_BSS) |
422 | return -EOPNOTSUPP; |
423 | |
424 | if ((wl->quirks & WLCORE_QUIRK_NO_SCHED_SCAN_WHILE_CONN) && |
425 | test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) |
426 | return -EBUSY; |
427 | |
428 | start = kzalloc(size: sizeof(*start), GFP_KERNEL); |
429 | if (!start) |
430 | return -ENOMEM; |
431 | |
432 | start->role_id = wlvif->role_id; |
433 | start->tag = WL1271_SCAN_DEFAULT_TAG; |
434 | |
435 | ret = wl1271_cmd_send(wl, id: CMD_START_PERIODIC_SCAN, buf: start, |
436 | len: sizeof(*start), res_len: 0); |
437 | if (ret < 0) { |
438 | wl1271_error("failed to send scan start command" ); |
439 | goto out_free; |
440 | } |
441 | |
442 | out_free: |
443 | kfree(objp: start); |
444 | return ret; |
445 | } |
446 | |
447 | int wl12xx_sched_scan_start(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
448 | struct cfg80211_sched_scan_request *req, |
449 | struct ieee80211_scan_ies *ies) |
450 | { |
451 | int ret; |
452 | |
453 | ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies); |
454 | if (ret < 0) |
455 | return ret; |
456 | |
457 | return wl1271_scan_sched_scan_start(wl, wlvif); |
458 | } |
459 | |
460 | void wl12xx_scan_sched_scan_stop(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
461 | { |
462 | struct wl1271_cmd_sched_scan_stop *stop; |
463 | int ret = 0; |
464 | |
465 | wl1271_debug(DEBUG_CMD, "cmd periodic scan stop" ); |
466 | |
467 | /* FIXME: what to do if alloc'ing to stop fails? */ |
468 | stop = kzalloc(size: sizeof(*stop), GFP_KERNEL); |
469 | if (!stop) { |
470 | wl1271_error("failed to alloc memory to send sched scan stop" ); |
471 | return; |
472 | } |
473 | |
474 | stop->role_id = wlvif->role_id; |
475 | stop->tag = WL1271_SCAN_DEFAULT_TAG; |
476 | |
477 | ret = wl1271_cmd_send(wl, id: CMD_STOP_PERIODIC_SCAN, buf: stop, |
478 | len: sizeof(*stop), res_len: 0); |
479 | if (ret < 0) { |
480 | wl1271_error("failed to send sched scan stop command" ); |
481 | goto out_free; |
482 | } |
483 | |
484 | out_free: |
485 | kfree(objp: stop); |
486 | } |
487 | |
488 | int wl12xx_scan_start(struct wl1271 *wl, struct wl12xx_vif *wlvif, |
489 | struct cfg80211_scan_request *req) |
490 | { |
491 | wl1271_scan_stm(wl, wlvif); |
492 | return 0; |
493 | } |
494 | |
495 | void wl12xx_scan_completed(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
496 | { |
497 | wl1271_scan_stm(wl, wlvif); |
498 | } |
499 | |