1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68#include <linux/etherdevice.h>
69#include <net/mac80211.h>
70
71#include "mvm.h"
72#include "fw-api-scan.h"
73
74#define IWL_DENSE_EBS_SCAN_RATIO 5
75#define IWL_SPARSE_EBS_SCAN_RATIO 1
76
77enum iwl_mvm_traffic_load {
78 IWL_MVM_TRAFFIC_LOW,
79 IWL_MVM_TRAFFIC_MEDIUM,
80 IWL_MVM_TRAFFIC_HIGH,
81};
82
83struct iwl_mvm_scan_timing_params {
84 u32 dwell_active;
85 u32 dwell_passive;
86 u32 dwell_fragmented;
87 u32 dwell_extended;
88 u32 suspend_time;
89 u32 max_out_time;
90};
91
92static struct iwl_mvm_scan_timing_params scan_timing[] = {
93 [IWL_SCAN_TYPE_UNASSOC] = {
94 .dwell_active = 10,
95 .dwell_passive = 110,
96 .dwell_fragmented = 44,
97 .dwell_extended = 90,
98 .suspend_time = 0,
99 .max_out_time = 0,
100 },
101 [IWL_SCAN_TYPE_WILD] = {
102 .dwell_active = 10,
103 .dwell_passive = 110,
104 .dwell_fragmented = 44,
105 .dwell_extended = 90,
106 .suspend_time = 30,
107 .max_out_time = 120,
108 },
109 [IWL_SCAN_TYPE_MILD] = {
110 .dwell_active = 10,
111 .dwell_passive = 110,
112 .dwell_fragmented = 44,
113 .dwell_extended = 90,
114 .suspend_time = 120,
115 .max_out_time = 120,
116 },
117 [IWL_SCAN_TYPE_FRAGMENTED] = {
118 .dwell_active = 10,
119 .dwell_passive = 110,
120 .dwell_fragmented = 44,
121 .suspend_time = 95,
122 .max_out_time = 44,
123 },
124};
125
126struct iwl_mvm_scan_params {
127 enum iwl_mvm_scan_type type;
128 u32 n_channels;
129 u16 delay;
130 int n_ssids;
131 struct cfg80211_ssid *ssids;
132 struct ieee80211_channel **channels;
133 u32 flags;
134 u8 *mac_addr;
135 u8 *mac_addr_mask;
136 bool no_cck;
137 bool pass_all;
138 int n_match_sets;
139 struct iwl_scan_probe_req preq;
140 struct cfg80211_match_set *match_sets;
141 int n_scan_plans;
142 struct cfg80211_sched_scan_plan *scan_plans;
143};
144
145static u8 iwl_mvm_scan_rx_ant(struct iwl_mvm *mvm)
146{
147 if (mvm->scan_rx_ant != ANT_NONE)
148 return mvm->scan_rx_ant;
149 return iwl_mvm_get_valid_rx_ant(mvm);
150}
151
152static inline __le16 iwl_mvm_scan_rx_chain(struct iwl_mvm *mvm)
153{
154 u16 rx_chain;
155 u8 rx_ant;
156
157 rx_ant = iwl_mvm_scan_rx_ant(mvm);
158 rx_chain = rx_ant << PHY_RX_CHAIN_VALID_POS;
159 rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_MIMO_SEL_POS;
160 rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_SEL_POS;
161 rx_chain |= 0x1 << PHY_RX_CHAIN_DRIVER_FORCE_POS;
162 return cpu_to_le16(rx_chain);
163}
164
165static __le32 iwl_mvm_scan_rxon_flags(enum ieee80211_band band)
166{
167 if (band == IEEE80211_BAND_2GHZ)
168 return cpu_to_le32(PHY_BAND_24);
169 else
170 return cpu_to_le32(PHY_BAND_5);
171}
172
173static inline __le32
174iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum ieee80211_band band,
175 bool no_cck)
176{
177 u32 tx_ant;
178
179 mvm->scan_last_antenna_idx =
180 iwl_mvm_next_antenna(mvm, iwl_mvm_get_valid_tx_ant(mvm),
181 mvm->scan_last_antenna_idx);
182 tx_ant = BIT(mvm->scan_last_antenna_idx) << RATE_MCS_ANT_POS;
183
184 if (band == IEEE80211_BAND_2GHZ && !no_cck)
185 return cpu_to_le32(IWL_RATE_1M_PLCP | RATE_MCS_CCK_MSK |
186 tx_ant);
187 else
188 return cpu_to_le32(IWL_RATE_6M_PLCP | tx_ant);
189}
190
191static void iwl_mvm_scan_condition_iterator(void *data, u8 *mac,
192 struct ieee80211_vif *vif)
193{
194 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
195 int *global_cnt = data;
196
197 if (vif->type != NL80211_IFTYPE_P2P_DEVICE && mvmvif->phy_ctxt &&
198 mvmvif->phy_ctxt->id < MAX_PHYS)
199 *global_cnt += 1;
200}
201
202static enum iwl_mvm_traffic_load iwl_mvm_get_traffic_load(struct iwl_mvm *mvm)
203{
204 return IWL_MVM_TRAFFIC_LOW;
205}
206
207static enum
208iwl_mvm_scan_type iwl_mvm_get_scan_type(struct iwl_mvm *mvm, bool p2p_device)
209{
210 int global_cnt = 0;
211 enum iwl_mvm_traffic_load load;
212 bool low_latency;
213
214 ieee80211_iterate_active_interfaces_atomic(mvm->hw,
215 IEEE80211_IFACE_ITER_NORMAL,
216 iwl_mvm_scan_condition_iterator,
217 &global_cnt);
218 if (!global_cnt)
219 return IWL_SCAN_TYPE_UNASSOC;
220
221 load = iwl_mvm_get_traffic_load(mvm);
222 low_latency = iwl_mvm_low_latency(mvm);
223
224 if ((load == IWL_MVM_TRAFFIC_HIGH || low_latency) && !p2p_device &&
225 fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_FRAGMENTED_SCAN))
226 return IWL_SCAN_TYPE_FRAGMENTED;
227
228 if (load >= IWL_MVM_TRAFFIC_MEDIUM || low_latency)
229 return IWL_SCAN_TYPE_MILD;
230
231 return IWL_SCAN_TYPE_WILD;
232}
233
234static inline bool iwl_mvm_rrm_scan_needed(struct iwl_mvm *mvm)
235{
236
237 return fw_has_capa(&mvm->fw->ucode_capa,
238 IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT);
239}
240
241static int iwl_mvm_max_scan_ie_fw_cmd_room(struct iwl_mvm *mvm)
242{
243 int max_probe_len;
244
245 max_probe_len = SCAN_OFFLOAD_PROBE_REQ_SIZE;
246
247
248 max_probe_len -= 24 + 2;
249
250
251 if (iwl_mvm_rrm_scan_needed(mvm))
252 max_probe_len -= 3;
253
254 return max_probe_len;
255}
256
257int iwl_mvm_max_scan_ie_len(struct iwl_mvm *mvm)
258{
259 int max_ie_len = iwl_mvm_max_scan_ie_fw_cmd_room(mvm);
260
261
262
263
264
265
266
267
268
269
270
271 return max_ie_len;
272}
273
274static u8 *iwl_mvm_dump_channel_list(struct iwl_scan_results_notif *res,
275 int num_res, u8 *buf, size_t buf_size)
276{
277 int i;
278 u8 *pos = buf, *end = buf + buf_size;
279
280 for (i = 0; pos < end && i < num_res; i++)
281 pos += snprintf(pos, end - pos, " %u", res[i].channel);
282
283
284 *(buf + buf_size - 1) = '\0';
285
286 return buf;
287}
288
289void iwl_mvm_rx_lmac_scan_iter_complete_notif(struct iwl_mvm *mvm,
290 struct iwl_rx_cmd_buffer *rxb)
291{
292 struct iwl_rx_packet *pkt = rxb_addr(rxb);
293 struct iwl_lmac_scan_complete_notif *notif = (void *)pkt->data;
294 u8 buf[256];
295
296 IWL_DEBUG_SCAN(mvm,
297 "Scan offload iteration complete: status=0x%x scanned channels=%d channels list: %s\n",
298 notif->status, notif->scanned_channels,
299 iwl_mvm_dump_channel_list(notif->results,
300 notif->scanned_channels, buf,
301 sizeof(buf)));
302
303 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_FOUND) {
304 IWL_DEBUG_SCAN(mvm, "Pass all scheduled scan results found\n");
305 ieee80211_sched_scan_results(mvm->hw);
306 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED;
307 }
308}
309
310void iwl_mvm_rx_scan_match_found(struct iwl_mvm *mvm,
311 struct iwl_rx_cmd_buffer *rxb)
312{
313 IWL_DEBUG_SCAN(mvm, "Scheduled scan results\n");
314 ieee80211_sched_scan_results(mvm->hw);
315}
316
317static const char *iwl_mvm_ebs_status_str(enum iwl_scan_ebs_status status)
318{
319 switch (status) {
320 case IWL_SCAN_EBS_SUCCESS:
321 return "successful";
322 case IWL_SCAN_EBS_INACTIVE:
323 return "inactive";
324 case IWL_SCAN_EBS_FAILED:
325 case IWL_SCAN_EBS_CHAN_NOT_FOUND:
326 default:
327 return "failed";
328 }
329}
330
331void iwl_mvm_rx_lmac_scan_complete_notif(struct iwl_mvm *mvm,
332 struct iwl_rx_cmd_buffer *rxb)
333{
334 struct iwl_rx_packet *pkt = rxb_addr(rxb);
335 struct iwl_periodic_scan_complete *scan_notif = (void *)pkt->data;
336 bool aborted = (scan_notif->status == IWL_SCAN_OFFLOAD_ABORTED);
337
338
339
340
341 if (WARN_ON_ONCE(fw_has_capa(&mvm->fw->ucode_capa,
342 IWL_UCODE_TLV_CAPA_UMAC_SCAN)))
343 return;
344
345
346 lockdep_assert_held(&mvm->mutex);
347
348
349
350
351
352
353
354
355
356
357
358 if (mvm->scan_status & IWL_MVM_SCAN_STOPPING_SCHED) {
359 WARN_ON_ONCE(mvm->scan_status & IWL_MVM_SCAN_STOPPING_REGULAR);
360
361 IWL_DEBUG_SCAN(mvm, "Scheduled scan %s, EBS status %s\n",
362 aborted ? "aborted" : "completed",
363 iwl_mvm_ebs_status_str(scan_notif->ebs_status));
364 IWL_DEBUG_SCAN(mvm,
365 "Last line %d, Last iteration %d, Time after last iteration %d\n",
366 scan_notif->last_schedule_line,
367 scan_notif->last_schedule_iteration,
368 __le32_to_cpu(scan_notif->time_after_last_iter));
369
370 mvm->scan_status &= ~IWL_MVM_SCAN_STOPPING_SCHED;
371 } else if (mvm->scan_status & IWL_MVM_SCAN_STOPPING_REGULAR) {
372 IWL_DEBUG_SCAN(mvm, "Regular scan %s, EBS status %s\n",
373 aborted ? "aborted" : "completed",
374 iwl_mvm_ebs_status_str(scan_notif->ebs_status));
375
376 mvm->scan_status &= ~IWL_MVM_SCAN_STOPPING_REGULAR;
377 } else if (mvm->scan_status & IWL_MVM_SCAN_SCHED) {
378 WARN_ON_ONCE(mvm->scan_status & IWL_MVM_SCAN_REGULAR);
379
380 IWL_DEBUG_SCAN(mvm, "Scheduled scan %s, EBS status %s\n",
381 aborted ? "aborted" : "completed",
382 iwl_mvm_ebs_status_str(scan_notif->ebs_status));
383 IWL_DEBUG_SCAN(mvm,
384 "Last line %d, Last iteration %d, Time after last iteration %d (FW)\n",
385 scan_notif->last_schedule_line,
386 scan_notif->last_schedule_iteration,
387 __le32_to_cpu(scan_notif->time_after_last_iter));
388
389 mvm->scan_status &= ~IWL_MVM_SCAN_SCHED;
390 ieee80211_sched_scan_stopped(mvm->hw);
391 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
392 } else if (mvm->scan_status & IWL_MVM_SCAN_REGULAR) {
393 IWL_DEBUG_SCAN(mvm, "Regular scan %s, EBS status %s (FW)\n",
394 aborted ? "aborted" : "completed",
395 iwl_mvm_ebs_status_str(scan_notif->ebs_status));
396
397 mvm->scan_status &= ~IWL_MVM_SCAN_REGULAR;
398 ieee80211_scan_completed(mvm->hw,
399 scan_notif->status == IWL_SCAN_OFFLOAD_ABORTED);
400 iwl_mvm_unref(mvm, IWL_MVM_REF_SCAN);
401 }
402
403 mvm->last_ebs_successful =
404 scan_notif->ebs_status == IWL_SCAN_EBS_SUCCESS ||
405 scan_notif->ebs_status == IWL_SCAN_EBS_INACTIVE;
406}
407
408static int iwl_ssid_exist(u8 *ssid, u8 ssid_len, struct iwl_ssid_ie *ssid_list)
409{
410 int i;
411
412 for (i = 0; i < PROBE_OPTION_MAX; i++) {
413 if (!ssid_list[i].len)
414 break;
415 if (ssid_list[i].len == ssid_len &&
416 !memcmp(ssid_list->ssid, ssid, ssid_len))
417 return i;
418 }
419 return -1;
420}
421
422
423
424
425static void iwl_scan_build_ssids(struct iwl_mvm_scan_params *params,
426 struct iwl_ssid_ie *ssids,
427 u32 *ssid_bitmap)
428{
429 int i, j;
430 int index;
431
432
433
434
435
436
437 for (i = 0, j = params->n_match_sets - 1;
438 j >= 0 && i < PROBE_OPTION_MAX;
439 i++, j--) {
440
441 if (!params->match_sets[j].ssid.ssid_len)
442 continue;
443 ssids[i].id = WLAN_EID_SSID;
444 ssids[i].len = params->match_sets[j].ssid.ssid_len;
445 memcpy(ssids[i].ssid, params->match_sets[j].ssid.ssid,
446 ssids[i].len);
447 }
448
449
450 *ssid_bitmap = 0;
451 for (j = params->n_ssids - 1;
452 j >= 0 && i < PROBE_OPTION_MAX;
453 i++, j--) {
454 index = iwl_ssid_exist(params->ssids[j].ssid,
455 params->ssids[j].ssid_len,
456 ssids);
457 if (index < 0) {
458 ssids[i].id = WLAN_EID_SSID;
459 ssids[i].len = params->ssids[j].ssid_len;
460 memcpy(ssids[i].ssid, params->ssids[j].ssid,
461 ssids[i].len);
462 *ssid_bitmap |= BIT(i);
463 } else {
464 *ssid_bitmap |= BIT(index);
465 }
466 }
467}
468
469static int
470iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm,
471 struct cfg80211_sched_scan_request *req)
472{
473 struct iwl_scan_offload_profile *profile;
474 struct iwl_scan_offload_profile_cfg *profile_cfg;
475 struct iwl_scan_offload_blacklist *blacklist;
476 struct iwl_host_cmd cmd = {
477 .id = SCAN_OFFLOAD_UPDATE_PROFILES_CMD,
478 .len[1] = sizeof(*profile_cfg),
479 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
480 .dataflags[1] = IWL_HCMD_DFL_NOCOPY,
481 };
482 int blacklist_len;
483 int i;
484 int ret;
485
486 if (WARN_ON(req->n_match_sets > IWL_SCAN_MAX_PROFILES))
487 return -EIO;
488
489 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_SHORT_BL)
490 blacklist_len = IWL_SCAN_SHORT_BLACKLIST_LEN;
491 else
492 blacklist_len = IWL_SCAN_MAX_BLACKLIST_LEN;
493
494 blacklist = kzalloc(sizeof(*blacklist) * blacklist_len, GFP_KERNEL);
495 if (!blacklist)
496 return -ENOMEM;
497
498 profile_cfg = kzalloc(sizeof(*profile_cfg), GFP_KERNEL);
499 if (!profile_cfg) {
500 ret = -ENOMEM;
501 goto free_blacklist;
502 }
503
504 cmd.data[0] = blacklist;
505 cmd.len[0] = sizeof(*blacklist) * blacklist_len;
506 cmd.data[1] = profile_cfg;
507
508
509
510 profile_cfg->num_profiles = req->n_match_sets;
511 profile_cfg->active_clients = SCAN_CLIENT_SCHED_SCAN;
512 profile_cfg->pass_match = SCAN_CLIENT_SCHED_SCAN;
513 profile_cfg->match_notify = SCAN_CLIENT_SCHED_SCAN;
514 if (!req->n_match_sets || !req->match_sets[0].ssid.ssid_len)
515 profile_cfg->any_beacon_notify = SCAN_CLIENT_SCHED_SCAN;
516
517 for (i = 0; i < req->n_match_sets; i++) {
518 profile = &profile_cfg->profiles[i];
519 profile->ssid_index = i;
520
521 profile->unicast_cipher = 0xff;
522 profile->auth_alg = 0xff;
523 profile->network_type = IWL_NETWORK_TYPE_ANY;
524 profile->band_selection = IWL_SCAN_OFFLOAD_SELECT_ANY;
525 profile->client_bitmap = SCAN_CLIENT_SCHED_SCAN;
526 }
527
528 IWL_DEBUG_SCAN(mvm, "Sending scheduled scan profile config\n");
529
530 ret = iwl_mvm_send_cmd(mvm, &cmd);
531 kfree(profile_cfg);
532free_blacklist:
533 kfree(blacklist);
534
535 return ret;
536}
537
538static bool iwl_mvm_scan_pass_all(struct iwl_mvm *mvm,
539 struct cfg80211_sched_scan_request *req)
540{
541 if (req->n_match_sets && req->match_sets[0].ssid.ssid_len) {
542 IWL_DEBUG_SCAN(mvm,
543 "Sending scheduled scan with filtering, n_match_sets %d\n",
544 req->n_match_sets);
545 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
546 return false;
547 }
548
549 IWL_DEBUG_SCAN(mvm, "Sending Scheduled scan without filtering\n");
550
551 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED;
552 return true;
553}
554
555static int iwl_mvm_lmac_scan_abort(struct iwl_mvm *mvm)
556{
557 int ret;
558 struct iwl_host_cmd cmd = {
559 .id = SCAN_OFFLOAD_ABORT_CMD,
560 };
561 u32 status;
562
563 ret = iwl_mvm_send_cmd_status(mvm, &cmd, &status);
564 if (ret)
565 return ret;
566
567 if (status != CAN_ABORT_STATUS) {
568
569
570
571
572
573
574
575 IWL_DEBUG_SCAN(mvm, "SCAN OFFLOAD ABORT ret %d.\n", status);
576 ret = -ENOENT;
577 }
578
579 return ret;
580}
581
582static void iwl_mvm_scan_fill_tx_cmd(struct iwl_mvm *mvm,
583 struct iwl_scan_req_tx_cmd *tx_cmd,
584 bool no_cck)
585{
586 tx_cmd[0].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL |
587 TX_CMD_FLG_BT_DIS);
588 tx_cmd[0].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm,
589 IEEE80211_BAND_2GHZ,
590 no_cck);
591 tx_cmd[0].sta_id = mvm->aux_sta.sta_id;
592
593 tx_cmd[1].tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL |
594 TX_CMD_FLG_BT_DIS);
595 tx_cmd[1].rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm,
596 IEEE80211_BAND_5GHZ,
597 no_cck);
598 tx_cmd[1].sta_id = mvm->aux_sta.sta_id;
599}
600
601static void
602iwl_mvm_lmac_scan_cfg_channels(struct iwl_mvm *mvm,
603 struct ieee80211_channel **channels,
604 int n_channels, u32 ssid_bitmap,
605 struct iwl_scan_req_lmac *cmd)
606{
607 struct iwl_scan_channel_cfg_lmac *channel_cfg = (void *)&cmd->data;
608 int i;
609
610 for (i = 0; i < n_channels; i++) {
611 channel_cfg[i].channel_num =
612 cpu_to_le16(channels[i]->hw_value);
613 channel_cfg[i].iter_count = cpu_to_le16(1);
614 channel_cfg[i].iter_interval = 0;
615 channel_cfg[i].flags =
616 cpu_to_le32(IWL_UNIFIED_SCAN_CHANNEL_PARTIAL |
617 ssid_bitmap);
618 }
619}
620
621static u8 *iwl_mvm_copy_and_insert_ds_elem(struct iwl_mvm *mvm, const u8 *ies,
622 size_t len, u8 *const pos)
623{
624 static const u8 before_ds_params[] = {
625 WLAN_EID_SSID,
626 WLAN_EID_SUPP_RATES,
627 WLAN_EID_REQUEST,
628 WLAN_EID_EXT_SUPP_RATES,
629 };
630 size_t offs;
631 u8 *newpos = pos;
632
633 if (!iwl_mvm_rrm_scan_needed(mvm)) {
634 memcpy(newpos, ies, len);
635 return newpos + len;
636 }
637
638 offs = ieee80211_ie_split(ies, len,
639 before_ds_params,
640 ARRAY_SIZE(before_ds_params),
641 0);
642
643 memcpy(newpos, ies, offs);
644 newpos += offs;
645
646
647 *newpos++ = WLAN_EID_DS_PARAMS;
648 *newpos++ = 1;
649 *newpos++ = 0;
650
651 memcpy(newpos, ies + offs, len - offs);
652 newpos += len - offs;
653
654 return newpos;
655}
656
657static void
658iwl_mvm_build_scan_probe(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
659 struct ieee80211_scan_ies *ies,
660 struct iwl_mvm_scan_params *params)
661{
662 struct ieee80211_mgmt *frame = (void *)params->preq.buf;
663 u8 *pos, *newpos;
664 const u8 *mac_addr = params->flags & NL80211_SCAN_FLAG_RANDOM_ADDR ?
665 params->mac_addr : NULL;
666
667
668
669
670
671
672
673 if (mac_addr)
674 get_random_mask_addr(frame->sa, mac_addr,
675 params->mac_addr_mask);
676 else
677 memcpy(frame->sa, vif->addr, ETH_ALEN);
678
679 frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
680 eth_broadcast_addr(frame->da);
681 eth_broadcast_addr(frame->bssid);
682 frame->seq_ctrl = 0;
683
684 pos = frame->u.probe_req.variable;
685 *pos++ = WLAN_EID_SSID;
686 *pos++ = 0;
687
688 params->preq.mac_header.offset = 0;
689 params->preq.mac_header.len = cpu_to_le16(24 + 2);
690
691
692 newpos = iwl_mvm_copy_and_insert_ds_elem(mvm,
693 ies->ies[IEEE80211_BAND_2GHZ],
694 ies->len[IEEE80211_BAND_2GHZ],
695 pos);
696 params->preq.band_data[0].offset = cpu_to_le16(pos - params->preq.buf);
697 params->preq.band_data[0].len = cpu_to_le16(newpos - pos);
698 pos = newpos;
699
700 memcpy(pos, ies->ies[IEEE80211_BAND_5GHZ],
701 ies->len[IEEE80211_BAND_5GHZ]);
702 params->preq.band_data[1].offset = cpu_to_le16(pos - params->preq.buf);
703 params->preq.band_data[1].len =
704 cpu_to_le16(ies->len[IEEE80211_BAND_5GHZ]);
705 pos += ies->len[IEEE80211_BAND_5GHZ];
706
707 memcpy(pos, ies->common_ies, ies->common_ie_len);
708 params->preq.common_data.offset = cpu_to_le16(pos - params->preq.buf);
709 params->preq.common_data.len = cpu_to_le16(ies->common_ie_len);
710}
711
712static __le32 iwl_mvm_scan_priority(struct iwl_mvm *mvm,
713 enum iwl_scan_priority_ext prio)
714{
715 if (fw_has_api(&mvm->fw->ucode_capa,
716 IWL_UCODE_TLV_API_EXT_SCAN_PRIORITY))
717 return cpu_to_le32(prio);
718
719 if (prio <= IWL_SCAN_PRIORITY_EXT_2)
720 return cpu_to_le32(IWL_SCAN_PRIORITY_LOW);
721
722 if (prio <= IWL_SCAN_PRIORITY_EXT_4)
723 return cpu_to_le32(IWL_SCAN_PRIORITY_MEDIUM);
724
725 return cpu_to_le32(IWL_SCAN_PRIORITY_HIGH);
726}
727
728static void iwl_mvm_scan_lmac_dwell(struct iwl_mvm *mvm,
729 struct iwl_scan_req_lmac *cmd,
730 struct iwl_mvm_scan_params *params)
731{
732 cmd->active_dwell = scan_timing[params->type].dwell_active;
733 cmd->passive_dwell = scan_timing[params->type].dwell_passive;
734 cmd->fragmented_dwell = scan_timing[params->type].dwell_fragmented;
735 cmd->extended_dwell = scan_timing[params->type].dwell_extended;
736 cmd->max_out_time = cpu_to_le32(scan_timing[params->type].max_out_time);
737 cmd->suspend_time = cpu_to_le32(scan_timing[params->type].suspend_time);
738 cmd->scan_prio = iwl_mvm_scan_priority(mvm, IWL_SCAN_PRIORITY_EXT_6);
739}
740
741static inline bool iwl_mvm_scan_fits(struct iwl_mvm *mvm, int n_ssids,
742 struct ieee80211_scan_ies *ies,
743 int n_channels)
744{
745 return ((n_ssids <= PROBE_OPTION_MAX) &&
746 (n_channels <= mvm->fw->ucode_capa.n_scan_channels) &
747 (ies->common_ie_len +
748 ies->len[NL80211_BAND_2GHZ] +
749 ies->len[NL80211_BAND_5GHZ] <=
750 iwl_mvm_max_scan_ie_fw_cmd_room(mvm)));
751}
752
753static inline bool iwl_mvm_scan_use_ebs(struct iwl_mvm *mvm,
754 struct ieee80211_vif *vif)
755{
756 const struct iwl_ucode_capabilities *capa = &mvm->fw->ucode_capa;
757
758
759
760
761
762
763
764 return ((capa->flags & IWL_UCODE_TLV_FLAGS_EBS_SUPPORT) &&
765 mvm->last_ebs_successful &&
766 vif->type != NL80211_IFTYPE_P2P_DEVICE);
767}
768
769static inline bool iwl_mvm_is_regular_scan(struct iwl_mvm_scan_params *params)
770{
771 return params->n_scan_plans == 1 &&
772 params->scan_plans[0].iterations == 1;
773}
774
775static int iwl_mvm_scan_lmac_flags(struct iwl_mvm *mvm,
776 struct iwl_mvm_scan_params *params,
777 struct ieee80211_vif *vif)
778{
779 int flags = 0;
780
781 if (params->n_ssids == 0)
782 flags |= IWL_MVM_LMAC_SCAN_FLAG_PASSIVE;
783
784 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0)
785 flags |= IWL_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION;
786
787 if (params->type == IWL_SCAN_TYPE_FRAGMENTED)
788 flags |= IWL_MVM_LMAC_SCAN_FLAG_FRAGMENTED;
789
790 if (iwl_mvm_rrm_scan_needed(mvm))
791 flags |= IWL_MVM_LMAC_SCAN_FLAGS_RRM_ENABLED;
792
793 if (params->pass_all)
794 flags |= IWL_MVM_LMAC_SCAN_FLAG_PASS_ALL;
795 else
796 flags |= IWL_MVM_LMAC_SCAN_FLAG_MATCH;
797
798#ifdef CONFIG_IWLWIFI_DEBUGFS
799 if (mvm->scan_iter_notif_enabled)
800 flags |= IWL_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE;
801#endif
802
803 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED)
804 flags |= IWL_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE;
805
806 if (iwl_mvm_is_regular_scan(params) &&
807 vif->type != NL80211_IFTYPE_P2P_DEVICE &&
808 params->type != IWL_SCAN_TYPE_FRAGMENTED)
809 flags |= IWL_MVM_LMAC_SCAN_FLAG_EXTENDED_DWELL;
810
811 return flags;
812}
813
814static int iwl_mvm_scan_lmac(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
815 struct iwl_mvm_scan_params *params)
816{
817 struct iwl_scan_req_lmac *cmd = mvm->scan_cmd;
818 struct iwl_scan_probe_req *preq =
819 (void *)(cmd->data + sizeof(struct iwl_scan_channel_cfg_lmac) *
820 mvm->fw->ucode_capa.n_scan_channels);
821 u32 ssid_bitmap = 0;
822 int i;
823
824 lockdep_assert_held(&mvm->mutex);
825
826 memset(cmd, 0, ksize(cmd));
827
828 if (WARN_ON(params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS))
829 return -EINVAL;
830
831 iwl_mvm_scan_lmac_dwell(mvm, cmd, params);
832
833 cmd->rx_chain_select = iwl_mvm_scan_rx_chain(mvm);
834 cmd->iter_num = cpu_to_le32(1);
835 cmd->n_channels = (u8)params->n_channels;
836
837 cmd->delay = cpu_to_le32(params->delay);
838
839 cmd->scan_flags = cpu_to_le32(iwl_mvm_scan_lmac_flags(mvm, params,
840 vif));
841
842 cmd->flags = iwl_mvm_scan_rxon_flags(params->channels[0]->band);
843 cmd->filter_flags = cpu_to_le32(MAC_FILTER_ACCEPT_GRP |
844 MAC_FILTER_IN_BEACON);
845 iwl_mvm_scan_fill_tx_cmd(mvm, cmd->tx_cmd, params->no_cck);
846 iwl_scan_build_ssids(params, cmd->direct_scan, &ssid_bitmap);
847
848
849 ssid_bitmap <<= 1;
850
851 for (i = 0; i < params->n_scan_plans; i++) {
852 struct cfg80211_sched_scan_plan *scan_plan =
853 ¶ms->scan_plans[i];
854
855 cmd->schedule[i].delay =
856 cpu_to_le16(scan_plan->interval);
857 cmd->schedule[i].iterations = scan_plan->iterations;
858 cmd->schedule[i].full_scan_mul = 1;
859 }
860
861
862
863
864
865
866
867 if (!cmd->schedule[i - 1].iterations)
868 cmd->schedule[i - 1].iterations = 0xff;
869
870 if (iwl_mvm_scan_use_ebs(mvm, vif)) {
871 cmd->channel_opt[0].flags =
872 cpu_to_le16(IWL_SCAN_CHANNEL_FLAG_EBS |
873 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
874 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD);
875 cmd->channel_opt[0].non_ebs_ratio =
876 cpu_to_le16(IWL_DENSE_EBS_SCAN_RATIO);
877 cmd->channel_opt[1].flags =
878 cpu_to_le16(IWL_SCAN_CHANNEL_FLAG_EBS |
879 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
880 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD);
881 cmd->channel_opt[1].non_ebs_ratio =
882 cpu_to_le16(IWL_SPARSE_EBS_SCAN_RATIO);
883 }
884
885 iwl_mvm_lmac_scan_cfg_channels(mvm, params->channels,
886 params->n_channels, ssid_bitmap, cmd);
887
888 *preq = params->preq;
889
890 return 0;
891}
892
893static int rate_to_scan_rate_flag(unsigned int rate)
894{
895 static const int rate_to_scan_rate[IWL_RATE_COUNT] = {
896 [IWL_RATE_1M_INDEX] = SCAN_CONFIG_RATE_1M,
897 [IWL_RATE_2M_INDEX] = SCAN_CONFIG_RATE_2M,
898 [IWL_RATE_5M_INDEX] = SCAN_CONFIG_RATE_5M,
899 [IWL_RATE_11M_INDEX] = SCAN_CONFIG_RATE_11M,
900 [IWL_RATE_6M_INDEX] = SCAN_CONFIG_RATE_6M,
901 [IWL_RATE_9M_INDEX] = SCAN_CONFIG_RATE_9M,
902 [IWL_RATE_12M_INDEX] = SCAN_CONFIG_RATE_12M,
903 [IWL_RATE_18M_INDEX] = SCAN_CONFIG_RATE_18M,
904 [IWL_RATE_24M_INDEX] = SCAN_CONFIG_RATE_24M,
905 [IWL_RATE_36M_INDEX] = SCAN_CONFIG_RATE_36M,
906 [IWL_RATE_48M_INDEX] = SCAN_CONFIG_RATE_48M,
907 [IWL_RATE_54M_INDEX] = SCAN_CONFIG_RATE_54M,
908 };
909
910 return rate_to_scan_rate[rate];
911}
912
913static __le32 iwl_mvm_scan_config_rates(struct iwl_mvm *mvm)
914{
915 struct ieee80211_supported_band *band;
916 unsigned int rates = 0;
917 int i;
918
919 band = &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
920 for (i = 0; i < band->n_bitrates; i++)
921 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value);
922 band = &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
923 for (i = 0; i < band->n_bitrates; i++)
924 rates |= rate_to_scan_rate_flag(band->bitrates[i].hw_value);
925
926
927 rates |= SCAN_CONFIG_SUPPORTED_RATE(rates);
928
929 return cpu_to_le32(rates);
930}
931
932int iwl_mvm_config_scan(struct iwl_mvm *mvm)
933{
934 struct iwl_scan_config *scan_config;
935 struct ieee80211_supported_band *band;
936 int num_channels =
937 mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels +
938 mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels;
939 int ret, i, j = 0, cmd_size;
940 struct iwl_host_cmd cmd = {
941 .id = iwl_cmd_id(SCAN_CFG_CMD, IWL_ALWAYS_LONG_GROUP, 0),
942 };
943 enum iwl_mvm_scan_type type = iwl_mvm_get_scan_type(mvm, false);
944
945 if (WARN_ON(num_channels > mvm->fw->ucode_capa.n_scan_channels))
946 return -ENOBUFS;
947
948 if (type == mvm->scan_type) {
949 IWL_DEBUG_SCAN(mvm,
950 "Ignoring UMAC scan config of the same type\n");
951 return 0;
952 }
953
954 cmd_size = sizeof(*scan_config) + mvm->fw->ucode_capa.n_scan_channels;
955
956 scan_config = kzalloc(cmd_size, GFP_KERNEL);
957 if (!scan_config)
958 return -ENOMEM;
959
960 scan_config->flags = cpu_to_le32(SCAN_CONFIG_FLAG_ACTIVATE |
961 SCAN_CONFIG_FLAG_ALLOW_CHUB_REQS |
962 SCAN_CONFIG_FLAG_SET_TX_CHAINS |
963 SCAN_CONFIG_FLAG_SET_RX_CHAINS |
964 SCAN_CONFIG_FLAG_SET_ALL_TIMES |
965 SCAN_CONFIG_FLAG_SET_LEGACY_RATES |
966 SCAN_CONFIG_FLAG_SET_MAC_ADDR |
967 SCAN_CONFIG_FLAG_SET_CHANNEL_FLAGS|
968 SCAN_CONFIG_N_CHANNELS(num_channels) |
969 (type == IWL_SCAN_TYPE_FRAGMENTED ?
970 SCAN_CONFIG_FLAG_SET_FRAGMENTED :
971 SCAN_CONFIG_FLAG_CLEAR_FRAGMENTED));
972 scan_config->tx_chains = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm));
973 scan_config->rx_chains = cpu_to_le32(iwl_mvm_scan_rx_ant(mvm));
974 scan_config->legacy_rates = iwl_mvm_scan_config_rates(mvm);
975 scan_config->out_of_channel_time =
976 cpu_to_le32(scan_timing[type].max_out_time);
977 scan_config->suspend_time = cpu_to_le32(scan_timing[type].suspend_time);
978 scan_config->dwell_active = scan_timing[type].dwell_active;
979 scan_config->dwell_passive = scan_timing[type].dwell_passive;
980 scan_config->dwell_fragmented = scan_timing[type].dwell_fragmented;
981 scan_config->dwell_extended = scan_timing[type].dwell_extended;
982
983 memcpy(&scan_config->mac_addr, &mvm->addresses[0].addr, ETH_ALEN);
984
985 scan_config->bcast_sta_id = mvm->aux_sta.sta_id;
986 scan_config->channel_flags = IWL_CHANNEL_FLAG_EBS |
987 IWL_CHANNEL_FLAG_ACCURATE_EBS |
988 IWL_CHANNEL_FLAG_EBS_ADD |
989 IWL_CHANNEL_FLAG_PRE_SCAN_PASSIVE2ACTIVE;
990
991 band = &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
992 for (i = 0; i < band->n_channels; i++, j++)
993 scan_config->channel_array[j] = band->channels[i].hw_value;
994 band = &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
995 for (i = 0; i < band->n_channels; i++, j++)
996 scan_config->channel_array[j] = band->channels[i].hw_value;
997
998 cmd.data[0] = scan_config;
999 cmd.len[0] = cmd_size;
1000 cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
1001
1002 IWL_DEBUG_SCAN(mvm, "Sending UMAC scan config\n");
1003
1004 ret = iwl_mvm_send_cmd(mvm, &cmd);
1005 if (!ret)
1006 mvm->scan_type = type;
1007
1008 kfree(scan_config);
1009 return ret;
1010}
1011
1012static int iwl_mvm_scan_uid_by_status(struct iwl_mvm *mvm, int status)
1013{
1014 int i;
1015
1016 for (i = 0; i < mvm->max_scans; i++)
1017 if (mvm->scan_uid_status[i] == status)
1018 return i;
1019
1020 return -ENOENT;
1021}
1022
1023static void iwl_mvm_scan_umac_dwell(struct iwl_mvm *mvm,
1024 struct iwl_scan_req_umac *cmd,
1025 struct iwl_mvm_scan_params *params)
1026{
1027 cmd->extended_dwell = scan_timing[params->type].dwell_extended;
1028 cmd->active_dwell = scan_timing[params->type].dwell_active;
1029 cmd->passive_dwell = scan_timing[params->type].dwell_passive;
1030 cmd->fragmented_dwell = scan_timing[params->type].dwell_fragmented;
1031 cmd->max_out_time = cpu_to_le32(scan_timing[params->type].max_out_time);
1032 cmd->suspend_time = cpu_to_le32(scan_timing[params->type].suspend_time);
1033 cmd->scan_priority =
1034 iwl_mvm_scan_priority(mvm, IWL_SCAN_PRIORITY_EXT_6);
1035
1036 if (iwl_mvm_is_regular_scan(params))
1037 cmd->ooc_priority =
1038 iwl_mvm_scan_priority(mvm, IWL_SCAN_PRIORITY_EXT_6);
1039 else
1040 cmd->ooc_priority =
1041 iwl_mvm_scan_priority(mvm, IWL_SCAN_PRIORITY_EXT_2);
1042}
1043
1044static void
1045iwl_mvm_umac_scan_cfg_channels(struct iwl_mvm *mvm,
1046 struct ieee80211_channel **channels,
1047 int n_channels, u32 ssid_bitmap,
1048 struct iwl_scan_req_umac *cmd)
1049{
1050 struct iwl_scan_channel_cfg_umac *channel_cfg = (void *)&cmd->data;
1051 int i;
1052
1053 for (i = 0; i < n_channels; i++) {
1054 channel_cfg[i].flags = cpu_to_le32(ssid_bitmap);
1055 channel_cfg[i].channel_num = channels[i]->hw_value;
1056 channel_cfg[i].iter_count = 1;
1057 channel_cfg[i].iter_interval = 0;
1058 }
1059}
1060
1061static u32 iwl_mvm_scan_umac_flags(struct iwl_mvm *mvm,
1062 struct iwl_mvm_scan_params *params,
1063 struct ieee80211_vif *vif)
1064{
1065 int flags = 0;
1066
1067 if (params->n_ssids == 0)
1068 flags = IWL_UMAC_SCAN_GEN_FLAGS_PASSIVE;
1069
1070 if (params->n_ssids == 1 && params->ssids[0].ssid_len != 0)
1071 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT;
1072
1073 if (params->type == IWL_SCAN_TYPE_FRAGMENTED)
1074 flags |= IWL_UMAC_SCAN_GEN_FLAGS_FRAGMENTED;
1075
1076 if (iwl_mvm_rrm_scan_needed(mvm))
1077 flags |= IWL_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED;
1078
1079 if (params->pass_all)
1080 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PASS_ALL;
1081 else
1082 flags |= IWL_UMAC_SCAN_GEN_FLAGS_MATCH;
1083
1084 if (!iwl_mvm_is_regular_scan(params))
1085 flags |= IWL_UMAC_SCAN_GEN_FLAGS_PERIODIC;
1086
1087#ifdef CONFIG_IWLWIFI_DEBUGFS
1088 if (mvm->scan_iter_notif_enabled)
1089 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE;
1090#endif
1091
1092 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_ENABLED)
1093 flags |= IWL_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE;
1094
1095 if (iwl_mvm_is_regular_scan(params) &&
1096 vif->type != NL80211_IFTYPE_P2P_DEVICE &&
1097 params->type != IWL_SCAN_TYPE_FRAGMENTED)
1098 flags |= IWL_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL;
1099
1100 return flags;
1101}
1102
1103static int iwl_mvm_scan_umac(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1104 struct iwl_mvm_scan_params *params,
1105 int type)
1106{
1107 struct iwl_scan_req_umac *cmd = mvm->scan_cmd;
1108 struct iwl_scan_req_umac_tail *sec_part = (void *)&cmd->data +
1109 sizeof(struct iwl_scan_channel_cfg_umac) *
1110 mvm->fw->ucode_capa.n_scan_channels;
1111 int uid, i;
1112 u32 ssid_bitmap = 0;
1113
1114 lockdep_assert_held(&mvm->mutex);
1115
1116 if (WARN_ON(params->n_scan_plans > IWL_MAX_SCHED_SCAN_PLANS))
1117 return -EINVAL;
1118
1119 uid = iwl_mvm_scan_uid_by_status(mvm, 0);
1120 if (uid < 0)
1121 return uid;
1122
1123 memset(cmd, 0, ksize(cmd));
1124
1125 iwl_mvm_scan_umac_dwell(mvm, cmd, params);
1126
1127 mvm->scan_uid_status[uid] = type;
1128
1129 cmd->uid = cpu_to_le32(uid);
1130 cmd->general_flags = cpu_to_le32(iwl_mvm_scan_umac_flags(mvm, params,
1131 vif));
1132
1133 if (type == IWL_MVM_SCAN_SCHED || type == IWL_MVM_SCAN_NETDETECT)
1134 cmd->flags = cpu_to_le32(IWL_UMAC_SCAN_FLAG_PREEMPTIVE);
1135
1136 if (iwl_mvm_scan_use_ebs(mvm, vif))
1137 cmd->channel_flags = IWL_SCAN_CHANNEL_FLAG_EBS |
1138 IWL_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
1139 IWL_SCAN_CHANNEL_FLAG_CACHE_ADD;
1140
1141 cmd->n_channels = params->n_channels;
1142
1143 iwl_scan_build_ssids(params, sec_part->direct_scan, &ssid_bitmap);
1144
1145 iwl_mvm_umac_scan_cfg_channels(mvm, params->channels,
1146 params->n_channels, ssid_bitmap, cmd);
1147
1148 for (i = 0; i < params->n_scan_plans; i++) {
1149 struct cfg80211_sched_scan_plan *scan_plan =
1150 ¶ms->scan_plans[i];
1151
1152 sec_part->schedule[i].iter_count = scan_plan->iterations;
1153 sec_part->schedule[i].interval =
1154 cpu_to_le16(scan_plan->interval);
1155 }
1156
1157
1158
1159
1160
1161
1162
1163 if (!sec_part->schedule[i - 1].iter_count)
1164 sec_part->schedule[i - 1].iter_count = 0xff;
1165
1166 sec_part->delay = cpu_to_le16(params->delay);
1167 sec_part->preq = params->preq;
1168
1169 return 0;
1170}
1171
1172static int iwl_mvm_num_scans(struct iwl_mvm *mvm)
1173{
1174 return hweight32(mvm->scan_status & IWL_MVM_SCAN_MASK);
1175}
1176
1177static int iwl_mvm_check_running_scans(struct iwl_mvm *mvm, int type)
1178{
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189 if (iwl_mvm_num_scans(mvm) < mvm->max_scans)
1190 return 0;
1191
1192
1193
1194
1195 switch (type) {
1196 case IWL_MVM_SCAN_REGULAR:
1197 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR_MASK)
1198 return -EBUSY;
1199 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
1200 case IWL_MVM_SCAN_SCHED:
1201 if (mvm->scan_status & IWL_MVM_SCAN_SCHED_MASK)
1202 return -EBUSY;
1203 return iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
1204 case IWL_MVM_SCAN_NETDETECT:
1205
1206
1207
1208
1209
1210 return 0;
1211 default:
1212 WARN_ON(1);
1213 break;
1214 }
1215
1216 return -EIO;
1217}
1218
1219int iwl_mvm_reg_scan_start(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1220 struct cfg80211_scan_request *req,
1221 struct ieee80211_scan_ies *ies)
1222{
1223 struct iwl_host_cmd hcmd = {
1224 .len = { iwl_mvm_scan_size(mvm), },
1225 .data = { mvm->scan_cmd, },
1226 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
1227 };
1228 struct iwl_mvm_scan_params params = {};
1229 int ret;
1230 struct cfg80211_sched_scan_plan scan_plan = { .iterations = 1 };
1231
1232 lockdep_assert_held(&mvm->mutex);
1233
1234 if (iwl_mvm_is_lar_supported(mvm) && !mvm->lar_regdom_set) {
1235 IWL_ERR(mvm, "scan while LAR regdomain is not set\n");
1236 return -EBUSY;
1237 }
1238
1239 ret = iwl_mvm_check_running_scans(mvm, IWL_MVM_SCAN_REGULAR);
1240 if (ret)
1241 return ret;
1242
1243
1244 if (WARN_ON(!mvm->scan_cmd))
1245 return -ENOMEM;
1246
1247 if (!iwl_mvm_scan_fits(mvm, req->n_ssids, ies, req->n_channels))
1248 return -ENOBUFS;
1249
1250 params.n_ssids = req->n_ssids;
1251 params.flags = req->flags;
1252 params.n_channels = req->n_channels;
1253 params.delay = 0;
1254 params.ssids = req->ssids;
1255 params.channels = req->channels;
1256 params.mac_addr = req->mac_addr;
1257 params.mac_addr_mask = req->mac_addr_mask;
1258 params.no_cck = req->no_cck;
1259 params.pass_all = true;
1260 params.n_match_sets = 0;
1261 params.match_sets = NULL;
1262
1263 params.scan_plans = &scan_plan;
1264 params.n_scan_plans = 1;
1265
1266 params.type =
1267 iwl_mvm_get_scan_type(mvm,
1268 vif->type == NL80211_IFTYPE_P2P_DEVICE);
1269
1270 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms);
1271
1272 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1273 hcmd.id = iwl_cmd_id(SCAN_REQ_UMAC, IWL_ALWAYS_LONG_GROUP, 0);
1274 ret = iwl_mvm_scan_umac(mvm, vif, ¶ms,
1275 IWL_MVM_SCAN_REGULAR);
1276 } else {
1277 hcmd.id = SCAN_OFFLOAD_REQUEST_CMD;
1278 ret = iwl_mvm_scan_lmac(mvm, vif, ¶ms);
1279 }
1280
1281 if (ret)
1282 return ret;
1283
1284 ret = iwl_mvm_send_cmd(mvm, &hcmd);
1285 if (ret) {
1286
1287
1288
1289
1290 IWL_ERR(mvm, "Scan failed! ret %d\n", ret);
1291 return ret;
1292 }
1293
1294 IWL_DEBUG_SCAN(mvm, "Scan request was sent successfully\n");
1295 mvm->scan_status |= IWL_MVM_SCAN_REGULAR;
1296 iwl_mvm_ref(mvm, IWL_MVM_REF_SCAN);
1297
1298 return 0;
1299}
1300
1301int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm,
1302 struct ieee80211_vif *vif,
1303 struct cfg80211_sched_scan_request *req,
1304 struct ieee80211_scan_ies *ies,
1305 int type)
1306{
1307 struct iwl_host_cmd hcmd = {
1308 .len = { iwl_mvm_scan_size(mvm), },
1309 .data = { mvm->scan_cmd, },
1310 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
1311 };
1312 struct iwl_mvm_scan_params params = {};
1313 int ret;
1314
1315 lockdep_assert_held(&mvm->mutex);
1316
1317 if (iwl_mvm_is_lar_supported(mvm) && !mvm->lar_regdom_set) {
1318 IWL_ERR(mvm, "sched-scan while LAR regdomain is not set\n");
1319 return -EBUSY;
1320 }
1321
1322 ret = iwl_mvm_check_running_scans(mvm, type);
1323 if (ret)
1324 return ret;
1325
1326
1327 if (WARN_ON(!mvm->scan_cmd))
1328 return -ENOMEM;
1329
1330 if (!iwl_mvm_scan_fits(mvm, req->n_ssids, ies, req->n_channels))
1331 return -ENOBUFS;
1332
1333 params.n_ssids = req->n_ssids;
1334 params.flags = req->flags;
1335 params.n_channels = req->n_channels;
1336 params.ssids = req->ssids;
1337 params.channels = req->channels;
1338 params.mac_addr = req->mac_addr;
1339 params.mac_addr_mask = req->mac_addr_mask;
1340 params.no_cck = false;
1341 params.pass_all = iwl_mvm_scan_pass_all(mvm, req);
1342 params.n_match_sets = req->n_match_sets;
1343 params.match_sets = req->match_sets;
1344 if (!req->n_scan_plans)
1345 return -EINVAL;
1346
1347 params.n_scan_plans = req->n_scan_plans;
1348 params.scan_plans = req->scan_plans;
1349
1350 params.type =
1351 iwl_mvm_get_scan_type(mvm,
1352 vif->type == NL80211_IFTYPE_P2P_DEVICE);
1353
1354
1355
1356
1357
1358
1359 if (req->delay > U16_MAX) {
1360 IWL_DEBUG_SCAN(mvm,
1361 "delay value is > 16-bits, set to max possible\n");
1362 params.delay = U16_MAX;
1363 } else {
1364 params.delay = req->delay;
1365 }
1366
1367 ret = iwl_mvm_config_sched_scan_profiles(mvm, req);
1368 if (ret)
1369 return ret;
1370
1371 iwl_mvm_build_scan_probe(mvm, vif, ies, ¶ms);
1372
1373 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1374 hcmd.id = iwl_cmd_id(SCAN_REQ_UMAC, IWL_ALWAYS_LONG_GROUP, 0);
1375 ret = iwl_mvm_scan_umac(mvm, vif, ¶ms, type);
1376 } else {
1377 hcmd.id = SCAN_OFFLOAD_REQUEST_CMD;
1378 ret = iwl_mvm_scan_lmac(mvm, vif, ¶ms);
1379 }
1380
1381 if (ret)
1382 return ret;
1383
1384 ret = iwl_mvm_send_cmd(mvm, &hcmd);
1385 if (!ret) {
1386 IWL_DEBUG_SCAN(mvm,
1387 "Sched scan request was sent successfully\n");
1388 mvm->scan_status |= type;
1389 } else {
1390
1391
1392
1393
1394 IWL_ERR(mvm, "Sched scan failed! ret %d\n", ret);
1395 }
1396
1397 return ret;
1398}
1399
1400void iwl_mvm_rx_umac_scan_complete_notif(struct iwl_mvm *mvm,
1401 struct iwl_rx_cmd_buffer *rxb)
1402{
1403 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1404 struct iwl_umac_scan_complete *notif = (void *)pkt->data;
1405 u32 uid = __le32_to_cpu(notif->uid);
1406 bool aborted = (notif->status == IWL_SCAN_OFFLOAD_ABORTED);
1407
1408 if (WARN_ON(!(mvm->scan_uid_status[uid] & mvm->scan_status)))
1409 return;
1410
1411
1412 if (mvm->scan_uid_status[uid] == IWL_MVM_SCAN_REGULAR) {
1413 ieee80211_scan_completed(mvm->hw, aborted);
1414 iwl_mvm_unref(mvm, IWL_MVM_REF_SCAN);
1415 } else if (mvm->scan_uid_status[uid] == IWL_MVM_SCAN_SCHED) {
1416 ieee80211_sched_scan_stopped(mvm->hw);
1417 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
1418 }
1419
1420 mvm->scan_status &= ~mvm->scan_uid_status[uid];
1421 IWL_DEBUG_SCAN(mvm,
1422 "Scan completed, uid %u type %u, status %s, EBS status %s\n",
1423 uid, mvm->scan_uid_status[uid],
1424 notif->status == IWL_SCAN_OFFLOAD_COMPLETED ?
1425 "completed" : "aborted",
1426 iwl_mvm_ebs_status_str(notif->ebs_status));
1427 IWL_DEBUG_SCAN(mvm,
1428 "Last line %d, Last iteration %d, Time from last iteration %d\n",
1429 notif->last_schedule, notif->last_iter,
1430 __le32_to_cpu(notif->time_from_last_iter));
1431
1432 if (notif->ebs_status != IWL_SCAN_EBS_SUCCESS &&
1433 notif->ebs_status != IWL_SCAN_EBS_INACTIVE)
1434 mvm->last_ebs_successful = false;
1435
1436 mvm->scan_uid_status[uid] = 0;
1437}
1438
1439void iwl_mvm_rx_umac_scan_iter_complete_notif(struct iwl_mvm *mvm,
1440 struct iwl_rx_cmd_buffer *rxb)
1441{
1442 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1443 struct iwl_umac_scan_iter_complete_notif *notif = (void *)pkt->data;
1444 u8 buf[256];
1445
1446 IWL_DEBUG_SCAN(mvm,
1447 "UMAC Scan iteration complete: status=0x%x scanned_channels=%d channels list: %s\n",
1448 notif->status, notif->scanned_channels,
1449 iwl_mvm_dump_channel_list(notif->results,
1450 notif->scanned_channels, buf,
1451 sizeof(buf)));
1452
1453 if (mvm->sched_scan_pass_all == SCHED_SCAN_PASS_ALL_FOUND) {
1454 IWL_DEBUG_SCAN(mvm, "Pass all scheduled scan results found\n");
1455 ieee80211_sched_scan_results(mvm->hw);
1456 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_ENABLED;
1457 }
1458}
1459
1460static int iwl_mvm_umac_scan_abort(struct iwl_mvm *mvm, int type)
1461{
1462 struct iwl_umac_scan_abort cmd = {};
1463 int uid, ret;
1464
1465 lockdep_assert_held(&mvm->mutex);
1466
1467
1468
1469
1470
1471 uid = iwl_mvm_scan_uid_by_status(mvm, type);
1472 if (WARN_ON_ONCE(uid < 0))
1473 return uid;
1474
1475 cmd.uid = cpu_to_le32(uid);
1476
1477 IWL_DEBUG_SCAN(mvm, "Sending scan abort, uid %u\n", uid);
1478
1479 ret = iwl_mvm_send_cmd_pdu(mvm,
1480 iwl_cmd_id(SCAN_ABORT_UMAC,
1481 IWL_ALWAYS_LONG_GROUP, 0),
1482 0, sizeof(cmd), &cmd);
1483 if (!ret)
1484 mvm->scan_uid_status[uid] = type << IWL_MVM_SCAN_STOPPING_SHIFT;
1485
1486 return ret;
1487}
1488
1489static int iwl_mvm_scan_stop_wait(struct iwl_mvm *mvm, int type)
1490{
1491 struct iwl_notification_wait wait_scan_done;
1492 static const u16 scan_done_notif[] = { SCAN_COMPLETE_UMAC,
1493 SCAN_OFFLOAD_COMPLETE, };
1494 int ret;
1495
1496 lockdep_assert_held(&mvm->mutex);
1497
1498 iwl_init_notification_wait(&mvm->notif_wait, &wait_scan_done,
1499 scan_done_notif,
1500 ARRAY_SIZE(scan_done_notif),
1501 NULL, NULL);
1502
1503 IWL_DEBUG_SCAN(mvm, "Preparing to stop scan, type %x\n", type);
1504
1505 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
1506 ret = iwl_mvm_umac_scan_abort(mvm, type);
1507 else
1508 ret = iwl_mvm_lmac_scan_abort(mvm);
1509
1510 if (ret) {
1511 IWL_DEBUG_SCAN(mvm, "couldn't stop scan type %d\n", type);
1512 iwl_remove_notification(&mvm->notif_wait, &wait_scan_done);
1513 return ret;
1514 }
1515
1516 ret = iwl_wait_notification(&mvm->notif_wait, &wait_scan_done, 1 * HZ);
1517
1518 return ret;
1519}
1520
1521int iwl_mvm_scan_size(struct iwl_mvm *mvm)
1522{
1523 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
1524 return sizeof(struct iwl_scan_req_umac) +
1525 sizeof(struct iwl_scan_channel_cfg_umac) *
1526 mvm->fw->ucode_capa.n_scan_channels +
1527 sizeof(struct iwl_scan_req_umac_tail);
1528
1529 return sizeof(struct iwl_scan_req_lmac) +
1530 sizeof(struct iwl_scan_channel_cfg_lmac) *
1531 mvm->fw->ucode_capa.n_scan_channels +
1532 sizeof(struct iwl_scan_probe_req);
1533}
1534
1535
1536
1537
1538
1539void iwl_mvm_report_scan_aborted(struct iwl_mvm *mvm)
1540{
1541 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
1542 int uid, i;
1543
1544 uid = iwl_mvm_scan_uid_by_status(mvm, IWL_MVM_SCAN_REGULAR);
1545 if (uid >= 0) {
1546 ieee80211_scan_completed(mvm->hw, true);
1547 mvm->scan_uid_status[uid] = 0;
1548 }
1549 uid = iwl_mvm_scan_uid_by_status(mvm, IWL_MVM_SCAN_SCHED);
1550 if (uid >= 0 && !mvm->restart_fw) {
1551 ieee80211_sched_scan_stopped(mvm->hw);
1552 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
1553 mvm->scan_uid_status[uid] = 0;
1554 }
1555
1556
1557
1558
1559
1560 for (i = 0; i < mvm->max_scans; i++) {
1561 if (WARN_ONCE(mvm->scan_uid_status[i],
1562 "UMAC scan UID %d status was not cleaned\n",
1563 i))
1564 mvm->scan_uid_status[i] = 0;
1565 }
1566 } else {
1567 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR)
1568 ieee80211_scan_completed(mvm->hw, true);
1569
1570
1571
1572
1573
1574 if ((mvm->scan_status & IWL_MVM_SCAN_SCHED) &&
1575 !mvm->restart_fw) {
1576 ieee80211_sched_scan_stopped(mvm->hw);
1577 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
1578 }
1579 }
1580}
1581
1582int iwl_mvm_scan_stop(struct iwl_mvm *mvm, int type, bool notify)
1583{
1584 int ret;
1585
1586 if (!(mvm->scan_status & type))
1587 return 0;
1588
1589 if (iwl_mvm_is_radio_killed(mvm)) {
1590 ret = 0;
1591 goto out;
1592 }
1593
1594 ret = iwl_mvm_scan_stop_wait(mvm, type);
1595 if (!ret)
1596 mvm->scan_status |= type << IWL_MVM_SCAN_STOPPING_SHIFT;
1597out:
1598
1599
1600
1601
1602
1603 mvm->scan_status &= ~type;
1604
1605 if (type == IWL_MVM_SCAN_REGULAR) {
1606
1607
1608
1609 iwl_mvm_unref(mvm, IWL_MVM_REF_SCAN);
1610 if (notify)
1611 ieee80211_scan_completed(mvm->hw, true);
1612 } else if (notify) {
1613 ieee80211_sched_scan_stopped(mvm->hw);
1614 mvm->sched_scan_pass_all = SCHED_SCAN_PASS_ALL_DISABLED;
1615 }
1616
1617 return ret;
1618}
1619
