drivers/staging/wfx/scan.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Scan related functions.
   4  *
   5  * Copyright (c) 2017-2019, Silicon Laboratories, Inc.
   6  * Copyright (c) 2010, ST-Ericsson
   7  */
   8 #include <net/mac80211.h>
   9
  10 #include "scan.h"
  11 #include "wfx.h"
  12 #include "sta.h"
  13 #include "hif_tx_mib.h"
  14
  15 static void __ieee80211_scan_completed_compat(struct ieee80211_hw *hw,
  16                                               bool aborted)
  17 {
  18         struct cfg80211_scan_info info = {
  19                 .aborted = aborted,
  20         };
  21
  22         ieee80211_scan_completed(hw, &info);
  23 }
  24
  25 static int update_probe_tmpl(struct wfx_vif *wvif,
  26                              struct cfg80211_scan_request *req)
  27 {
  28         struct sk_buff *skb;
  29
  30         skb = ieee80211_probereq_get(wvif->wdev->hw, wvif->vif->addr,
  31                                      NULL, 0, req->ie_len);
  32         if (!skb)
  33                 return -ENOMEM;
  34
  35         skb_put_data(skb, req->ie, req->ie_len);
  36         hif_set_template_frame(wvif, skb, HIF_TMPLT_PRBREQ, 0);
  37         dev_kfree_skb(skb);
  38         return 0;
  39 }
  40
  41 static int send_scan_req(struct wfx_vif *wvif,
  42                          struct cfg80211_scan_request *req, int start_idx)
  43 {
  44         int i, ret, timeout;
  45         struct ieee80211_channel *ch_start, *ch_cur;
  46
  47         for (i = start_idx; i < req->n_channels; i++) {
  48                 ch_start = req->channels[start_idx];
  49                 ch_cur = req->channels[i];
  50                 WARN(ch_cur->band != NL80211_BAND_2GHZ, "band not supported");
  51                 if (ch_cur->max_power != ch_start->max_power)
  52                         break;
  53                 if ((ch_cur->flags ^ ch_start->flags) & IEEE80211_CHAN_NO_IR)
  54                         break;
  55         }
  56         wfx_tx_lock_flush(wvif->wdev);
  57         wvif->scan_abort = false;
  58         reinit_completion(&wvif->scan_complete);
  59         timeout = hif_scan(wvif, req, start_idx, i - start_idx);
  60         if (timeout < 0) {
  61                 wfx_tx_unlock(wvif->wdev);
  62                 return timeout;
  63         }
  64         ret = wait_for_completion_timeout(&wvif->scan_complete, timeout);
  65         if (req->channels[start_idx]->max_power != wvif->vif->bss_conf.txpower)
  66                 hif_set_output_power(wvif, wvif->vif->bss_conf.txpower);
  67         wfx_tx_unlock(wvif->wdev);
  68         if (!ret) {
  69                 dev_notice(wvif->wdev->dev, "scan timeout\n");
  70                 hif_stop_scan(wvif);
  71                 return -ETIMEDOUT;
  72         }
  73         if (wvif->scan_abort) {
  74                 dev_notice(wvif->wdev->dev, "scan abort\n");
  75                 return -ECONNABORTED;
  76         }
  77         return i - start_idx;
  78 }
  79
  80 /*
  81  * It is not really necessary to run scan request asynchronously. However,
  82  * there is a bug in "iw scan" when ieee80211_scan_completed() is called before
  83  * wfx_hw_scan() return
  84  */
  85 void wfx_hw_scan_work(struct work_struct *work)
  86 {
  87         struct wfx_vif *wvif = container_of(work, struct wfx_vif, scan_work);
  88         struct ieee80211_scan_request *hw_req = wvif->scan_req;
  89         int chan_cur, ret;
  90
  91         mutex_lock(&wvif->scan_lock);
  92         mutex_lock(&wvif->wdev->conf_mutex);
  93         update_probe_tmpl(wvif, &hw_req->req);
  94         wfx_fwd_probe_req(wvif, true);
  95         chan_cur = 0;
  96         do {
  97                 ret = send_scan_req(wvif, &hw_req->req, chan_cur);
  98                 if (ret > 0)
  99                         chan_cur += ret;
 100         } while (ret > 0 && chan_cur < hw_req->req.n_channels);
 101         mutex_unlock(&wvif->wdev->conf_mutex);
 102         mutex_unlock(&wvif->scan_lock);
 103         __ieee80211_scan_completed_compat(wvif->wdev->hw, ret < 0);
 104 }
 105
 106 int wfx_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 107                 struct ieee80211_scan_request *hw_req)
 108 {
 109         struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
 110
 111         WARN_ON(hw_req->req.n_channels > HIF_API_MAX_NB_CHANNELS);
 112
 113         if (vif->type == NL80211_IFTYPE_AP)
 114                 return -EOPNOTSUPP;
 115
 116         if (wvif->state == WFX_STATE_PRE_STA)
 117                 return -EBUSY;
 118
 119         wvif->scan_req = hw_req;
 120         schedule_work(&wvif->scan_work);
 121         return 0;
 122 }
 123
 124 void wfx_cancel_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 125 {
 126         struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
 127
 128         wvif->scan_abort = true;
 129         hif_stop_scan(wvif);
 130 }
 131
 132 void wfx_scan_complete(struct wfx_vif *wvif)
 133 {
 134         complete(&wvif->scan_complete);
 135 }