drivers/net/wireless/wl12xx/scan.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2009-2010 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23
  24 #include <linux/ieee80211.h>
  25
  26 #include "wl12xx.h"
  27 #include "cmd.h"
  28 #include "scan.h"
  29 #include "acx.h"
  30 #include "ps.h"
  31
  32 void wl1271_scan_complete_work(struct work_struct *work)
  33 {
  34         struct delayed_work *dwork;
  35         struct wl1271 *wl;
  36
  37         dwork = container_of(work, struct delayed_work, work);
  38         wl = container_of(dwork, struct wl1271, scan_complete_work);
  39
  40         wl1271_debug(DEBUG_SCAN, "Scanning complete");
  41
  42         mutex_lock(&wl->mutex);
  43
  44         if (wl->state == WL1271_STATE_OFF)
  45                 goto out;
  46
  47         if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
  48                 goto out;
  49
  50         wl->scan.state = WL1271_SCAN_STATE_IDLE;
  51         kfree(wl->scan.scanned_ch);
  52         wl->scan.scanned_ch = NULL;
  53         wl->scan.req = NULL;
  54         ieee80211_scan_completed(wl->hw, false);
  55
  56         /* restore hardware connection monitoring template */
  57         if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
  58                 if (wl1271_ps_elp_wakeup(wl) == 0) {
  59                         wl1271_cmd_build_ap_probe_req(wl, wl->probereq);
  60                         wl1271_ps_elp_sleep(wl);
  61                 }
  62         }
  63
  64         if (wl->scan.failed) {
  65                 wl1271_info("Scan completed due to error.");
  66                 ieee80211_queue_work(wl->hw, &wl->recovery_work);
  67         }
  68
  69 out:
  70         mutex_unlock(&wl->mutex);
  71
  72 }
  73
  74
  75 static int wl1271_get_scan_channels(struct wl1271 *wl,
  76                                     struct cfg80211_scan_request *req,
  77                                     struct basic_scan_channel_params *channels,
  78                                     enum ieee80211_band band, bool passive)
  79 {
  80         struct conf_scan_settings *c = &wl->conf.scan;
  81         int i, j;
  82         u32 flags;
  83
  84         for (i = 0, j = 0;
  85              i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS;
  86              i++) {
  87
  88                 flags = req->channels[i]->flags;
  89
  90                 if (!wl->scan.scanned_ch[i] &&
  91                     !(flags & IEEE80211_CHAN_DISABLED) &&
  92                     ((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) &&
  93                     (req->channels[i]->band == band)) {
  94
  95                         wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
  96                                      req->channels[i]->band,
  97                                      req->channels[i]->center_freq);
  98                         wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
  99                                      req->channels[i]->hw_value,
 100                                      req->channels[i]->flags);
 101                         wl1271_debug(DEBUG_SCAN,
 102                                      "max_antenna_gain %d, max_power %d",
 103                                      req->channels[i]->max_antenna_gain,
 104                                      req->channels[i]->max_power);
 105                         wl1271_debug(DEBUG_SCAN, "beacon_found %d",
 106                                      req->channels[i]->beacon_found);
 107
 108                         if (!passive) {
 109                                 channels[j].min_duration =
 110                                         cpu_to_le32(c->min_dwell_time_active);
 111                                 channels[j].max_duration =
 112                                         cpu_to_le32(c->max_dwell_time_active);
 113                         } else {
 114                                 channels[j].min_duration =
 115                                         cpu_to_le32(c->min_dwell_time_passive);
 116                                 channels[j].max_duration =
 117                                         cpu_to_le32(c->max_dwell_time_passive);
 118                         }
 119                         channels[j].early_termination = 0;
 120                         channels[j].tx_power_att = req->channels[i]->max_power;
 121                         channels[j].channel = req->channels[i]->hw_value;
 122
 123                         memset(&channels[j].bssid_lsb, 0xff, 4);
 124                         memset(&channels[j].bssid_msb, 0xff, 2);
 125
 126                         /* Mark the channels we already used */
 127                         wl->scan.scanned_ch[i] = true;
 128
 129                         j++;
 130                 }
 131         }
 132
 133         return j;
 134 }
 135
 136 #define WL1271_NOTHING_TO_SCAN 1
 137
 138 static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band,
 139                              bool passive, u32 basic_rate)
 140 {
 141         struct wl1271_cmd_scan *cmd;
 142         struct wl1271_cmd_trigger_scan_to *trigger;
 143         int ret;
 144         u16 scan_options = 0;
 145
 146         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 147         trigger = kzalloc(sizeof(*trigger), GFP_KERNEL);
 148         if (!cmd || !trigger) {
 149                 ret = -ENOMEM;
 150                 goto out;
 151         }
 152
 153         /* We always use high priority scans */
 154         scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH;
 155
 156         /* No SSIDs means that we have a forced passive scan */
 157         if (passive || wl->scan.req->n_ssids == 0)
 158                 scan_options |= WL1271_SCAN_OPT_PASSIVE;
 159
 160         cmd->params.scan_options = cpu_to_le16(scan_options);
 161
 162         cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req,
 163                                                     cmd->channels,
 164                                                     band, passive);
 165         if (cmd->params.n_ch == 0) {
 166                 ret = WL1271_NOTHING_TO_SCAN;
 167                 goto out;
 168         }
 169
 170         cmd->params.tx_rate = cpu_to_le32(basic_rate);
 171         cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
 172         cmd->params.rx_filter_options =
 173                 cpu_to_le32(CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN);
 174
 175         cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs;
 176         cmd->params.tx_rate = cpu_to_le32(basic_rate);
 177         cmd->params.tid_trigger = 0;
 178         cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;
 179
 180         if (band == IEEE80211_BAND_2GHZ)
 181                 cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
 182         else
 183                 cmd->params.band = WL1271_SCAN_BAND_5_GHZ;
 184
 185         if (wl->scan.ssid_len && wl->scan.ssid) {
 186                 cmd->params.ssid_len = wl->scan.ssid_len;
 187                 memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
 188         }
 189
 190         ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len,
 191                                          wl->scan.req->ie, wl->scan.req->ie_len,
 192                                          band);
 193         if (ret < 0) {
 194                 wl1271_error("PROBE request template failed");
 195                 goto out;
 196         }
 197
 198         /* disable the timeout */
 199         trigger->timeout = 0;
 200         ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
 201                               sizeof(*trigger), 0);
 202         if (ret < 0) {
 203                 wl1271_error("trigger scan to failed for hw scan");
 204                 goto out;
 205         }
 206
 207         wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd));
 208
 209         ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
 210         if (ret < 0) {
 211                 wl1271_error("SCAN failed");
 212                 goto out;
 213         }
 214
 215 out:
 216         kfree(cmd);
 217         kfree(trigger);
 218         return ret;
 219 }
 220
 221 void wl1271_scan_stm(struct wl1271 *wl)
 222 {
 223         int ret = 0;
 224
 225         switch (wl->scan.state) {
 226         case WL1271_SCAN_STATE_IDLE:
 227                 break;
 228
 229         case WL1271_SCAN_STATE_2GHZ_ACTIVE:
 230                 ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false,
 231                                        wl->conf.tx.basic_rate);
 232                 if (ret == WL1271_NOTHING_TO_SCAN) {
 233                         wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE;
 234                         wl1271_scan_stm(wl);
 235                 }
 236
 237                 break;
 238
 239         case WL1271_SCAN_STATE_2GHZ_PASSIVE:
 240                 ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true,
 241                                        wl->conf.tx.basic_rate);
 242                 if (ret == WL1271_NOTHING_TO_SCAN) {
 243                         if (wl->enable_11a)
 244                                 wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE;
 245                         else
 246                                 wl->scan.state = WL1271_SCAN_STATE_DONE;
 247                         wl1271_scan_stm(wl);
 248                 }
 249
 250                 break;
 251
 252         case WL1271_SCAN_STATE_5GHZ_ACTIVE:
 253                 ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false,
 254                                        wl->conf.tx.basic_rate_5);
 255                 if (ret == WL1271_NOTHING_TO_SCAN) {
 256                         wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE;
 257                         wl1271_scan_stm(wl);
 258                 }
 259
 260                 break;
 261
 262         case WL1271_SCAN_STATE_5GHZ_PASSIVE:
 263                 ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true,
 264                                        wl->conf.tx.basic_rate_5);
 265                 if (ret == WL1271_NOTHING_TO_SCAN) {
 266                         wl->scan.state = WL1271_SCAN_STATE_DONE;
 267                         wl1271_scan_stm(wl);
 268                 }
 269
 270                 break;
 271
 272         case WL1271_SCAN_STATE_DONE:
 273                 wl->scan.failed = false;
 274                 cancel_delayed_work(&wl->scan_complete_work);
 275                 ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
 276                                              msecs_to_jiffies(0));
 277                 break;
 278
 279         default:
 280                 wl1271_error("invalid scan state");
 281                 break;
 282         }
 283
 284         if (ret < 0) {
 285                 cancel_delayed_work(&wl->scan_complete_work);
 286                 ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
 287                                              msecs_to_jiffies(0));
 288         }
 289 }
 290
 291 int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len,
 292                 struct cfg80211_scan_request *req)
 293 {
 294         if (wl->scan.state != WL1271_SCAN_STATE_IDLE)
 295                 return -EBUSY;
 296
 297         wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE;
 298
 299         if (ssid_len && ssid) {
 300                 wl->scan.ssid_len = ssid_len;
 301                 memcpy(wl->scan.ssid, ssid, ssid_len);
 302         } else {
 303                 wl->scan.ssid_len = 0;
 304         }
 305
 306         wl->scan.req = req;
 307
 308         wl->scan.scanned_ch = kcalloc(req->n_channels,
 309                                       sizeof(*wl->scan.scanned_ch),
 310                                       GFP_KERNEL);
 311         /* we assume failure so that timeout scenarios are handled correctly */
 312         wl->scan.failed = true;
 313         ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
 314                                      msecs_to_jiffies(WL1271_SCAN_TIMEOUT));
 315
 316         wl1271_scan_stm(wl);
 317
 318         return 0;
 319 }