Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 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 | |
Shahar Levi | 00d2010 | 2010-11-08 11:20:10 +0000 | [diff] [blame] | 26 | #include "wl12xx.h" |
| 27 | #include "cmd.h" |
| 28 | #include "scan.h" |
| 29 | #include "acx.h" |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 30 | |
Juuso Oikarinen | c454f1d | 2010-08-24 06:28:03 +0300 | [diff] [blame] | 31 | void wl1271_scan_complete_work(struct work_struct *work) |
| 32 | { |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 33 | struct delayed_work *dwork; |
| 34 | struct wl1271 *wl; |
| 35 | |
| 36 | dwork = container_of(work, struct delayed_work, work); |
| 37 | wl = container_of(dwork, struct wl1271, scan_complete_work); |
Juuso Oikarinen | c454f1d | 2010-08-24 06:28:03 +0300 | [diff] [blame] | 38 | |
| 39 | wl1271_debug(DEBUG_SCAN, "Scanning complete"); |
| 40 | |
| 41 | mutex_lock(&wl->mutex); |
Juuso Oikarinen | 52a2a37 | 2010-09-21 06:23:30 +0200 | [diff] [blame] | 42 | |
| 43 | if (wl->scan.state == WL1271_SCAN_STATE_IDLE) { |
| 44 | mutex_unlock(&wl->mutex); |
| 45 | return; |
| 46 | } |
| 47 | |
Juuso Oikarinen | c454f1d | 2010-08-24 06:28:03 +0300 | [diff] [blame] | 48 | wl->scan.state = WL1271_SCAN_STATE_IDLE; |
| 49 | kfree(wl->scan.scanned_ch); |
| 50 | wl->scan.scanned_ch = NULL; |
Juuso Oikarinen | b739a42 | 2010-10-26 13:24:38 +0200 | [diff] [blame] | 51 | wl->scan.req = NULL; |
Juuso Oikarinen | c454f1d | 2010-08-24 06:28:03 +0300 | [diff] [blame] | 52 | ieee80211_scan_completed(wl->hw, false); |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 53 | |
Juuso Oikarinen | 2f6724b | 2010-11-24 08:16:57 +0200 | [diff] [blame^] | 54 | /* restore hardware connection monitoring template */ |
| 55 | if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) |
| 56 | wl1271_cmd_build_ap_probe_req(wl, wl->probereq); |
| 57 | |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 58 | if (wl->scan.failed) { |
| 59 | wl1271_info("Scan completed due to error."); |
| 60 | ieee80211_queue_work(wl->hw, &wl->recovery_work); |
| 61 | } |
Juuso Oikarinen | b739a42 | 2010-10-26 13:24:38 +0200 | [diff] [blame] | 62 | mutex_unlock(&wl->mutex); |
| 63 | |
Juuso Oikarinen | c454f1d | 2010-08-24 06:28:03 +0300 | [diff] [blame] | 64 | } |
| 65 | |
| 66 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 67 | static int wl1271_get_scan_channels(struct wl1271 *wl, |
| 68 | struct cfg80211_scan_request *req, |
| 69 | struct basic_scan_channel_params *channels, |
| 70 | enum ieee80211_band band, bool passive) |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 71 | { |
Juuso Oikarinen | bea39d6 | 2010-09-21 08:14:31 +0200 | [diff] [blame] | 72 | struct conf_scan_settings *c = &wl->conf.scan; |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 73 | int i, j; |
| 74 | u32 flags; |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 75 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 76 | for (i = 0, j = 0; |
| 77 | i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS; |
| 78 | i++) { |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 79 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 80 | flags = req->channels[i]->flags; |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 81 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 82 | if (!wl->scan.scanned_ch[i] && |
| 83 | !(flags & IEEE80211_CHAN_DISABLED) && |
| 84 | ((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) && |
| 85 | (req->channels[i]->band == band)) { |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 86 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 87 | wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ", |
| 88 | req->channels[i]->band, |
| 89 | req->channels[i]->center_freq); |
| 90 | wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X", |
| 91 | req->channels[i]->hw_value, |
| 92 | req->channels[i]->flags); |
| 93 | wl1271_debug(DEBUG_SCAN, |
| 94 | "max_antenna_gain %d, max_power %d", |
| 95 | req->channels[i]->max_antenna_gain, |
| 96 | req->channels[i]->max_power); |
| 97 | wl1271_debug(DEBUG_SCAN, "beacon_found %d", |
| 98 | req->channels[i]->beacon_found); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 99 | |
Juuso Oikarinen | bea39d6 | 2010-09-21 08:14:31 +0200 | [diff] [blame] | 100 | if (!passive) { |
| 101 | channels[j].min_duration = |
| 102 | cpu_to_le32(c->min_dwell_time_active); |
| 103 | channels[j].max_duration = |
| 104 | cpu_to_le32(c->max_dwell_time_active); |
| 105 | } else { |
| 106 | channels[j].min_duration = |
| 107 | cpu_to_le32(c->min_dwell_time_passive); |
| 108 | channels[j].max_duration = |
| 109 | cpu_to_le32(c->max_dwell_time_passive); |
| 110 | } |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 111 | channels[j].early_termination = 0; |
Luciano Coelho | 3cc7b54 | 2010-07-08 17:50:08 +0300 | [diff] [blame] | 112 | channels[j].tx_power_att = req->channels[i]->max_power; |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 113 | channels[j].channel = req->channels[i]->hw_value; |
| 114 | |
| 115 | memset(&channels[j].bssid_lsb, 0xff, 4); |
| 116 | memset(&channels[j].bssid_msb, 0xff, 2); |
| 117 | |
| 118 | /* Mark the channels we already used */ |
| 119 | wl->scan.scanned_ch[i] = true; |
| 120 | |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 121 | j++; |
| 122 | } |
| 123 | } |
| 124 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 125 | return j; |
| 126 | } |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 127 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 128 | #define WL1271_NOTHING_TO_SCAN 1 |
| 129 | |
| 130 | static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band, |
| 131 | bool passive, u32 basic_rate) |
| 132 | { |
| 133 | struct wl1271_cmd_scan *cmd; |
| 134 | struct wl1271_cmd_trigger_scan_to *trigger; |
| 135 | int ret; |
| 136 | u16 scan_options = 0; |
| 137 | |
| 138 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); |
| 139 | trigger = kzalloc(sizeof(*trigger), GFP_KERNEL); |
| 140 | if (!cmd || !trigger) { |
| 141 | ret = -ENOMEM; |
| 142 | goto out; |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 143 | } |
| 144 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 145 | /* We always use high priority scans */ |
| 146 | scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH; |
Luciano Coelho | 4f35c02 | 2010-08-04 04:36:32 +0300 | [diff] [blame] | 147 | |
| 148 | /* No SSIDs means that we have a forced passive scan */ |
| 149 | if (passive || wl->scan.req->n_ssids == 0) |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 150 | scan_options |= WL1271_SCAN_OPT_PASSIVE; |
Luciano Coelho | 4f35c02 | 2010-08-04 04:36:32 +0300 | [diff] [blame] | 151 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 152 | cmd->params.scan_options = cpu_to_le16(scan_options); |
| 153 | |
| 154 | cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req, |
| 155 | cmd->channels, |
| 156 | band, passive); |
| 157 | if (cmd->params.n_ch == 0) { |
| 158 | ret = WL1271_NOTHING_TO_SCAN; |
| 159 | goto out; |
| 160 | } |
| 161 | |
| 162 | cmd->params.tx_rate = cpu_to_le32(basic_rate); |
| 163 | cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD); |
| 164 | cmd->params.rx_filter_options = |
| 165 | cpu_to_le32(CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN); |
| 166 | |
Juuso Oikarinen | bea39d6 | 2010-09-21 08:14:31 +0200 | [diff] [blame] | 167 | cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs; |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 168 | cmd->params.tx_rate = cpu_to_le32(basic_rate); |
| 169 | cmd->params.tid_trigger = 0; |
| 170 | cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG; |
| 171 | |
| 172 | if (band == IEEE80211_BAND_2GHZ) |
| 173 | cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ; |
| 174 | else |
| 175 | cmd->params.band = WL1271_SCAN_BAND_5_GHZ; |
| 176 | |
| 177 | if (wl->scan.ssid_len && wl->scan.ssid) { |
| 178 | cmd->params.ssid_len = wl->scan.ssid_len; |
| 179 | memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len); |
| 180 | } |
| 181 | |
| 182 | ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len, |
| 183 | wl->scan.req->ie, wl->scan.req->ie_len, |
| 184 | band); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 185 | if (ret < 0) { |
| 186 | wl1271_error("PROBE request template failed"); |
| 187 | goto out; |
| 188 | } |
| 189 | |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 190 | /* disable the timeout */ |
| 191 | trigger->timeout = 0; |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 192 | ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger, |
| 193 | sizeof(*trigger), 0); |
| 194 | if (ret < 0) { |
| 195 | wl1271_error("trigger scan to failed for hw scan"); |
| 196 | goto out; |
| 197 | } |
| 198 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 199 | wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd)); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 200 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 201 | ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 202 | if (ret < 0) { |
| 203 | wl1271_error("SCAN failed"); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 204 | goto out; |
| 205 | } |
| 206 | |
| 207 | out: |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 208 | kfree(cmd); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 209 | kfree(trigger); |
| 210 | return ret; |
| 211 | } |
| 212 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 213 | void wl1271_scan_stm(struct wl1271 *wl) |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 214 | { |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 215 | int ret = 0; |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 216 | |
| 217 | switch (wl->scan.state) { |
| 218 | case WL1271_SCAN_STATE_IDLE: |
| 219 | break; |
| 220 | |
| 221 | case WL1271_SCAN_STATE_2GHZ_ACTIVE: |
| 222 | ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false, |
| 223 | wl->conf.tx.basic_rate); |
| 224 | if (ret == WL1271_NOTHING_TO_SCAN) { |
| 225 | wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE; |
| 226 | wl1271_scan_stm(wl); |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 227 | } |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 228 | |
| 229 | break; |
| 230 | |
| 231 | case WL1271_SCAN_STATE_2GHZ_PASSIVE: |
| 232 | ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true, |
| 233 | wl->conf.tx.basic_rate); |
| 234 | if (ret == WL1271_NOTHING_TO_SCAN) { |
Juuso Oikarinen | 02fabb0 | 2010-08-19 04:41:15 +0200 | [diff] [blame] | 235 | if (wl->enable_11a) |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 236 | wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE; |
| 237 | else |
| 238 | wl->scan.state = WL1271_SCAN_STATE_DONE; |
| 239 | wl1271_scan_stm(wl); |
| 240 | } |
| 241 | |
| 242 | break; |
| 243 | |
| 244 | case WL1271_SCAN_STATE_5GHZ_ACTIVE: |
| 245 | ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false, |
| 246 | wl->conf.tx.basic_rate_5); |
| 247 | if (ret == WL1271_NOTHING_TO_SCAN) { |
| 248 | wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE; |
| 249 | wl1271_scan_stm(wl); |
| 250 | } |
| 251 | |
| 252 | break; |
| 253 | |
| 254 | case WL1271_SCAN_STATE_5GHZ_PASSIVE: |
| 255 | ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true, |
| 256 | wl->conf.tx.basic_rate_5); |
| 257 | if (ret == WL1271_NOTHING_TO_SCAN) { |
| 258 | wl->scan.state = WL1271_SCAN_STATE_DONE; |
| 259 | wl1271_scan_stm(wl); |
| 260 | } |
| 261 | |
| 262 | break; |
| 263 | |
| 264 | case WL1271_SCAN_STATE_DONE: |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 265 | wl->scan.failed = false; |
| 266 | cancel_delayed_work(&wl->scan_complete_work); |
| 267 | ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work, |
| 268 | msecs_to_jiffies(0)); |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 269 | break; |
| 270 | |
| 271 | default: |
| 272 | wl1271_error("invalid scan state"); |
| 273 | break; |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 274 | } |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 275 | |
| 276 | if (ret < 0) { |
| 277 | cancel_delayed_work(&wl->scan_complete_work); |
| 278 | ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work, |
| 279 | msecs_to_jiffies(0)); |
| 280 | } |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len, |
| 284 | struct cfg80211_scan_request *req) |
| 285 | { |
| 286 | if (wl->scan.state != WL1271_SCAN_STATE_IDLE) |
| 287 | return -EBUSY; |
| 288 | |
| 289 | wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE; |
| 290 | |
| 291 | if (ssid_len && ssid) { |
| 292 | wl->scan.ssid_len = ssid_len; |
| 293 | memcpy(wl->scan.ssid, ssid, ssid_len); |
| 294 | } else { |
| 295 | wl->scan.ssid_len = 0; |
| 296 | } |
| 297 | |
| 298 | wl->scan.req = req; |
| 299 | |
Joe Perches | baeb2ff | 2010-08-11 07:02:48 +0000 | [diff] [blame] | 300 | wl->scan.scanned_ch = kcalloc(req->n_channels, |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 301 | sizeof(*wl->scan.scanned_ch), |
| 302 | GFP_KERNEL); |
Juuso Oikarinen | 78abd32 | 2010-09-21 06:23:32 +0200 | [diff] [blame] | 303 | /* we assume failure so that timeout scenarios are handled correctly */ |
| 304 | wl->scan.failed = true; |
| 305 | ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work, |
| 306 | msecs_to_jiffies(WL1271_SCAN_TIMEOUT)); |
| 307 | |
Luciano Coelho | 08688d6 | 2010-07-08 17:50:07 +0300 | [diff] [blame] | 308 | wl1271_scan_stm(wl); |
| 309 | |
Luciano Coelho | 34dd2aa | 2010-07-08 17:50:06 +0300 | [diff] [blame] | 310 | return 0; |
| 311 | } |