iwlwifi: mvm: change the name of init_ucode_run flag
[linux-2.6-block.git] / drivers / net / wireless / iwlwifi / mvm / scan.c
1 /******************************************************************************
2  *
3  * This file is provided under a dual BSD/GPLv2 license.  When using or
4  * redistributing this file, you may do so under either license.
5  *
6  * GPL LICENSE SUMMARY
7  *
8  * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of version 2 of the GNU General Public License as
12  * published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22  * USA
23  *
24  * The full GNU General Public License is included in this distribution
25  * in the file called COPYING.
26  *
27  * Contact Information:
28  *  Intel Linux Wireless <ilw@linux.intel.com>
29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30  *
31  * BSD LICENSE
32  *
33  * Copyright(c) 2012 - 2013 Intel Corporation. All rights reserved.
34  * All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  *
40  *  * Redistributions of source code must retain the above copyright
41  *    notice, this list of conditions and the following disclaimer.
42  *  * Redistributions in binary form must reproduce the above copyright
43  *    notice, this list of conditions and the following disclaimer in
44  *    the documentation and/or other materials provided with the
45  *    distribution.
46  *  * Neither the name Intel Corporation nor the names of its
47  *    contributors may be used to endorse or promote products derived
48  *    from this software without specific prior written permission.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61  *
62  *****************************************************************************/
63
64 #include <linux/etherdevice.h>
65 #include <net/mac80211.h>
66
67 #include "mvm.h"
68 #include "iwl-eeprom-parse.h"
69 #include "fw-api-scan.h"
70
71 #define IWL_PLCP_QUIET_THRESH 1
72 #define IWL_ACTIVE_QUIET_TIME 10
73
74 static inline __le16 iwl_mvm_scan_rx_chain(struct iwl_mvm *mvm)
75 {
76         u16 rx_chain;
77         u8 rx_ant;
78
79         if (mvm->scan_rx_ant != ANT_NONE)
80                 rx_ant = mvm->scan_rx_ant;
81         else
82                 rx_ant = iwl_fw_valid_rx_ant(mvm->fw);
83         rx_chain = rx_ant << PHY_RX_CHAIN_VALID_POS;
84         rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_MIMO_SEL_POS;
85         rx_chain |= rx_ant << PHY_RX_CHAIN_FORCE_SEL_POS;
86         rx_chain |= 0x1 << PHY_RX_CHAIN_DRIVER_FORCE_POS;
87         return cpu_to_le16(rx_chain);
88 }
89
90 static inline __le32 iwl_mvm_scan_max_out_time(struct ieee80211_vif *vif)
91 {
92         if (vif->bss_conf.assoc)
93                 return cpu_to_le32(200 * 1024);
94         else
95                 return 0;
96 }
97
98 static inline __le32 iwl_mvm_scan_suspend_time(struct ieee80211_vif *vif)
99 {
100         if (vif->bss_conf.assoc)
101                 return cpu_to_le32(vif->bss_conf.beacon_int);
102         else
103                 return 0;
104 }
105
106 static inline __le32
107 iwl_mvm_scan_rxon_flags(struct cfg80211_scan_request *req)
108 {
109         if (req->channels[0]->band == IEEE80211_BAND_2GHZ)
110                 return cpu_to_le32(PHY_BAND_24);
111         else
112                 return cpu_to_le32(PHY_BAND_5);
113 }
114
115 static inline __le32
116 iwl_mvm_scan_rate_n_flags(struct iwl_mvm *mvm, enum ieee80211_band band,
117                           bool no_cck)
118 {
119         u32 tx_ant;
120
121         mvm->scan_last_antenna_idx =
122                 iwl_mvm_next_antenna(mvm, iwl_fw_valid_tx_ant(mvm->fw),
123                                      mvm->scan_last_antenna_idx);
124         tx_ant = BIT(mvm->scan_last_antenna_idx) << RATE_MCS_ANT_POS;
125
126         if (band == IEEE80211_BAND_2GHZ && !no_cck)
127                 return cpu_to_le32(IWL_RATE_1M_PLCP | RATE_MCS_CCK_MSK |
128                                    tx_ant);
129         else
130                 return cpu_to_le32(IWL_RATE_6M_PLCP | tx_ant);
131 }
132
133 /*
134  * We insert the SSIDs in an inverted order, because the FW will
135  * invert it back. The most prioritized SSID, which is first in the
136  * request list, is not copied here, but inserted directly to the probe
137  * request.
138  */
139 static void iwl_mvm_scan_fill_ssids(struct iwl_scan_cmd *cmd,
140                                     struct cfg80211_scan_request *req,
141                                     int first)
142 {
143         int fw_idx, req_idx;
144
145         for (req_idx = req->n_ssids - 1, fw_idx = 0; req_idx >= first;
146              req_idx--, fw_idx++) {
147                 cmd->direct_scan[fw_idx].id = WLAN_EID_SSID;
148                 cmd->direct_scan[fw_idx].len = req->ssids[req_idx].ssid_len;
149                 memcpy(cmd->direct_scan[fw_idx].ssid,
150                        req->ssids[req_idx].ssid,
151                        req->ssids[req_idx].ssid_len);
152         }
153 }
154
155 /*
156  * If req->n_ssids > 0, it means we should do an active scan.
157  * In case of active scan w/o directed scan, we receive a zero-length SSID
158  * just to notify that this scan is active and not passive.
159  * In order to notify the FW of the number of SSIDs we wish to scan (including
160  * the zero-length one), we need to set the corresponding bits in chan->type,
161  * one for each SSID, and set the active bit (first). If the first SSID is
162  * already included in the probe template, so we need to set only
163  * req->n_ssids - 1 bits in addition to the first bit.
164  */
165 static u16 iwl_mvm_get_active_dwell(enum ieee80211_band band, int n_ssids)
166 {
167         if (band == IEEE80211_BAND_2GHZ)
168                 return 30  + 3 * (n_ssids + 1);
169         return 20  + 2 * (n_ssids + 1);
170 }
171
172 static u16 iwl_mvm_get_passive_dwell(enum ieee80211_band band)
173 {
174         return band == IEEE80211_BAND_2GHZ ? 100 + 20 : 100 + 10;
175 }
176
177 static void iwl_mvm_scan_fill_channels(struct iwl_scan_cmd *cmd,
178                                        struct cfg80211_scan_request *req,
179                                        bool basic_ssid)
180 {
181         u16 passive_dwell = iwl_mvm_get_passive_dwell(req->channels[0]->band);
182         u16 active_dwell = iwl_mvm_get_active_dwell(req->channels[0]->band,
183                                                     req->n_ssids);
184         struct iwl_scan_channel *chan = (struct iwl_scan_channel *)
185                 (cmd->data + le16_to_cpu(cmd->tx_cmd.len));
186         int i;
187         int type = BIT(req->n_ssids) - 1;
188
189         if (!basic_ssid)
190                 type |= BIT(req->n_ssids);
191
192         for (i = 0; i < cmd->channel_count; i++) {
193                 chan->channel = cpu_to_le16(req->channels[i]->hw_value);
194                 chan->type = cpu_to_le32(type);
195                 if (req->channels[i]->flags & IEEE80211_CHAN_PASSIVE_SCAN)
196                         chan->type &= cpu_to_le32(~SCAN_CHANNEL_TYPE_ACTIVE);
197                 chan->active_dwell = cpu_to_le16(active_dwell);
198                 chan->passive_dwell = cpu_to_le16(passive_dwell);
199                 chan->iteration_count = cpu_to_le16(1);
200                 chan++;
201         }
202 }
203
204 /*
205  * Fill in probe request with the following parameters:
206  * TA is our vif HW address, which mac80211 ensures we have.
207  * Packet is broadcasted, so this is both SA and DA.
208  * The probe request IE is made out of two: first comes the most prioritized
209  * SSID if a directed scan is requested. Second comes whatever extra
210  * information was given to us as the scan request IE.
211  */
212 static u16 iwl_mvm_fill_probe_req(struct ieee80211_mgmt *frame, const u8 *ta,
213                                   int n_ssids, const u8 *ssid, int ssid_len,
214                                   const u8 *ie, int ie_len,
215                                   int left)
216 {
217         int len = 0;
218         u8 *pos = NULL;
219
220         /* Make sure there is enough space for the probe request,
221          * two mandatory IEs and the data */
222         left -= 24;
223         if (left < 0)
224                 return 0;
225
226         frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
227         eth_broadcast_addr(frame->da);
228         memcpy(frame->sa, ta, ETH_ALEN);
229         eth_broadcast_addr(frame->bssid);
230         frame->seq_ctrl = 0;
231
232         len += 24;
233
234         /* for passive scans, no need to fill anything */
235         if (n_ssids == 0)
236                 return (u16)len;
237
238         /* points to the payload of the request */
239         pos = &frame->u.probe_req.variable[0];
240
241         /* fill in our SSID IE */
242         left -= ssid_len + 2;
243         if (left < 0)
244                 return 0;
245         *pos++ = WLAN_EID_SSID;
246         *pos++ = ssid_len;
247         if (ssid && ssid_len) { /* ssid_len may be == 0 even if ssid is valid */
248                 memcpy(pos, ssid, ssid_len);
249                 pos += ssid_len;
250         }
251
252         len += ssid_len + 2;
253
254         if (WARN_ON(left < ie_len))
255                 return len;
256
257         if (ie && ie_len) {
258                 memcpy(pos, ie, ie_len);
259                 len += ie_len;
260         }
261
262         return (u16)len;
263 }
264
265 int iwl_mvm_scan_request(struct iwl_mvm *mvm,
266                          struct ieee80211_vif *vif,
267                          struct cfg80211_scan_request *req)
268 {
269         struct iwl_host_cmd hcmd = {
270                 .id = SCAN_REQUEST_CMD,
271                 .len = { 0, },
272                 .data = { mvm->scan_cmd, },
273                 .flags = CMD_SYNC,
274                 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
275         };
276         struct iwl_scan_cmd *cmd = mvm->scan_cmd;
277         int ret;
278         u32 status;
279         int ssid_len = 0;
280         u8 *ssid = NULL;
281         bool basic_ssid = !(mvm->fw->ucode_capa.flags &
282                            IWL_UCODE_TLV_FLAGS_NO_BASIC_SSID);
283
284         lockdep_assert_held(&mvm->mutex);
285         BUG_ON(mvm->scan_cmd == NULL);
286
287         IWL_DEBUG_SCAN(mvm, "Handling mac80211 scan request\n");
288         mvm->scan_status = IWL_MVM_SCAN_OS;
289         memset(cmd, 0, sizeof(struct iwl_scan_cmd) +
290                mvm->fw->ucode_capa.max_probe_length +
291                (MAX_NUM_SCAN_CHANNELS * sizeof(struct iwl_scan_channel)));
292
293         cmd->channel_count = (u8)req->n_channels;
294         cmd->quiet_time = cpu_to_le16(IWL_ACTIVE_QUIET_TIME);
295         cmd->quiet_plcp_th = cpu_to_le16(IWL_PLCP_QUIET_THRESH);
296         cmd->rxchain_sel_flags = iwl_mvm_scan_rx_chain(mvm);
297         cmd->max_out_time = iwl_mvm_scan_max_out_time(vif);
298         cmd->suspend_time = iwl_mvm_scan_suspend_time(vif);
299         cmd->rxon_flags = iwl_mvm_scan_rxon_flags(req);
300         cmd->filter_flags = cpu_to_le32(MAC_FILTER_ACCEPT_GRP |
301                                         MAC_FILTER_IN_BEACON);
302
303         if (vif->type == NL80211_IFTYPE_P2P_DEVICE)
304                 cmd->type = cpu_to_le32(SCAN_TYPE_DISCOVERY_FORCED);
305         else
306                 cmd->type = cpu_to_le32(SCAN_TYPE_FORCED);
307
308         cmd->repeats = cpu_to_le32(1);
309
310         /*
311          * If the user asked for passive scan, don't change to active scan if
312          * you see any activity on the channel - remain passive.
313          */
314         if (req->n_ssids > 0) {
315                 cmd->passive2active = cpu_to_le16(1);
316                 cmd->scan_flags |= SCAN_FLAGS_PASSIVE2ACTIVE;
317                 if (basic_ssid) {
318                         ssid = req->ssids[0].ssid;
319                         ssid_len = req->ssids[0].ssid_len;
320                 }
321         } else {
322                 cmd->passive2active = 0;
323                 cmd->scan_flags &= ~SCAN_FLAGS_PASSIVE2ACTIVE;
324         }
325
326         iwl_mvm_scan_fill_ssids(cmd, req, basic_ssid ? 1 : 0);
327
328         cmd->tx_cmd.tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL);
329         cmd->tx_cmd.sta_id = mvm->aux_sta.sta_id;
330         cmd->tx_cmd.life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
331         cmd->tx_cmd.rate_n_flags =
332                         iwl_mvm_scan_rate_n_flags(mvm, req->channels[0]->band,
333                                                   req->no_cck);
334
335         cmd->tx_cmd.len =
336                 cpu_to_le16(iwl_mvm_fill_probe_req(
337                             (struct ieee80211_mgmt *)cmd->data,
338                             vif->addr,
339                             req->n_ssids, ssid, ssid_len,
340                             req->ie, req->ie_len,
341                             mvm->fw->ucode_capa.max_probe_length));
342
343         iwl_mvm_scan_fill_channels(cmd, req, basic_ssid);
344
345         cmd->len = cpu_to_le16(sizeof(struct iwl_scan_cmd) +
346                 le16_to_cpu(cmd->tx_cmd.len) +
347                 (cmd->channel_count * sizeof(struct iwl_scan_channel)));
348         hcmd.len[0] = le16_to_cpu(cmd->len);
349
350         status = SCAN_RESPONSE_OK;
351         ret = iwl_mvm_send_cmd_status(mvm, &hcmd, &status);
352         if (!ret && status == SCAN_RESPONSE_OK) {
353                 IWL_DEBUG_SCAN(mvm, "Scan request was sent successfully\n");
354         } else {
355                 /*
356                  * If the scan failed, it usually means that the FW was unable
357                  * to allocate the time events. Warn on it, but maybe we
358                  * should try to send the command again with different params.
359                  */
360                 IWL_ERR(mvm, "Scan failed! status 0x%x ret %d\n",
361                         status, ret);
362                 mvm->scan_status = IWL_MVM_SCAN_NONE;
363                 ret = -EIO;
364         }
365         return ret;
366 }
367
368 int iwl_mvm_rx_scan_response(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb,
369                           struct iwl_device_cmd *cmd)
370 {
371         struct iwl_rx_packet *pkt = rxb_addr(rxb);
372         struct iwl_cmd_response *resp = (void *)pkt->data;
373
374         IWL_DEBUG_SCAN(mvm, "Scan response received. status 0x%x\n",
375                        le32_to_cpu(resp->status));
376         return 0;
377 }
378
379 int iwl_mvm_rx_scan_complete(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb,
380                           struct iwl_device_cmd *cmd)
381 {
382         struct iwl_rx_packet *pkt = rxb_addr(rxb);
383         struct iwl_scan_complete_notif *notif = (void *)pkt->data;
384
385         IWL_DEBUG_SCAN(mvm, "Scan complete: status=0x%x scanned channels=%d\n",
386                        notif->status, notif->scanned_channels);
387
388         mvm->scan_status = IWL_MVM_SCAN_NONE;
389         ieee80211_scan_completed(mvm->hw, notif->status != SCAN_COMP_STATUS_OK);
390
391         return 0;
392 }
393
394 int iwl_mvm_rx_sched_scan_results(struct iwl_mvm *mvm,
395                                   struct iwl_rx_cmd_buffer *rxb,
396                                   struct iwl_device_cmd *cmd)
397 {
398         struct iwl_rx_packet *pkt = rxb_addr(rxb);
399         struct iwl_sched_scan_results *notif = (void *)pkt->data;
400
401         if (notif->client_bitmap & SCAN_CLIENT_SCHED_SCAN) {
402                 IWL_DEBUG_SCAN(mvm, "Scheduled scan results\n");
403                 ieee80211_sched_scan_results(mvm->hw);
404         }
405
406         return 0;
407 }
408
409 static bool iwl_mvm_scan_abort_notif(struct iwl_notif_wait_data *notif_wait,
410                                      struct iwl_rx_packet *pkt, void *data)
411 {
412         struct iwl_mvm *mvm =
413                 container_of(notif_wait, struct iwl_mvm, notif_wait);
414         struct iwl_scan_complete_notif *notif;
415         u32 *resp;
416
417         switch (pkt->hdr.cmd) {
418         case SCAN_ABORT_CMD:
419                 resp = (void *)pkt->data;
420                 if (*resp == CAN_ABORT_STATUS) {
421                         IWL_DEBUG_SCAN(mvm,
422                                        "Scan can be aborted, wait until completion\n");
423                         return false;
424                 }
425
426                 IWL_DEBUG_SCAN(mvm, "Scan cannot be aborted, exit now: %d\n",
427                                *resp);
428                 return true;
429
430         case SCAN_COMPLETE_NOTIFICATION:
431                 notif = (void *)pkt->data;
432                 IWL_DEBUG_SCAN(mvm, "Scan aborted: status 0x%x\n",
433                                notif->status);
434                 return true;
435
436         default:
437                 WARN_ON(1);
438                 return false;
439         };
440 }
441
442 void iwl_mvm_cancel_scan(struct iwl_mvm *mvm)
443 {
444         struct iwl_notification_wait wait_scan_abort;
445         static const u8 scan_abort_notif[] = { SCAN_ABORT_CMD,
446                                                SCAN_COMPLETE_NOTIFICATION };
447         int ret;
448
449         iwl_init_notification_wait(&mvm->notif_wait, &wait_scan_abort,
450                                    scan_abort_notif,
451                                    ARRAY_SIZE(scan_abort_notif),
452                                    iwl_mvm_scan_abort_notif, NULL);
453
454         ret = iwl_mvm_send_cmd_pdu(mvm, SCAN_ABORT_CMD, CMD_SYNC, 0, NULL);
455         if (ret) {
456                 IWL_ERR(mvm, "Couldn't send SCAN_ABORT_CMD: %d\n", ret);
457                 goto out_remove_notif;
458         }
459
460         ret = iwl_wait_notification(&mvm->notif_wait, &wait_scan_abort, 1 * HZ);
461         if (ret)
462                 IWL_ERR(mvm, "%s - failed on timeout\n", __func__);
463
464         return;
465
466 out_remove_notif:
467         iwl_remove_notification(&mvm->notif_wait, &wait_scan_abort);
468 }
469
470 int iwl_mvm_rx_scan_offload_complete_notif(struct iwl_mvm *mvm,
471                                            struct iwl_rx_cmd_buffer *rxb,
472                                            struct iwl_device_cmd *cmd)
473 {
474         struct iwl_rx_packet *pkt = rxb_addr(rxb);
475         struct iwl_scan_offload_complete *scan_notif = (void *)pkt->data;
476
477         IWL_DEBUG_SCAN(mvm, "Scheduled scan completed, status %s\n",
478                        scan_notif->status == IWL_SCAN_OFFLOAD_COMPLETED ?
479                        "completed" : "aborted");
480
481         mvm->scan_status = IWL_MVM_SCAN_NONE;
482         ieee80211_sched_scan_stopped(mvm->hw);
483
484         return 0;
485 }
486
487 static void iwl_scan_offload_build_tx_cmd(struct iwl_mvm *mvm,
488                                           struct ieee80211_vif *vif,
489                                           struct ieee80211_sched_scan_ies *ies,
490                                           enum ieee80211_band band,
491                                           struct iwl_tx_cmd *cmd,
492                                           u8 *data)
493 {
494         u16 cmd_len;
495
496         cmd->tx_flags = cpu_to_le32(TX_CMD_FLG_SEQ_CTL);
497         cmd->life_time = cpu_to_le32(TX_CMD_LIFE_TIME_INFINITE);
498         cmd->sta_id = mvm->aux_sta.sta_id;
499
500         cmd->rate_n_flags = iwl_mvm_scan_rate_n_flags(mvm, band, false);
501
502         cmd_len = iwl_mvm_fill_probe_req((struct ieee80211_mgmt *)data,
503                                          vif->addr,
504                                          1, NULL, 0,
505                                          ies->ie[band], ies->len[band],
506                                          SCAN_OFFLOAD_PROBE_REQ_SIZE);
507         cmd->len = cpu_to_le16(cmd_len);
508 }
509
510 static void iwl_build_scan_cmd(struct iwl_mvm *mvm,
511                                struct ieee80211_vif *vif,
512                                struct cfg80211_sched_scan_request *req,
513                                struct iwl_scan_offload_cmd *scan)
514 {
515         scan->channel_count =
516                 mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels +
517                 mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels;
518         scan->quiet_time = cpu_to_le16(IWL_ACTIVE_QUIET_TIME);
519         scan->quiet_plcp_th = cpu_to_le16(IWL_PLCP_QUIET_THRESH);
520         scan->good_CRC_th = IWL_GOOD_CRC_TH_DEFAULT;
521         scan->rx_chain = iwl_mvm_scan_rx_chain(mvm);
522         scan->max_out_time = cpu_to_le32(200 * 1024);
523         scan->suspend_time = iwl_mvm_scan_suspend_time(vif);
524         scan->filter_flags |= cpu_to_le32(MAC_FILTER_ACCEPT_GRP |
525                                           MAC_FILTER_IN_BEACON);
526         scan->scan_type = cpu_to_le32(SCAN_TYPE_BACKGROUND);
527         scan->rep_count = cpu_to_le32(1);
528 }
529
530 static int iwl_ssid_exist(u8 *ssid, u8 ssid_len, struct iwl_ssid_ie *ssid_list)
531 {
532         int i;
533
534         for (i = 0; i < PROBE_OPTION_MAX; i++) {
535                 if (!ssid_list[i].len)
536                         break;
537                 if (ssid_list[i].len == ssid_len &&
538                     !memcmp(ssid_list->ssid, ssid, ssid_len))
539                         return i;
540         }
541         return -1;
542 }
543
544 static void iwl_scan_offload_build_ssid(struct cfg80211_sched_scan_request *req,
545                                         struct iwl_scan_offload_cmd *scan,
546                                         u32 *ssid_bitmap)
547 {
548         int i, j;
549         int index;
550
551         /*
552          * copy SSIDs from match list.
553          * iwl_config_sched_scan_profiles() uses the order of these ssids to
554          * config match list.
555          */
556         for (i = 0; i < req->n_match_sets && i < PROBE_OPTION_MAX; i++) {
557                 scan->direct_scan[i].id = WLAN_EID_SSID;
558                 scan->direct_scan[i].len = req->match_sets[i].ssid.ssid_len;
559                 memcpy(scan->direct_scan[i].ssid, req->match_sets[i].ssid.ssid,
560                        scan->direct_scan[i].len);
561         }
562
563         /* add SSIDs from scan SSID list */
564         *ssid_bitmap = 0;
565         for (j = 0; j < req->n_ssids && i < PROBE_OPTION_MAX; j++) {
566                 index = iwl_ssid_exist(req->ssids[j].ssid,
567                                        req->ssids[j].ssid_len,
568                                        scan->direct_scan);
569                 if (index < 0) {
570                         if (!req->ssids[j].ssid_len)
571                                 continue;
572                         scan->direct_scan[i].id = WLAN_EID_SSID;
573                         scan->direct_scan[i].len = req->ssids[j].ssid_len;
574                         memcpy(scan->direct_scan[i].ssid, req->ssids[j].ssid,
575                                scan->direct_scan[i].len);
576                         *ssid_bitmap |= BIT(i + 1);
577                         i++;
578                 } else {
579                         *ssid_bitmap |= BIT(index + 1);
580                 }
581         }
582 }
583
584 static void iwl_build_channel_cfg(struct iwl_mvm *mvm,
585                                   struct cfg80211_sched_scan_request *req,
586                                   struct iwl_scan_channel_cfg *channels,
587                                   enum ieee80211_band band,
588                                   int *head, int *tail,
589                                   u32 ssid_bitmap)
590 {
591         struct ieee80211_supported_band *s_band;
592         int n_probes = req->n_ssids;
593         int n_channels = req->n_channels;
594         u8 active_dwell, passive_dwell;
595         int i, j, index = 0;
596         bool partial;
597
598         /*
599          * We have to configure all supported channels, even if we don't want to
600          * scan on them, but we have to send channels in the order that we want
601          * to scan. So add requested channels to head of the list and others to
602          * the end.
603         */
604         active_dwell = iwl_mvm_get_active_dwell(band, n_probes);
605         passive_dwell = iwl_mvm_get_passive_dwell(band);
606         s_band = &mvm->nvm_data->bands[band];
607
608         for (i = 0; i < s_band->n_channels && *head <= *tail; i++) {
609                 partial = false;
610                 for (j = 0; j < n_channels; j++)
611                         if (s_band->channels[i].center_freq ==
612                                                 req->channels[j]->center_freq) {
613                                 index = *head;
614                                 (*head)++;
615                                 /*
616                                  * Channels that came with the request will be
617                                  * in partial scan .
618                                  */
619                                 partial = true;
620                                 break;
621                         }
622                 if (!partial) {
623                         index = *tail;
624                         (*tail)--;
625                 }
626                 channels->channel_number[index] =
627                         cpu_to_le16(ieee80211_frequency_to_channel(
628                                         s_band->channels[i].center_freq));
629                 channels->dwell_time[index][0] = active_dwell;
630                 channels->dwell_time[index][1] = passive_dwell;
631
632                 channels->iter_count[index] = cpu_to_le16(1);
633                 channels->iter_interval[index] = 0;
634
635                 if (!(s_band->channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN))
636                         channels->type[index] |=
637                                 cpu_to_le32(IWL_SCAN_OFFLOAD_CHANNEL_ACTIVE);
638
639                 channels->type[index] |=
640                                 cpu_to_le32(IWL_SCAN_OFFLOAD_CHANNEL_FULL);
641                 if (partial)
642                         channels->type[index] |=
643                                 cpu_to_le32(IWL_SCAN_OFFLOAD_CHANNEL_PARTIAL);
644
645                 if (s_band->channels[i].flags & IEEE80211_CHAN_NO_HT40)
646                         channels->type[index] |=
647                                 cpu_to_le32(IWL_SCAN_OFFLOAD_CHANNEL_NARROW);
648
649                 /* scan for all SSIDs from req->ssids */
650                 channels->type[index] |= cpu_to_le32(ssid_bitmap);
651         }
652 }
653
654 int iwl_mvm_config_sched_scan(struct iwl_mvm *mvm,
655                               struct ieee80211_vif *vif,
656                               struct cfg80211_sched_scan_request *req,
657                               struct ieee80211_sched_scan_ies *ies)
658 {
659         int supported_bands = 0;
660         int band_2ghz = mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels;
661         int band_5ghz = mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels;
662         int head = 0;
663         int tail = band_2ghz + band_5ghz;
664         u32 ssid_bitmap;
665         int cmd_len;
666         int ret;
667
668         struct iwl_scan_offload_cfg *scan_cfg;
669         struct iwl_host_cmd cmd = {
670                 .id = SCAN_OFFLOAD_CONFIG_CMD,
671                 .flags = CMD_SYNC,
672         };
673
674         lockdep_assert_held(&mvm->mutex);
675
676         if (band_2ghz)
677                 supported_bands++;
678         if (band_5ghz)
679                 supported_bands++;
680
681         cmd_len = sizeof(struct iwl_scan_offload_cfg) +
682                                 supported_bands * SCAN_OFFLOAD_PROBE_REQ_SIZE;
683
684         scan_cfg = kzalloc(cmd_len, GFP_KERNEL);
685         if (!scan_cfg)
686                 return -ENOMEM;
687
688         iwl_build_scan_cmd(mvm, vif, req, &scan_cfg->scan_cmd);
689         scan_cfg->scan_cmd.len = cpu_to_le16(cmd_len);
690
691         iwl_scan_offload_build_ssid(req, &scan_cfg->scan_cmd, &ssid_bitmap);
692         /* build tx frames for supported bands */
693         if (band_2ghz) {
694                 iwl_scan_offload_build_tx_cmd(mvm, vif, ies,
695                                               IEEE80211_BAND_2GHZ,
696                                               &scan_cfg->scan_cmd.tx_cmd[0],
697                                               scan_cfg->data);
698                 iwl_build_channel_cfg(mvm, req, &scan_cfg->channel_cfg,
699                                       IEEE80211_BAND_2GHZ, &head, &tail,
700                                       ssid_bitmap);
701         }
702         if (band_5ghz) {
703                 iwl_scan_offload_build_tx_cmd(mvm, vif, ies,
704                                               IEEE80211_BAND_5GHZ,
705                                               &scan_cfg->scan_cmd.tx_cmd[1],
706                                               scan_cfg->data +
707                                                 SCAN_OFFLOAD_PROBE_REQ_SIZE);
708                 iwl_build_channel_cfg(mvm, req, &scan_cfg->channel_cfg,
709                                       IEEE80211_BAND_5GHZ, &head, &tail,
710                                       ssid_bitmap);
711         }
712
713         cmd.data[0] = scan_cfg;
714         cmd.len[0] = cmd_len;
715         cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
716
717         IWL_DEBUG_SCAN(mvm, "Sending scheduled scan config\n");
718
719         ret = iwl_mvm_send_cmd(mvm, &cmd);
720         kfree(scan_cfg);
721         return ret;
722 }
723
724 int iwl_mvm_config_sched_scan_profiles(struct iwl_mvm *mvm,
725                                        struct cfg80211_sched_scan_request *req)
726 {
727         struct iwl_scan_offload_profile *profile;
728         struct iwl_scan_offload_profile_cfg *profile_cfg;
729         struct iwl_scan_offload_blacklist *blacklist;
730         struct iwl_host_cmd cmd = {
731                 .id = SCAN_OFFLOAD_UPDATE_PROFILES_CMD,
732                 .flags = CMD_SYNC,
733                 .len[1] = sizeof(*profile_cfg),
734                 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
735                 .dataflags[1] = IWL_HCMD_DFL_NOCOPY,
736         };
737         int blacklist_len;
738         int i;
739         int ret;
740
741         if (WARN_ON(req->n_match_sets > IWL_SCAN_MAX_PROFILES))
742                         return -EIO;
743
744         if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_SHORT_BL)
745                 blacklist_len = IWL_SCAN_SHORT_BLACKLIST_LEN;
746         else
747                 blacklist_len = IWL_SCAN_MAX_BLACKLIST_LEN;
748
749         blacklist = kzalloc(sizeof(*blacklist) * blacklist_len, GFP_KERNEL);
750         if (!blacklist)
751                 return -ENOMEM;
752
753         profile_cfg = kzalloc(sizeof(*profile_cfg), GFP_KERNEL);
754         if (!profile_cfg) {
755                 ret = -ENOMEM;
756                 goto free_blacklist;
757         }
758
759         cmd.data[0] = blacklist;
760         cmd.len[0] = sizeof(*blacklist) * blacklist_len;
761         cmd.data[1] = profile_cfg;
762
763         /* No blacklist configuration */
764
765         profile_cfg->num_profiles = req->n_match_sets;
766         profile_cfg->active_clients = SCAN_CLIENT_SCHED_SCAN;
767         profile_cfg->pass_match = SCAN_CLIENT_SCHED_SCAN;
768         profile_cfg->match_notify = SCAN_CLIENT_SCHED_SCAN;
769
770         for (i = 0; i < req->n_match_sets; i++) {
771                 profile = &profile_cfg->profiles[i];
772                 profile->ssid_index = i;
773                 /* Support any cipher and auth algorithm */
774                 profile->unicast_cipher = 0xff;
775                 profile->auth_alg = 0xff;
776                 profile->network_type = IWL_NETWORK_TYPE_ANY;
777                 profile->band_selection = IWL_SCAN_OFFLOAD_SELECT_ANY;
778                 profile->client_bitmap = SCAN_CLIENT_SCHED_SCAN;
779         }
780
781         IWL_DEBUG_SCAN(mvm, "Sending scheduled scan profile config\n");
782
783         ret = iwl_mvm_send_cmd(mvm, &cmd);
784         kfree(profile_cfg);
785 free_blacklist:
786         kfree(blacklist);
787
788         return ret;
789 }
790
791 int iwl_mvm_sched_scan_start(struct iwl_mvm *mvm,
792                              struct cfg80211_sched_scan_request *req)
793 {
794         struct iwl_scan_offload_req scan_req = {
795                 .watchdog = IWL_SCHED_SCAN_WATCHDOG,
796
797                 .schedule_line[0].iterations = IWL_FAST_SCHED_SCAN_ITERATIONS,
798                 .schedule_line[0].delay = req->interval / 1000,
799                 .schedule_line[0].full_scan_mul = 1,
800
801                 .schedule_line[1].iterations = 0xff,
802                 .schedule_line[1].delay = req->interval / 1000,
803                 .schedule_line[1].full_scan_mul = IWL_FULL_SCAN_MULTIPLIER,
804         };
805
806         if (req->n_match_sets && req->match_sets[0].ssid.ssid_len) {
807                 IWL_DEBUG_SCAN(mvm,
808                                "Sending scheduled scan with filtering, filter len %d\n",
809                                req->n_match_sets);
810                 scan_req.flags |=
811                                 cpu_to_le16(IWL_SCAN_OFFLOAD_FLAG_FILTER_SSID);
812         } else {
813                 IWL_DEBUG_SCAN(mvm,
814                                "Sending Scheduled scan without filtering\n");
815         }
816
817         return iwl_mvm_send_cmd_pdu(mvm, SCAN_OFFLOAD_REQUEST_CMD, CMD_SYNC,
818                                     sizeof(scan_req), &scan_req);
819 }
820
821 static int iwl_mvm_send_sched_scan_abort(struct iwl_mvm *mvm)
822 {
823         int ret;
824         struct iwl_host_cmd cmd = {
825                 .id = SCAN_OFFLOAD_ABORT_CMD,
826                 .flags = CMD_SYNC,
827         };
828         u32 status;
829
830         /* Exit instantly with error when device is not ready
831          * to receive scan abort command or it does not perform
832          * scheduled scan currently */
833         if (mvm->scan_status != IWL_MVM_SCAN_SCHED)
834                 return -EIO;
835
836         ret = iwl_mvm_send_cmd_status(mvm, &cmd, &status);
837         if (ret)
838                 return ret;
839
840         if (status != CAN_ABORT_STATUS) {
841                 /*
842                  * The scan abort will return 1 for success or
843                  * 2 for "failure".  A failure condition can be
844                  * due to simply not being in an active scan which
845                  * can occur if we send the scan abort before the
846                  * microcode has notified us that a scan is completed.
847                  */
848                 IWL_DEBUG_SCAN(mvm, "SCAN OFFLOAD ABORT ret %d.\n", status);
849                 ret = -EIO;
850         }
851
852         return ret;
853 }
854
855 void iwl_mvm_sched_scan_stop(struct iwl_mvm *mvm)
856 {
857         int ret;
858
859         lockdep_assert_held(&mvm->mutex);
860
861         if (mvm->scan_status != IWL_MVM_SCAN_SCHED) {
862                 IWL_DEBUG_SCAN(mvm, "No offloaded scan to stop\n");
863                 return;
864         }
865
866         ret = iwl_mvm_send_sched_scan_abort(mvm);
867         if (ret)
868                 IWL_DEBUG_SCAN(mvm, "Send stop offload scan failed %d\n", ret);
869         else
870                 IWL_DEBUG_SCAN(mvm, "Successfully sent stop offload scan\n");
871 }