projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: avoid blocking while holding rcu lock on bss info change
[deliverable/linux.git] / drivers / net / wireless / wl12xx / main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 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/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
f5fc0f86 33
00d20100 34#include "wl12xx.h"
f5fc0f86 35#include "wl12xx_80211.h"
00d20100
SL		 36#include "reg.h"
37#include "io.h"
38#include "event.h"
39#include "tx.h"
40#include "rx.h"
41#include "ps.h"
42#include "init.h"
43#include "debugfs.h"
44#include "cmd.h"
45#include "boot.h"
46#include "testmode.h"
47#include "scan.h"
f5fc0f86 48
9ccd9217
JO		 49#define WL1271_BOOT_RETRIES 3
50
8a08048a
JO		 51static struct conf_drv_settings default_conf = {
52 .sg = {
1b00f546
JO		 53 .params = {
54 [CONF_SG_BT_PER_THRESHOLD] = 7500,
55 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
56 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
57 [CONF_SG_BT_LOAD_RATIO] = 50,
8d2ef7bd 58 [CONF_SG_AUTO_PS_MODE] = 1,
1b00f546
JO		 59 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
60 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
61 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
62 [CONF_SG_BEACON_MISS_PERCENT] = 60,
63 [CONF_SG_RATE_ADAPT_THRESH] = 12,
64 [CONF_SG_RATE_ADAPT_SNR] = 0,
65 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
67 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
68 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
70 /* Note: with UPSD, this should be 4 */
71 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
72 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
74 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
75 /* Note: with UPDS, this should be 15 */
76 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
77 /* Note: with UPDS, this should be 50 */
78 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
79 /* Note: with UPDS, this should be 10 */
80 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
81 [CONF_SG_RXT] = 1200,
82 [CONF_SG_TXT] = 1000,
83 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
84 [CONF_SG_PS_POLL_TIMEOUT] = 10,
85 [CONF_SG_UPSD_TIMEOUT] = 10,
86 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
88 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
91 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
92 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
94 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
95 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
97 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
98 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
99 [CONF_SG_HV3_MAX_SERVED] = 6,
100 [CONF_SG_DHCP_TIME] = 5000,
101 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
102 },
103 .state = CONF_SG_PROTECTIVE,
8a08048a
JO		 104 },
105 .rx = {
106 .rx_msdu_life_time = 512000,
107 .packet_detection_threshold = 0,
108 .ps_poll_timeout = 15,
109 .upsd_timeout = 15,
110 .rts_threshold = 2347,
3ed8f2c6
LC		 111 .rx_cca_threshold = 0,
112 .irq_blk_threshold = 0xFFFF,
113 .irq_pkt_threshold = 0,
114 .irq_timeout = 600,
8a08048a
JO		 115 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
116 },
117 .tx = {
118 .tx_energy_detection = 0,
1e05a818 119 .sta_rc_conf = {
ebba60c6 120 .enabled_rates = 0,
8a08048a
JO		 121 .short_retry_limit = 10,
122 .long_retry_limit = 10,
1e05a818 123 .aflags = 0,
45b531a8 124 },
8a08048a
JO		 125 .ac_conf_count = 4,
126 .ac_conf = {
9987a9da 127 [CONF_TX_AC_BE] = {
8a08048a
JO		 128 .ac = CONF_TX_AC_BE,
129 .cw_min = 15,
130 .cw_max = 63,
131 .aifsn = 3,
132 .tx_op_limit = 0,
45b531a8 133 },
9987a9da 134 [CONF_TX_AC_BK] = {
8a08048a
JO		 135 .ac = CONF_TX_AC_BK,
136 .cw_min = 15,
137 .cw_max = 63,
138 .aifsn = 7,
139 .tx_op_limit = 0,
45b531a8 140 },
9987a9da 141 [CONF_TX_AC_VI] = {
8a08048a
JO		 142 .ac = CONF_TX_AC_VI,
143 .cw_min = 15,
144 .cw_max = 63,
145 .aifsn = CONF_TX_AIFS_PIFS,
146 .tx_op_limit = 3008,
147 },
9987a9da 148 [CONF_TX_AC_VO] = {
8a08048a
JO		 149 .ac = CONF_TX_AC_VO,
150 .cw_min = 15,
151 .cw_max = 63,
152 .aifsn = CONF_TX_AIFS_PIFS,
153 .tx_op_limit = 1504,
45b531a8 154 },
51f2be24 155 },
1e05a818
AN		 156 .ap_rc_conf = {
157 [0] = {
158 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
159 .short_retry_limit = 10,
160 .long_retry_limit = 10,
161 .aflags = 0,
162 },
163 [1] = {
164 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
165 .short_retry_limit = 10,
166 .long_retry_limit = 10,
167 .aflags = 0,
168 },
169 [2] = {
170 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
171 .short_retry_limit = 10,
172 .long_retry_limit = 10,
173 .aflags = 0,
174 },
175 [3] = {
176 .enabled_rates = CONF_TX_AP_ENABLED_RATES,
177 .short_retry_limit = 10,
178 .long_retry_limit = 10,
179 .aflags = 0,
180 },
181 },
182 .ap_mgmt_conf = {
183 .enabled_rates = CONF_TX_AP_DEFAULT_MGMT_RATES,
184 .short_retry_limit = 10,
185 .long_retry_limit = 10,
186 .aflags = 0,
187 },
188 .ap_bcst_conf = {
189 .enabled_rates = CONF_HW_BIT_RATE_1MBPS,
190 .short_retry_limit = 10,
191 .long_retry_limit = 10,
192 .aflags = 0,
193 },
79b223f4 194 .ap_max_tx_retries = 100,
9987a9da 195 .tid_conf_count = 4,
8a08048a 196 .tid_conf = {
9987a9da
JO		 197 [CONF_TX_AC_BE] = {
198 .queue_id = CONF_TX_AC_BE,
199 .channel_type = CONF_CHANNEL_TYPE_EDCF,
8a08048a
JO		 200 .tsid = CONF_TX_AC_BE,
201 .ps_scheme = CONF_PS_SCHEME_LEGACY,
202 .ack_policy = CONF_ACK_POLICY_LEGACY,
203 .apsd_conf = {0, 0},
51f2be24 204 },
9987a9da
JO		 205 [CONF_TX_AC_BK] = {
206 .queue_id = CONF_TX_AC_BK,
207 .channel_type = CONF_CHANNEL_TYPE_EDCF,
208 .tsid = CONF_TX_AC_BK,
8a08048a
JO		 209 .ps_scheme = CONF_PS_SCHEME_LEGACY,
210 .ack_policy = CONF_ACK_POLICY_LEGACY,
211 .apsd_conf = {0, 0},
212 },
9987a9da
JO		 213 [CONF_TX_AC_VI] = {
214 .queue_id = CONF_TX_AC_VI,
215 .channel_type = CONF_CHANNEL_TYPE_EDCF,
216 .tsid = CONF_TX_AC_VI,
8a08048a
JO		 217 .ps_scheme = CONF_PS_SCHEME_LEGACY,
218 .ack_policy = CONF_ACK_POLICY_LEGACY,
219 .apsd_conf = {0, 0},
220 },
9987a9da
JO		 221 [CONF_TX_AC_VO] = {
222 .queue_id = CONF_TX_AC_VO,
223 .channel_type = CONF_CHANNEL_TYPE_EDCF,
224 .tsid = CONF_TX_AC_VO,
8a08048a
JO		 225 .ps_scheme = CONF_PS_SCHEME_LEGACY,
226 .ack_policy = CONF_ACK_POLICY_LEGACY,
227 .apsd_conf = {0, 0},
228 },
8a08048a
JO		 229 },
230 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6 231 .tx_compl_timeout = 700,
ebba60c6
JO		 232 .tx_compl_threshold = 4,
233 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
234 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
1e05a818
AN		 235 .tmpl_short_retry_limit = 10,
236 .tmpl_long_retry_limit = 10,
8a08048a
JO		 237 },
238 .conn = {
239 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
50c500ad 240 .listen_interval = 1,
8a08048a
JO		 241 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
242 .bcn_filt_ie_count = 1,
243 .bcn_filt_ie = {
244 [0] = {
245 .ie = WLAN_EID_CHANNEL_SWITCH,
246 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
51f2be24 247 }
47fab7d5 248 },
3ed8f2c6 249 .synch_fail_thold = 10,
8a08048a
JO		 250 .bss_lose_timeout = 100,
251 .beacon_rx_timeout = 10000,
252 .broadcast_timeout = 20000,
253 .rx_broadcast_in_ps = 1,
90494a90
JO		 254 .ps_poll_threshold = 10,
255 .ps_poll_recovery_period = 700,
11f70f97 256 .bet_enable = CONF_BET_MODE_ENABLE,
84502563 257 .bet_max_consecutive = 10,
8eab7b47 258 .psm_entry_retries = 5,
ee60833a 259 .psm_exit_retries = 255,
8eab7b47
JO		 260 .psm_entry_nullfunc_retries = 3,
261 .psm_entry_hangover_period = 1,
50c500ad
JO		 262 .keep_alive_interval = 55000,
263 .max_listen_interval = 20,
8a08048a 264 },
6e92b416
LC		 265 .itrim = {
266 .enable = false,
267 .timeout = 50000,
38ad2d87
JO		 268 },
269 .pm_config = {
270 .host_clk_settling_time = 5000,
271 .host_fast_wakeup_support = false
00236aed
JO		 272 },
273 .roam_trigger = {
00236aed
JO		 274 .trigger_pacing = 1,
275 .avg_weight_rssi_beacon = 20,
276 .avg_weight_rssi_data = 10,
277 .avg_weight_snr_beacon = 20,
4b7fac77 278 .avg_weight_snr_data = 10,
bea39d6a
JO		 279 },
280 .scan = {
281 .min_dwell_time_active = 7500,
282 .max_dwell_time_active = 30000,
ea45b2cb
JO		 283 .min_dwell_time_passive = 100000,
284 .max_dwell_time_passive = 100000,
bea39d6a
JO		 285 .num_probe_reqs = 2,
286 },
644a4860
JO		 287 .rf = {
288 .tx_per_channel_power_compensation_2 = {
289 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
290 },
291 .tx_per_channel_power_compensation_5 = {
292 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
295 },
296 },
4b7fac77
LS		 297 .ht = {
298 .tx_ba_win_size = 64,
299 .inactivity_timeout = 10000,
300 },
c8bde243 301 .mem = {
fe5ef090
EP		 302 .num_stations = 1,
303 .ssid_profiles = 1,
304 .rx_block_num = 70,
305 .tx_min_block_num = 40,
c8bde243
EP		 306 .dynamic_memory = 0,
307 .min_req_tx_blocks = 104,
308 .min_req_rx_blocks = 22,
309 .tx_min = 27,
310 }
8a08048a
JO		 311};
312
52b0e7a6 313static void __wl1271_op_remove_interface(struct wl1271 *wl);
7f179b46 314static void wl1271_free_ap_keys(struct wl1271 *wl);
52b0e7a6
JO		 315
316
a1dd8187
JO		 317static void wl1271_device_release(struct device *dev)
318{
319
320}
321
322static struct platform_device wl1271_device = {
323 .name = "wl1271",
324 .id = -1,
325
326 /* device model insists to have a release function */
327 .dev = {
328 .release = wl1271_device_release,
329 },
330};
331
01c09162
JO		 332static LIST_HEAD(wl_list);
333
c2c192ac
JO		 334static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
335 void *arg)
336{
337 struct net_device *dev = arg;
338 struct wireless_dev *wdev;
339 struct wiphy *wiphy;
340 struct ieee80211_hw *hw;
341 struct wl1271 *wl;
342 struct wl1271 *wl_temp;
343 int ret = 0;
344
345 /* Check that this notification is for us. */
346 if (what != NETDEV_CHANGE)
347 return NOTIFY_DONE;
348
349 wdev = dev->ieee80211_ptr;
350 if (wdev == NULL)
351 return NOTIFY_DONE;
352
353 wiphy = wdev->wiphy;
354 if (wiphy == NULL)
355 return NOTIFY_DONE;
356
357 hw = wiphy_priv(wiphy);
358 if (hw == NULL)
359 return NOTIFY_DONE;
360
361 wl_temp = hw->priv;
362 list_for_each_entry(wl, &wl_list, list) {
363 if (wl == wl_temp)
364 break;
365 }
366 if (wl != wl_temp)
367 return NOTIFY_DONE;
368
369 mutex_lock(&wl->mutex);
370
371 if (wl->state == WL1271_STATE_OFF)
372 goto out;
373
374 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
375 goto out;
376
377 ret = wl1271_ps_elp_wakeup(wl, false);
378 if (ret < 0)
379 goto out;
380
381 if ((dev->operstate == IF_OPER_UP) &&
382 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
383 wl1271_cmd_set_sta_state(wl);
384 wl1271_info("Association completed.");
385 }
386
387 wl1271_ps_elp_sleep(wl);
388
389out:
390 mutex_unlock(&wl->mutex);
391
392 return NOTIFY_OK;
393}
394
b7417d93 395static int wl1271_reg_notify(struct wiphy *wiphy,
573c67cf
LC		 396 struct regulatory_request *request)
397{
b7417d93
JO		 398 struct ieee80211_supported_band *band;
399 struct ieee80211_channel *ch;
400 int i;
401
402 band = wiphy->bands[IEEE80211_BAND_5GHZ];
403 for (i = 0; i < band->n_channels; i++) {
404 ch = &band->channels[i];
405 if (ch->flags & IEEE80211_CHAN_DISABLED)
406 continue;
407
408 if (ch->flags & IEEE80211_CHAN_RADAR)
409 ch->flags |= IEEE80211_CHAN_NO_IBSS |
410 IEEE80211_CHAN_PASSIVE_SCAN;
411
412 }
413
414 return 0;
415}
416
8a08048a
JO		 417static void wl1271_conf_init(struct wl1271 *wl)
418{
2b60100b
JO		 419
420 /*
421 * This function applies the default configuration to the driver. This
422 * function is invoked upon driver load (spi probe.)
423 *
424 * The configuration is stored in a run-time structure in order to
425 * facilitate for run-time adjustment of any of the parameters. Making
426 * changes to the configuration structure will apply the new values on
427 * the next interface up (wl1271_op_start.)
428 */
429
430 /* apply driver default configuration */
8a08048a 431 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
2b60100b
JO		 432}
433
434
f5fc0f86
LC		 435static int wl1271_plt_init(struct wl1271 *wl)
436{
12419cce
LC		 437 struct conf_tx_ac_category *conf_ac;
438 struct conf_tx_tid *conf_tid;
439 int ret, i;
f5fc0f86 440
98b5dd5d 441 ret = wl1271_cmd_general_parms(wl);
4a90406b 442 if (ret < 0)
cc7defa3
LC		 443 return ret;
444
98b5dd5d 445 ret = wl1271_cmd_radio_parms(wl);
4a90406b 446 if (ret < 0)
cc7defa3
LC		 447 return ret;
448
644a4860
JO		 449 ret = wl1271_cmd_ext_radio_parms(wl);
450 if (ret < 0)
451 return ret;
452
e0fe371b 453 ret = wl1271_sta_init_templates_config(wl);
12419cce
LC		 454 if (ret < 0)
455 return ret;
456
f5fc0f86
LC		 457 ret = wl1271_acx_init_mem_config(wl);
458 if (ret < 0)
459 return ret;
460
12419cce
LC		 461 /* PHY layer config */
462 ret = wl1271_init_phy_config(wl);
463 if (ret < 0)
464 goto out_free_memmap;
465
466 ret = wl1271_acx_dco_itrim_params(wl);
467 if (ret < 0)
468 goto out_free_memmap;
469
470 /* Initialize connection monitoring thresholds */
6ccbb92e 471 ret = wl1271_acx_conn_monit_params(wl, false);
12419cce
LC		 472 if (ret < 0)
473 goto out_free_memmap;
474
475 /* Bluetooth WLAN coexistence */
476 ret = wl1271_init_pta(wl);
477 if (ret < 0)
478 goto out_free_memmap;
479
480 /* Energy detection */
481 ret = wl1271_init_energy_detection(wl);
482 if (ret < 0)
483 goto out_free_memmap;
484
1ec610eb
GK		 485 ret = wl1271_acx_sta_mem_cfg(wl);
486 if (ret < 0)
487 goto out_free_memmap;
488
12419cce 489 /* Default fragmentation threshold */
68d069c4 490 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
12419cce
LC		 491 if (ret < 0)
492 goto out_free_memmap;
493
9987a9da
JO		 494 /* Default TID/AC configuration */
495 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
12419cce 496 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
9987a9da
JO		 497 conf_ac = &wl->conf.tx.ac_conf[i];
498 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
499 conf_ac->cw_max, conf_ac->aifsn,
500 conf_ac->tx_op_limit);
501 if (ret < 0)
502 goto out_free_memmap;
503
12419cce
LC		 504 conf_tid = &wl->conf.tx.tid_conf[i];
505 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
506 conf_tid->channel_type,
507 conf_tid->tsid,
508 conf_tid->ps_scheme,
509 conf_tid->ack_policy,
510 conf_tid->apsd_conf[0],
511 conf_tid->apsd_conf[1]);
512 if (ret < 0)
513 goto out_free_memmap;
514 }
515
12419cce 516 /* Enable data path */
94210897 517 ret = wl1271_cmd_data_path(wl, 1);
f5fc0f86 518 if (ret < 0)
12419cce
LC		 519 goto out_free_memmap;
520
521 /* Configure for CAM power saving (ie. always active) */
522 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
523 if (ret < 0)
524 goto out_free_memmap;
525
526 /* configure PM */
527 ret = wl1271_acx_pm_config(wl);
528 if (ret < 0)
529 goto out_free_memmap;
f5fc0f86
LC		 530
531 return 0;
12419cce
LC		 532
533 out_free_memmap:
534 kfree(wl->target_mem_map);
535 wl->target_mem_map = NULL;
536
537 return ret;
f5fc0f86
LC		 538}
539
c15f63bf 540static void wl1271_fw_status(struct wl1271 *wl,
c8bde243 541 struct wl1271_fw_full_status *full_status)
f5fc0f86 542{
c8bde243 543 struct wl1271_fw_common_status *status = &full_status->common;
ac5e1e39 544 struct timespec ts;
f5fc0f86
LC		 545 u32 total = 0;
546 int i;
547
c8bde243
EP		 548 if (wl->bss_type == BSS_TYPE_AP_BSS)
549 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
550 sizeof(struct wl1271_fw_ap_status), false);
551 else
552 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
553 sizeof(struct wl1271_fw_sta_status), false);
f5fc0f86
LC		 554
555 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
556 "drv_rx_counter = %d, tx_results_counter = %d)",
557 status->intr,
558 status->fw_rx_counter,
559 status->drv_rx_counter,
560 status->tx_results_counter);
561
562 /* update number of available TX blocks */
563 for (i = 0; i < NUM_TX_QUEUES; i++) {
d0f63b20
LC		 564 u32 cnt = le32_to_cpu(status->tx_released_blks[i]) -
565 wl->tx_blocks_freed[i];
566
567 wl->tx_blocks_freed[i] =
568 le32_to_cpu(status->tx_released_blks[i]);
f5fc0f86
LC		 569 wl->tx_blocks_available += cnt;
570 total += cnt;
571 }
572
a522550a
IY		 573 /* if more blocks are available now, tx work can be scheduled */
574 if (total)
575 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
f5fc0f86
LC		 576
577 /* update the host-chipset time offset */
ac5e1e39
JO		 578 getnstimeofday(&ts);
579 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
580 (s64)le32_to_cpu(status->fw_localtime);
f5fc0f86
LC		 581}
582
1e73eb62
JO		 583#define WL1271_IRQ_MAX_LOOPS 10
584
f5fc0f86
LC		 585static void wl1271_irq_work(struct work_struct *work)
586{
f5fc0f86 587 int ret;
c15f63bf 588 u32 intr;
1e73eb62
JO		 589 int loopcount = WL1271_IRQ_MAX_LOOPS;
590 unsigned long flags;
f5fc0f86
LC		 591 struct wl1271 *wl =
592 container_of(work, struct wl1271, irq_work);
593
594 mutex_lock(&wl->mutex);
595
596 wl1271_debug(DEBUG_IRQ, "IRQ work");
597
1e73eb62 598 if (unlikely(wl->state == WL1271_STATE_OFF))
f5fc0f86
LC		 599 goto out;
600
601 ret = wl1271_ps_elp_wakeup(wl, true);
602 if (ret < 0)
603 goto out;
604
1e73eb62
JO		 605 spin_lock_irqsave(&wl->wl_lock, flags);
606 while (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags) && loopcount) {
607 clear_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags);
608 spin_unlock_irqrestore(&wl->wl_lock, flags);
609 loopcount--;
610
611 wl1271_fw_status(wl, wl->fw_status);
c8bde243 612 intr = le32_to_cpu(wl->fw_status->common.intr);
1e73eb62
JO		 613 if (!intr) {
614 wl1271_debug(DEBUG_IRQ, "Zero interrupt received.");
cdd0864a 615 spin_lock_irqsave(&wl->wl_lock, flags);
1e73eb62
JO		 616 continue;
617 }
f5fc0f86 618
1e73eb62 619 intr &= WL1271_INTR_MASK;
f5fc0f86 620
ccc83b04
EP		 621 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
622 wl1271_error("watchdog interrupt received! "
623 "starting recovery.");
624 ieee80211_queue_work(wl->hw, &wl->recovery_work);
625
626 /* restarting the chip. ignore any other interrupt. */
627 goto out;
628 }
629
1e73eb62
JO		 630 if (intr & WL1271_ACX_INTR_DATA) {
631 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
1fd2794f 632
1e73eb62 633 /* check for tx results */
c8bde243 634 if (wl->fw_status->common.tx_results_counter !=
1e73eb62
JO		 635 (wl->tx_results_count & 0xff))
636 wl1271_tx_complete(wl);
f5fc0f86 637
a522550a
IY		 638 /* Check if any tx blocks were freed */
639 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
6742f554 640 wl->tx_queue_count) {
a522550a
IY		 641 /*
642 * In order to avoid starvation of the TX path,
643 * call the work function directly.
644 */
645 wl1271_tx_work_locked(wl);
646 }
647
c8bde243 648 wl1271_rx(wl, &wl->fw_status->common);
1e73eb62 649 }
f5fc0f86 650
1e73eb62
JO		 651 if (intr & WL1271_ACX_INTR_EVENT_A) {
652 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
653 wl1271_event_handle(wl, 0);
654 }
f5fc0f86 655
1e73eb62
JO		 656 if (intr & WL1271_ACX_INTR_EVENT_B) {
657 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
658 wl1271_event_handle(wl, 1);
659 }
f5fc0f86 660
1e73eb62
JO		 661 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
662 wl1271_debug(DEBUG_IRQ,
663 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 664
1e73eb62
JO		 665 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
666 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
667
668 spin_lock_irqsave(&wl->wl_lock, flags);
c15f63bf 669 }
f5fc0f86 670
1e73eb62
JO		 671 if (test_bit(WL1271_FLAG_IRQ_PENDING, &wl->flags))
672 ieee80211_queue_work(wl->hw, &wl->irq_work);
673 else
674 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
675 spin_unlock_irqrestore(&wl->wl_lock, flags);
676
f5fc0f86
LC		 677 wl1271_ps_elp_sleep(wl);
678
679out:
680 mutex_unlock(&wl->mutex);
681}
682
f5fc0f86
LC		 683static int wl1271_fetch_firmware(struct wl1271 *wl)
684{
685 const struct firmware *fw;
166d504e 686 const char *fw_name;
f5fc0f86
LC		 687 int ret;
688
166d504e
AN		 689 switch (wl->bss_type) {
690 case BSS_TYPE_AP_BSS:
691 fw_name = WL1271_AP_FW_NAME;
692 break;
693 case BSS_TYPE_IBSS:
694 case BSS_TYPE_STA_BSS:
695 fw_name = WL1271_FW_NAME;
696 break;
697 default:
698 wl1271_error("no compatible firmware for bss_type %d",
699 wl->bss_type);
700 return -EINVAL;
701 }
702
703 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
704
705 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 706
707 if (ret < 0) {
708 wl1271_error("could not get firmware: %d", ret);
709 return ret;
710 }
711
712 if (fw->size % 4) {
713 wl1271_error("firmware size is not multiple of 32 bits: %zu",
714 fw->size);
715 ret = -EILSEQ;
716 goto out;
717 }
718
166d504e 719 vfree(wl->fw);
f5fc0f86 720 wl->fw_len = fw->size;
1fba4974 721 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 722
723 if (!wl->fw) {
724 wl1271_error("could not allocate memory for the firmware");
725 ret = -ENOMEM;
726 goto out;
727 }
728
729 memcpy(wl->fw, fw->data, wl->fw_len);
166d504e 730 wl->fw_bss_type = wl->bss_type;
f5fc0f86
LC		 731 ret = 0;
732
733out:
734 release_firmware(fw);
735
736 return ret;
737}
738
739static int wl1271_fetch_nvs(struct wl1271 *wl)
740{
741 const struct firmware *fw;
742 int ret;
743
8197b711 744 ret = request_firmware(&fw, WL1271_NVS_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 745
746 if (ret < 0) {
747 wl1271_error("could not get nvs file: %d", ret);
748 return ret;
749 }
750
929ebd30 751 wl->nvs = kmemdup(fw->data, sizeof(struct wl1271_nvs_file), GFP_KERNEL);
f5fc0f86
LC		 752
753 if (!wl->nvs) {
754 wl1271_error("could not allocate memory for the nvs file");
755 ret = -ENOMEM;
756 goto out;
757 }
758
02fabb0e
JO		 759 wl->nvs_len = fw->size;
760
f5fc0f86
LC		 761out:
762 release_firmware(fw);
763
764 return ret;
765}
766
52b0e7a6
JO		 767static void wl1271_recovery_work(struct work_struct *work)
768{
769 struct wl1271 *wl =
770 container_of(work, struct wl1271, recovery_work);
771
772 mutex_lock(&wl->mutex);
773
774 if (wl->state != WL1271_STATE_ON)
775 goto out;
776
777 wl1271_info("Hardware recovery in progress.");
778
d25611da
JO		 779 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
780 ieee80211_connection_loss(wl->vif);
781
52b0e7a6
JO		 782 /* reboot the chipset */
783 __wl1271_op_remove_interface(wl);
784 ieee80211_restart_hw(wl->hw);
785
786out:
787 mutex_unlock(&wl->mutex);
788}
789
f5fc0f86
LC		 790static void wl1271_fw_wakeup(struct wl1271 *wl)
791{
792 u32 elp_reg;
793
794 elp_reg = ELPCTRL_WAKE_UP;
74621417 795 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 796}
797
798static int wl1271_setup(struct wl1271 *wl)
799{
800 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
801 if (!wl->fw_status)
802 return -ENOMEM;
803
804 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
805 if (!wl->tx_res_if) {
806 kfree(wl->fw_status);
807 return -ENOMEM;
808 }
809
f5fc0f86
LC		 810 return 0;
811}
812
813static int wl1271_chip_wakeup(struct wl1271 *wl)
814{
451de97a 815 struct wl1271_partition_set partition;
f5fc0f86
LC		 816 int ret = 0;
817
01ac17ec 818 msleep(WL1271_PRE_POWER_ON_SLEEP);
2cc78ff7
OBC		 819 ret = wl1271_power_on(wl);
820 if (ret < 0)
821 goto out;
f5fc0f86 822 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 823 wl1271_io_reset(wl);
824 wl1271_io_init(wl);
f5fc0f86
LC		 825
826 /* We don't need a real memory partition here, because we only want
827 * to use the registers at this point. */
451de97a
JO		 828 memset(&partition, 0, sizeof(partition));
829 partition.reg.start = REGISTERS_BASE;
830 partition.reg.size = REGISTERS_DOWN_SIZE;
831 wl1271_set_partition(wl, &partition);
f5fc0f86
LC		 832
833 /* ELP module wake up */
834 wl1271_fw_wakeup(wl);
835
836 /* whal_FwCtrl_BootSm() */
837
838 /* 0. read chip id from CHIP_ID */
7b048c52 839 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 840
841 /* 1. check if chip id is valid */
842
843 switch (wl->chip.id) {
844 case CHIP_ID_1271_PG10:
845 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
846 wl->chip.id);
847
848 ret = wl1271_setup(wl);
849 if (ret < 0)
9ccd9217 850 goto out;
f5fc0f86
LC		 851 break;
852 case CHIP_ID_1271_PG20:
853 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
854 wl->chip.id);
855
856 ret = wl1271_setup(wl);
857 if (ret < 0)
9ccd9217 858 goto out;
f5fc0f86
LC		 859 break;
860 default:
9ccd9217 861 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 862 ret = -ENODEV;
9ccd9217 863 goto out;
f5fc0f86
LC		 864 }
865
166d504e
AN		 866 /* Make sure the firmware type matches the BSS type */
867 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
f5fc0f86
LC		 868 ret = wl1271_fetch_firmware(wl);
869 if (ret < 0)
9ccd9217 870 goto out;
f5fc0f86
LC		 871 }
872
873 /* No NVS from netlink, try to get it from the filesystem */
874 if (wl->nvs == NULL) {
875 ret = wl1271_fetch_nvs(wl);
876 if (ret < 0)
9ccd9217 877 goto out;
f5fc0f86
LC		 878 }
879
880out:
881 return ret;
882}
883
f5fc0f86
LC		 884int wl1271_plt_start(struct wl1271 *wl)
885{
9ccd9217 886 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 887 int ret;
888
889 mutex_lock(&wl->mutex);
890
891 wl1271_notice("power up");
892
893 if (wl->state != WL1271_STATE_OFF) {
894 wl1271_error("cannot go into PLT state because not "
895 "in off state: %d", wl->state);
896 ret = -EBUSY;
897 goto out;
898 }
899
166d504e
AN		 900 wl->bss_type = BSS_TYPE_STA_BSS;
901
9ccd9217
JO		 902 while (retries) {
903 retries--;
904 ret = wl1271_chip_wakeup(wl);
905 if (ret < 0)
906 goto power_off;
f5fc0f86 907
9ccd9217
JO		 908 ret = wl1271_boot(wl);
909 if (ret < 0)
910 goto power_off;
eb5b28d0 911
9ccd9217
JO		 912 ret = wl1271_plt_init(wl);
913 if (ret < 0)
914 goto irq_disable;
bd5ea18f 915
9ccd9217
JO		 916 wl->state = WL1271_STATE_PLT;
917 wl1271_notice("firmware booted in PLT mode (%s)",
4b7fac77 918 wl->chip.fw_ver_str);
9ccd9217 919 goto out;
eb5b28d0 920
9ccd9217
JO		 921irq_disable:
922 wl1271_disable_interrupts(wl);
923 mutex_unlock(&wl->mutex);
924 /* Unlocking the mutex in the middle of handling is
925 inherently unsafe. In this case we deem it safe to do,
926 because we need to let any possibly pending IRQ out of
927 the system (and while we are WL1271_STATE_OFF the IRQ
928 work function will not do anything.) Also, any other
929 possible concurrent operations will fail due to the
930 current state, hence the wl1271 struct should be safe. */
931 cancel_work_sync(&wl->irq_work);
932 mutex_lock(&wl->mutex);
933power_off:
934 wl1271_power_off(wl);
935 }
f5fc0f86 936
9ccd9217
JO		 937 wl1271_error("firmware boot in PLT mode failed despite %d retries",
938 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 939out:
940 mutex_unlock(&wl->mutex);
941
942 return ret;
943}
944
4ae3fa87 945int __wl1271_plt_stop(struct wl1271 *wl)
f5fc0f86
LC		 946{
947 int ret = 0;
948
f5fc0f86
LC		 949 wl1271_notice("power down");
950
951 if (wl->state != WL1271_STATE_PLT) {
952 wl1271_error("cannot power down because not in PLT "
953 "state: %d", wl->state);
954 ret = -EBUSY;
955 goto out;
956 }
957
958 wl1271_disable_interrupts(wl);
959 wl1271_power_off(wl);
960
961 wl->state = WL1271_STATE_OFF;
bd5ea18f 962 wl->rx_counter = 0;
f5fc0f86 963
f5fc0f86 964 mutex_unlock(&wl->mutex);
8c7f4f31 965 cancel_work_sync(&wl->irq_work);
52b0e7a6 966 cancel_work_sync(&wl->recovery_work);
4ae3fa87
JO		 967 mutex_lock(&wl->mutex);
968out:
969 return ret;
970}
971
972int wl1271_plt_stop(struct wl1271 *wl)
973{
974 int ret;
8c7f4f31 975
4ae3fa87
JO		 976 mutex_lock(&wl->mutex);
977 ret = __wl1271_plt_stop(wl);
978 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 979 return ret;
980}
981
f5fc0f86
LC		 982static int wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
983{
984 struct wl1271 *wl = hw->priv;
830fb67b 985 unsigned long flags;
6742f554 986 int q;
f5fc0f86 987
830fb67b 988 spin_lock_irqsave(&wl->wl_lock, flags);
6742f554 989 wl->tx_queue_count++;
830fb67b
JO		 990 spin_unlock_irqrestore(&wl->wl_lock, flags);
991
992 /* queue the packet */
6742f554
JO		 993 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
994 skb_queue_tail(&wl->tx_queue[q], skb);
f5fc0f86
LC		 995
996 /*
997 * The chip specific setup must run before the first TX packet -
998 * before that, the tx_work will not be initialized!
999 */
1000
a522550a
IY		 1001 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1002 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86
LC		 1003
1004 /*
1005 * The workqueue is slow to process the tx_queue and we need stop
1006 * the queue here, otherwise the queue will get too long.
1007 */
6742f554 1008 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
06f7bc7d 1009 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
f5fc0f86 1010
06f7bc7d
JO		 1011 spin_lock_irqsave(&wl->wl_lock, flags);
1012 ieee80211_stop_queues(wl->hw);
71449f8d 1013 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
06f7bc7d 1014 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 1015 }
1016
1017 return NETDEV_TX_OK;
1018}
1019
c2c192ac
JO		 1020static struct notifier_block wl1271_dev_notifier = {
1021 .notifier_call = wl1271_dev_notify,
1022};
1023
f5fc0f86 1024static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1025{
1026 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1027
1028 /*
1029 * We have to delay the booting of the hardware because
1030 * we need to know the local MAC address before downloading and
1031 * initializing the firmware. The MAC address cannot be changed
1032 * after boot, and without the proper MAC address, the firmware
1033 * will not function properly.
1034 *
1035 * The MAC address is first known when the corresponding interface
1036 * is added. That is where we will initialize the hardware.
166d504e
AN		 1037 *
1038 * In addition, we currently have different firmwares for AP and managed
1039 * operation. We will know which to boot according to interface type.
1b72aecd
JO		 1040 */
1041
1042 return 0;
1043}
1044
1045static void wl1271_op_stop(struct ieee80211_hw *hw)
1046{
1047 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1048}
1049
1050static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1051 struct ieee80211_vif *vif)
f5fc0f86
LC		 1052{
1053 struct wl1271 *wl = hw->priv;
ac01e948 1054 struct wiphy *wiphy = hw->wiphy;
9ccd9217 1055 int retries = WL1271_BOOT_RETRIES;
f5fc0f86 1056 int ret = 0;
71125abd 1057 bool booted = false;
f5fc0f86 1058
1b72aecd
JO		 1059 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1060 vif->type, vif->addr);
f5fc0f86
LC		 1061
1062 mutex_lock(&wl->mutex);
1b72aecd 1063 if (wl->vif) {
71125abd
EP		 1064 wl1271_debug(DEBUG_MAC80211,
1065 "multiple vifs are not supported yet");
1b72aecd
JO		 1066 ret = -EBUSY;
1067 goto out;
1068 }
1069
1b72aecd
JO		 1070 switch (vif->type) {
1071 case NL80211_IFTYPE_STATION:
1072 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 1073 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 1074 break;
1075 case NL80211_IFTYPE_ADHOC:
1076 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 1077 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd 1078 break;
038d925b
AN		 1079 case NL80211_IFTYPE_AP:
1080 wl->bss_type = BSS_TYPE_AP_BSS;
1081 break;
1b72aecd
JO		 1082 default:
1083 ret = -EOPNOTSUPP;
1084 goto out;
1085 }
1086
1087 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 1088
1089 if (wl->state != WL1271_STATE_OFF) {
1090 wl1271_error("cannot start because not in off state: %d",
1091 wl->state);
1092 ret = -EBUSY;
1093 goto out;
1094 }
1095
9ccd9217
JO		 1096 while (retries) {
1097 retries--;
1098 ret = wl1271_chip_wakeup(wl);
1099 if (ret < 0)
1100 goto power_off;
f5fc0f86 1101
9ccd9217
JO		 1102 ret = wl1271_boot(wl);
1103 if (ret < 0)
1104 goto power_off;
f5fc0f86 1105
9ccd9217
JO		 1106 ret = wl1271_hw_init(wl);
1107 if (ret < 0)
1108 goto irq_disable;
f5fc0f86 1109
71125abd
EP		 1110 booted = true;
1111 break;
eb5b28d0 1112
9ccd9217
JO		 1113irq_disable:
1114 wl1271_disable_interrupts(wl);
1115 mutex_unlock(&wl->mutex);
1116 /* Unlocking the mutex in the middle of handling is
1117 inherently unsafe. In this case we deem it safe to do,
1118 because we need to let any possibly pending IRQ out of
1119 the system (and while we are WL1271_STATE_OFF the IRQ
1120 work function will not do anything.) Also, any other
1121 possible concurrent operations will fail due to the
1122 current state, hence the wl1271 struct should be safe. */
1123 cancel_work_sync(&wl->irq_work);
1124 mutex_lock(&wl->mutex);
1125power_off:
1126 wl1271_power_off(wl);
1127 }
eb5b28d0 1128
71125abd
EP		 1129 if (!booted) {
1130 wl1271_error("firmware boot failed despite %d retries",
1131 WL1271_BOOT_RETRIES);
1132 goto out;
1133 }
1134
1135 wl->vif = vif;
1136 wl->state = WL1271_STATE_ON;
4b7fac77 1137 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 1138
1139 /* update hw/fw version info in wiphy struct */
1140 wiphy->hw_version = wl->chip.id;
4b7fac77 1141 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 1142 sizeof(wiphy->fw_version));
1143
fb6a6819
LC		 1144 /*
1145 * Now we know if 11a is supported (info from the NVS), so disable
1146 * 11a channels if not supported
1147 */
1148 if (!wl->enable_11a)
1149 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1150
1151 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1152 wl->enable_11a ? "" : "not ");
1153
eb5b28d0 1154out:
f5fc0f86
LC		 1155 mutex_unlock(&wl->mutex);
1156
eb887dfd 1157 if (!ret)
01c09162 1158 list_add(&wl->list, &wl_list);
01c09162 1159
f5fc0f86
LC		 1160 return ret;
1161}
1162
52a2a375 1163static void __wl1271_op_remove_interface(struct wl1271 *wl)
f5fc0f86 1164{
f5fc0f86
LC		 1165 int i;
1166
1b72aecd 1167 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 1168
1b72aecd 1169 wl1271_info("down");
f5fc0f86 1170
01c09162
JO		 1171 list_del(&wl->list);
1172
f5fc0f86
LC		 1173 WARN_ON(wl->state != WL1271_STATE_ON);
1174
8d2ef7bd 1175 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 1176 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 1177 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1178
08688d6b 1179 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b
LC		 1180 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1181 kfree(wl->scan.scanned_ch);
1182 wl->scan.scanned_ch = NULL;
b739a42c 1183 wl->scan.req = NULL;
76a029fb 1184 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 1185 }
1186
1187 wl->state = WL1271_STATE_OFF;
1188
1189 wl1271_disable_interrupts(wl);
1190
1191 mutex_unlock(&wl->mutex);
1192
78abd320 1193 cancel_delayed_work_sync(&wl->scan_complete_work);
f5fc0f86
LC		 1194 cancel_work_sync(&wl->irq_work);
1195 cancel_work_sync(&wl->tx_work);
90494a90 1196 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1197 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1198
1199 mutex_lock(&wl->mutex);
1200
1201 /* let's notify MAC80211 about the remaining pending TX frames */
781608c4 1202 wl1271_tx_reset(wl);
f5fc0f86
LC		 1203 wl1271_power_off(wl);
1204
1205 memset(wl->bssid, 0, ETH_ALEN);
1206 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1207 wl->ssid_len = 0;
f5fc0f86 1208 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 1209 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 1210 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1211
1212 wl->rx_counter = 0;
19ad0715 1213 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1214 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1215 wl->tx_blocks_available = 0;
1216 wl->tx_results_count = 0;
1217 wl->tx_packets_count = 0;
ac4e4ce5 1218 wl->tx_security_last_seq = 0;
04e36fc5 1219 wl->tx_security_seq = 0;
f5fc0f86
LC		 1220 wl->time_offset = 0;
1221 wl->session_counter = 0;
830fb67b 1222 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
830fb67b 1223 wl->flags = 0;
1b72aecd 1224 wl->vif = NULL;
14b228a0 1225 wl->filters = 0;
7f179b46 1226 wl1271_free_ap_keys(wl);
f84f7d78 1227 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
d6e19d13 1228
f5fc0f86
LC		 1229 for (i = 0; i < NUM_TX_QUEUES; i++)
1230 wl->tx_blocks_freed[i] = 0;
1231
1232 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1233
1234 kfree(wl->fw_status);
1235 wl->fw_status = NULL;
1236 kfree(wl->tx_res_if);
1237 wl->tx_res_if = NULL;
1238 kfree(wl->target_mem_map);
1239 wl->target_mem_map = NULL;
52a2a375 1240}
bd9dc49c 1241
52a2a375
JO		 1242static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1243 struct ieee80211_vif *vif)
1244{
1245 struct wl1271 *wl = hw->priv;
1246
1247 mutex_lock(&wl->mutex);
67353299
JO		 1248 /*
1249 * wl->vif can be null here if someone shuts down the interface
1250 * just when hardware recovery has been started.
1251 */
1252 if (wl->vif) {
1253 WARN_ON(wl->vif != vif);
1254 __wl1271_op_remove_interface(wl);
1255 }
52b0e7a6 1256
67353299 1257 mutex_unlock(&wl->mutex);
52b0e7a6 1258 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1259}
1260
14b228a0
JO		 1261static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1262{
ae113b57 1263 wl1271_set_default_filters(wl);
14b228a0
JO		 1264
1265 /* combine requested filters with current filter config */
1266 filters = wl->filters | filters;
1267
1268 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1269
1270 if (filters & FIF_PROMISC_IN_BSS) {
1271 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1272 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1273 wl->rx_config |= CFG_BSSID_FILTER_EN;
1274 }
1275 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1276 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1277 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1278 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1279 }
1280 if (filters & FIF_OTHER_BSS) {
1281 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1282 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1283 }
1284 if (filters & FIF_CONTROL) {
1285 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1286 wl->rx_filter |= CFG_RX_CTL_EN;
1287 }
1288 if (filters & FIF_FCSFAIL) {
1289 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1290 wl->rx_filter |= CFG_RX_FCS_ERROR;
1291 }
1292}
1293
82429d32 1294static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1295{
e0d8bbf0 1296 int ret = 0;
c7f43e45
LC		 1297 /* we need to use a dummy BSSID for now */
1298 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1299 0xad, 0xbe, 0xef };
1300
c7f43e45
LC		 1301 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1302
14b228a0
JO		 1303 /* pass through frames from all BSS */
1304 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1305
5da11dcd 1306 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1307 if (ret < 0)
1308 goto out;
1309
71449f8d 1310 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1311
1312out:
1313 return ret;
1314}
1315
69e5434c 1316static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1317{
1318 int ret;
1319
69e5434c
JO		 1320 /*
1321 * One of the side effects of the JOIN command is that is clears
1322 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1323 * to a WPA/WPA2 access point will therefore kill the data-path.
1324 * Currently there is no supported scenario for JOIN during
1325 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1326 * must be handled somehow.
1327 *
1328 */
1329 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1330 wl1271_info("JOIN while associated.");
1331
1332 if (set_assoc)
1333 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1334
82429d32
JO		 1335 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1336 if (ret < 0)
1337 goto out;
1338
1339 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1340
1341 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1342 goto out;
1343
1344 /*
1345 * The join command disable the keep-alive mode, shut down its process,
1346 * and also clear the template config, so we need to reset it all after
1347 * the join. The acx_aid starts the keep-alive process, and the order
1348 * of the commands below is relevant.
1349 */
1350 ret = wl1271_acx_keep_alive_mode(wl, true);
1351 if (ret < 0)
1352 goto out;
1353
1354 ret = wl1271_acx_aid(wl, wl->aid);
1355 if (ret < 0)
1356 goto out;
1357
1358 ret = wl1271_cmd_build_klv_null_data(wl);
1359 if (ret < 0)
1360 goto out;
1361
1362 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1363 ACX_KEEP_ALIVE_TPL_VALID);
1364 if (ret < 0)
1365 goto out;
1366
1367out:
1368 return ret;
1369}
1370
1371static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1372{
1373 int ret;
1374
1375 /* to stop listening to a channel, we disconnect */
1376 ret = wl1271_cmd_disconnect(wl);
1377 if (ret < 0)
1378 goto out;
1379
71449f8d 1380 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1381 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1382
1383 /* stop filterting packets based on bssid */
1384 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1385
1386out:
1387 return ret;
1388}
1389
ebba60c6
JO		 1390static void wl1271_set_band_rate(struct wl1271 *wl)
1391{
1392 if (wl->band == IEEE80211_BAND_2GHZ)
1393 wl->basic_rate_set = wl->conf.tx.basic_rate;
1394 else
1395 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1396}
1397
bee0ffec 1398static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 1399{
1400 int ret;
1401
1402 if (idle) {
1403 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1404 ret = wl1271_unjoin(wl);
1405 if (ret < 0)
1406 goto out;
1407 }
e0fe371b 1408 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 1409 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 1410 if (ret < 0)
1411 goto out;
1412 ret = wl1271_acx_keep_alive_config(
1413 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1414 ACX_KEEP_ALIVE_TPL_INVALID);
1415 if (ret < 0)
1416 goto out;
1417 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1418 } else {
1419 /* increment the session counter */
1420 wl->session_counter++;
1421 if (wl->session_counter >= SESSION_COUNTER_MAX)
1422 wl->session_counter = 0;
1423 ret = wl1271_dummy_join(wl);
1424 if (ret < 0)
1425 goto out;
1426 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1427 }
1428
1429out:
1430 return ret;
1431}
1432
f5fc0f86
LC		 1433static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1434{
1435 struct wl1271 *wl = hw->priv;
1436 struct ieee80211_conf *conf = &hw->conf;
1437 int channel, ret = 0;
bee0ffec 1438 bool is_ap;
f5fc0f86
LC		 1439
1440 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1441
bee0ffec
AN		 1442 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1443 " changed 0x%x",
f5fc0f86
LC		 1444 channel,
1445 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 1446 conf->power_level,
bee0ffec
AN		 1447 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1448 changed);
f5fc0f86 1449
781608c4
JO		 1450 /*
1451 * mac80211 will go to idle nearly immediately after transmitting some
1452 * frames, such as the deauth. To make sure those frames reach the air,
1453 * wait here until the TX queue is fully flushed.
1454 */
1455 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1456 (conf->flags & IEEE80211_CONF_IDLE))
1457 wl1271_tx_flush(wl);
1458
f5fc0f86
LC		 1459 mutex_lock(&wl->mutex);
1460
f8d9802f
JO		 1461 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1462 ret = -EAGAIN;
2c10bb9c 1463 goto out;
f8d9802f 1464 }
8a5a37a6 1465
bee0ffec
AN		 1466 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1467
f5fc0f86
LC		 1468 ret = wl1271_ps_elp_wakeup(wl, false);
1469 if (ret < 0)
1470 goto out;
1471
ebba60c6 1472 /* if the channel changes while joined, join again */
69e5434c
JO		 1473 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1474 ((wl->band != conf->channel->band) ||
1475 (wl->channel != channel))) {
ebba60c6
JO		 1476 wl->band = conf->channel->band;
1477 wl->channel = channel;
1478
bee0ffec
AN		 1479 if (!is_ap) {
1480 /*
1481 * FIXME: the mac80211 should really provide a fixed
1482 * rate to use here. for now, just use the smallest
1483 * possible rate for the band as a fixed rate for
1484 * association frames and other control messages.
1485 */
1486 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1487 wl1271_set_band_rate(wl);
1488
1489 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1490 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 1491 if (ret < 0)
bee0ffec 1492 wl1271_warning("rate policy for channel "
ebba60c6 1493 "failed %d", ret);
bee0ffec
AN		 1494
1495 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1496 ret = wl1271_join(wl, false);
1497 if (ret < 0)
1498 wl1271_warning("cmd join on channel "
1499 "failed %d", ret);
1500 }
ebba60c6
JO		 1501 }
1502 }
1503
bee0ffec
AN		 1504 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1505 ret = wl1271_sta_handle_idle(wl,
1506 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 1507 if (ret < 0)
1508 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1509 }
1510
90494a90
JO		 1511 /*
1512 * if mac80211 changes the PSM mode, make sure the mode is not
1513 * incorrectly changed after the pspoll failure active window.
1514 */
1515 if (changed & IEEE80211_CONF_CHANGE_PS)
1516 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1517
71449f8d
JO		 1518 if (conf->flags & IEEE80211_CONF_PS &&
1519 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1520 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1521
1522 /*
1523 * We enter PSM only if we're already associated.
1524 * If we're not, we'll enter it when joining an SSID,
1525 * through the bss_info_changed() hook.
1526 */
830fb67b 1527 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1528 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1529 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 1530 wl->basic_rate, true);
af5e084b 1531 }
f5fc0f86 1532 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1533 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1534 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1535
71449f8d 1536 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1537
71449f8d 1538 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1539 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 1540 wl->basic_rate, true);
f5fc0f86
LC		 1541 }
1542
1543 if (conf->power_level != wl->power_level) {
1544 ret = wl1271_acx_tx_power(wl, conf->power_level);
1545 if (ret < 0)
c6317a54 1546 goto out_sleep;
f5fc0f86
LC		 1547
1548 wl->power_level = conf->power_level;
1549 }
1550
1551out_sleep:
1552 wl1271_ps_elp_sleep(wl);
1553
1554out:
1555 mutex_unlock(&wl->mutex);
1556
1557 return ret;
1558}
1559
b54853f1
JO		 1560struct wl1271_filter_params {
1561 bool enabled;
1562 int mc_list_length;
1563 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1564};
1565
22bedad3
JP		 1566static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1567 struct netdev_hw_addr_list *mc_list)
c87dec9f 1568{
c87dec9f 1569 struct wl1271_filter_params *fp;
22bedad3 1570 struct netdev_hw_addr *ha;
2c10bb9c 1571 struct wl1271 *wl = hw->priv;
c87dec9f 1572
2c10bb9c
SD		 1573 if (unlikely(wl->state == WL1271_STATE_OFF))
1574 return 0;
c87dec9f 1575
74441130 1576 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1577 if (!fp) {
1578 wl1271_error("Out of memory setting filters.");
1579 return 0;
1580 }
1581
1582 /* update multicast filtering parameters */
c87dec9f 1583 fp->mc_list_length = 0;
22bedad3
JP		 1584 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1585 fp->enabled = false;
1586 } else {
1587 fp->enabled = true;
1588 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1589 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1590 ha->addr, ETH_ALEN);
c87dec9f 1591 fp->mc_list_length++;
22bedad3 1592 }
c87dec9f
JO		 1593 }
1594
b54853f1 1595 return (u64)(unsigned long)fp;
c87dec9f 1596}
f5fc0f86 1597
b54853f1
JO		 1598#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1599 FIF_ALLMULTI | \
1600 FIF_FCSFAIL | \
1601 FIF_BCN_PRBRESP_PROMISC | \
1602 FIF_CONTROL | \
1603 FIF_OTHER_BSS)
1604
f5fc0f86
LC		 1605static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1606 unsigned int changed,
c87dec9f 1607 unsigned int *total, u64 multicast)
f5fc0f86 1608{
b54853f1 1609 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1610 struct wl1271 *wl = hw->priv;
b54853f1 1611 int ret;
f5fc0f86 1612
7d057869
AN		 1613 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1614 " total %x", changed, *total);
f5fc0f86 1615
b54853f1
JO		 1616 mutex_lock(&wl->mutex);
1617
2c10bb9c
SD		 1618 *total &= WL1271_SUPPORTED_FILTERS;
1619 changed &= WL1271_SUPPORTED_FILTERS;
1620
1621 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1622 goto out;
1623
1624 ret = wl1271_ps_elp_wakeup(wl, false);
1625 if (ret < 0)
1626 goto out;
1627
7d057869
AN		 1628 if (wl->bss_type != BSS_TYPE_AP_BSS) {
1629 if (*total & FIF_ALLMULTI)
1630 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1631 else if (fp)
1632 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1633 fp->mc_list,
1634 fp->mc_list_length);
1635 if (ret < 0)
1636 goto out_sleep;
1637 }
f5fc0f86 1638
b54853f1
JO		 1639 /* determine, whether supported filter values have changed */
1640 if (changed == 0)
1641 goto out_sleep;
c87dec9f 1642
14b228a0
JO		 1643 /* configure filters */
1644 wl->filters = *total;
1645 wl1271_configure_filters(wl, 0);
1646
b54853f1
JO		 1647 /* apply configured filters */
1648 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1649 if (ret < 0)
1650 goto out_sleep;
1651
1652out_sleep:
1653 wl1271_ps_elp_sleep(wl);
1654
1655out:
1656 mutex_unlock(&wl->mutex);
14b228a0 1657 kfree(fp);
f5fc0f86
LC		 1658}
1659
7f179b46
AN		 1660static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1661 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1662 u16 tx_seq_16)
1663{
1664 struct wl1271_ap_key *ap_key;
1665 int i;
1666
1667 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1668
1669 if (key_size > MAX_KEY_SIZE)
1670 return -EINVAL;
1671
1672 /*
1673 * Find next free entry in ap_keys. Also check we are not replacing
1674 * an existing key.
1675 */
1676 for (i = 0; i < MAX_NUM_KEYS; i++) {
1677 if (wl->recorded_ap_keys[i] == NULL)
1678 break;
1679
1680 if (wl->recorded_ap_keys[i]->id == id) {
1681 wl1271_warning("trying to record key replacement");
1682 return -EINVAL;
1683 }
1684 }
1685
1686 if (i == MAX_NUM_KEYS)
1687 return -EBUSY;
1688
1689 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1690 if (!ap_key)
1691 return -ENOMEM;
1692
1693 ap_key->id = id;
1694 ap_key->key_type = key_type;
1695 ap_key->key_size = key_size;
1696 memcpy(ap_key->key, key, key_size);
1697 ap_key->hlid = hlid;
1698 ap_key->tx_seq_32 = tx_seq_32;
1699 ap_key->tx_seq_16 = tx_seq_16;
1700
1701 wl->recorded_ap_keys[i] = ap_key;
1702 return 0;
1703}
1704
1705static void wl1271_free_ap_keys(struct wl1271 *wl)
1706{
1707 int i;
1708
1709 for (i = 0; i < MAX_NUM_KEYS; i++) {
1710 kfree(wl->recorded_ap_keys[i]);
1711 wl->recorded_ap_keys[i] = NULL;
1712 }
1713}
1714
1715static int wl1271_ap_init_hwenc(struct wl1271 *wl)
1716{
1717 int i, ret = 0;
1718 struct wl1271_ap_key *key;
1719 bool wep_key_added = false;
1720
1721 for (i = 0; i < MAX_NUM_KEYS; i++) {
1722 if (wl->recorded_ap_keys[i] == NULL)
1723 break;
1724
1725 key = wl->recorded_ap_keys[i];
1726 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
1727 key->id, key->key_type,
1728 key->key_size, key->key,
1729 key->hlid, key->tx_seq_32,
1730 key->tx_seq_16);
1731 if (ret < 0)
1732 goto out;
1733
1734 if (key->key_type == KEY_WEP)
1735 wep_key_added = true;
1736 }
1737
1738 if (wep_key_added) {
1739 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
1740 if (ret < 0)
1741 goto out;
1742 }
1743
1744out:
1745 wl1271_free_ap_keys(wl);
1746 return ret;
1747}
1748
1749static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
1750 u8 key_size, const u8 *key, u32 tx_seq_32,
1751 u16 tx_seq_16, struct ieee80211_sta *sta)
1752{
1753 int ret;
1754 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1755
1756 if (is_ap) {
1757 struct wl1271_station *wl_sta;
1758 u8 hlid;
1759
1760 if (sta) {
1761 wl_sta = (struct wl1271_station *)sta->drv_priv;
1762 hlid = wl_sta->hlid;
1763 } else {
1764 hlid = WL1271_AP_BROADCAST_HLID;
1765 }
1766
1767 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
1768 /*
1769 * We do not support removing keys after AP shutdown.
1770 * Pretend we do to make mac80211 happy.
1771 */
1772 if (action != KEY_ADD_OR_REPLACE)
1773 return 0;
1774
1775 ret = wl1271_record_ap_key(wl, id,
1776 key_type, key_size,
1777 key, hlid, tx_seq_32,
1778 tx_seq_16);
1779 } else {
1780 ret = wl1271_cmd_set_ap_key(wl, action,
1781 id, key_type, key_size,
1782 key, hlid, tx_seq_32,
1783 tx_seq_16);
1784 }
1785
1786 if (ret < 0)
1787 return ret;
1788 } else {
1789 const u8 *addr;
1790 static const u8 bcast_addr[ETH_ALEN] = {
1791 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1792 };
1793
1794 addr = sta ? sta->addr : bcast_addr;
1795
1796 if (is_zero_ether_addr(addr)) {
1797 /* We dont support TX only encryption */
1798 return -EOPNOTSUPP;
1799 }
1800
1801 /* The wl1271 does not allow to remove unicast keys - they
1802 will be cleared automatically on next CMD_JOIN. Ignore the
1803 request silently, as we dont want the mac80211 to emit
1804 an error message. */
1805 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
1806 return 0;
1807
1808 ret = wl1271_cmd_set_sta_key(wl, action,
1809 id, key_type, key_size,
1810 key, addr, tx_seq_32,
1811 tx_seq_16);
1812 if (ret < 0)
1813 return ret;
1814
1815 /* the default WEP key needs to be configured at least once */
1816 if (key_type == KEY_WEP) {
1817 ret = wl1271_cmd_set_sta_default_wep_key(wl,
1818 wl->default_key);
1819 if (ret < 0)
1820 return ret;
1821 }
1822 }
1823
1824 return 0;
1825}
1826
f5fc0f86
LC		 1827static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1828 struct ieee80211_vif *vif,
1829 struct ieee80211_sta *sta,
1830 struct ieee80211_key_conf *key_conf)
1831{
1832 struct wl1271 *wl = hw->priv;
f5fc0f86 1833 int ret;
ac4e4ce5
JO		 1834 u32 tx_seq_32 = 0;
1835 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1836 u8 key_type;
1837
f5fc0f86
LC		 1838 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1839
7f179b46 1840 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 1841 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 1842 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 1843 key_conf->keylen, key_conf->flags);
1844 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1845
f5fc0f86
LC		 1846 mutex_lock(&wl->mutex);
1847
f8d9802f
JO		 1848 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1849 ret = -EAGAIN;
1850 goto out_unlock;
1851 }
1852
f5fc0f86
LC		 1853 ret = wl1271_ps_elp_wakeup(wl, false);
1854 if (ret < 0)
1855 goto out_unlock;
1856
97359d12
JB		 1857 switch (key_conf->cipher) {
1858 case WLAN_CIPHER_SUITE_WEP40:
1859 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 1860 key_type = KEY_WEP;
1861
1862 key_conf->hw_key_idx = key_conf->keyidx;
1863 break;
97359d12 1864 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 1865 key_type = KEY_TKIP;
1866
1867 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1868 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1869 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1870 break;
97359d12 1871 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 1872 key_type = KEY_AES;
1873
1874 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1875 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1876 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1877 break;
7a55724e
JO		 1878 case WL1271_CIPHER_SUITE_GEM:
1879 key_type = KEY_GEM;
1880 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1881 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1882 break;
f5fc0f86 1883 default:
97359d12 1884 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 1885
1886 ret = -EOPNOTSUPP;
1887 goto out_sleep;
1888 }
1889
1890 switch (cmd) {
1891 case SET_KEY:
7f179b46
AN		 1892 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
1893 key_conf->keyidx, key_type,
1894 key_conf->keylen, key_conf->key,
1895 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 1896 if (ret < 0) {
1897 wl1271_error("Could not add or replace key");
1898 goto out_sleep;
1899 }
1900 break;
1901
1902 case DISABLE_KEY:
7f179b46
AN		 1903 ret = wl1271_set_key(wl, KEY_REMOVE,
1904 key_conf->keyidx, key_type,
1905 key_conf->keylen, key_conf->key,
1906 0, 0, sta);
f5fc0f86
LC		 1907 if (ret < 0) {
1908 wl1271_error("Could not remove key");
1909 goto out_sleep;
1910 }
1911 break;
1912
1913 default:
1914 wl1271_error("Unsupported key cmd 0x%x", cmd);
1915 ret = -EOPNOTSUPP;
f5fc0f86
LC		 1916 break;
1917 }
1918
1919out_sleep:
1920 wl1271_ps_elp_sleep(wl);
1921
1922out_unlock:
1923 mutex_unlock(&wl->mutex);
1924
f5fc0f86
LC		 1925 return ret;
1926}
1927
1928static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1929 struct ieee80211_vif *vif,
f5fc0f86
LC		 1930 struct cfg80211_scan_request *req)
1931{
1932 struct wl1271 *wl = hw->priv;
1933 int ret;
1934 u8 *ssid = NULL;
abb0b3bf 1935 size_t len = 0;
f5fc0f86
LC		 1936
1937 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1938
1939 if (req->n_ssids) {
1940 ssid = req->ssids[0].ssid;
abb0b3bf 1941 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1942 }
1943
1944 mutex_lock(&wl->mutex);
1945
b739a42c
JO		 1946 if (wl->state == WL1271_STATE_OFF) {
1947 /*
1948 * We cannot return -EBUSY here because cfg80211 will expect
1949 * a call to ieee80211_scan_completed if we do - in this case
1950 * there won't be any call.
1951 */
1952 ret = -EAGAIN;
1953 goto out;
1954 }
1955
f5fc0f86
LC		 1956 ret = wl1271_ps_elp_wakeup(wl, false);
1957 if (ret < 0)
1958 goto out;
1959
5924f89d 1960 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 1961
1962 wl1271_ps_elp_sleep(wl);
1963
1964out:
1965 mutex_unlock(&wl->mutex);
1966
1967 return ret;
1968}
1969
68d069c4
AN		 1970static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1971{
1972 struct wl1271 *wl = hw->priv;
1973 int ret = 0;
1974
1975 mutex_lock(&wl->mutex);
1976
1977 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1978 ret = -EAGAIN;
1979 goto out;
1980 }
1981
1982 ret = wl1271_ps_elp_wakeup(wl, false);
1983 if (ret < 0)
1984 goto out;
1985
1986 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1987 if (ret < 0)
1988 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1989
1990 wl1271_ps_elp_sleep(wl);
1991
1992out:
1993 mutex_unlock(&wl->mutex);
1994
1995 return ret;
1996}
1997
f5fc0f86
LC		 1998static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1999{
2000 struct wl1271 *wl = hw->priv;
aecb0565 2001 int ret = 0;
f5fc0f86
LC		 2002
2003 mutex_lock(&wl->mutex);
2004
f8d9802f
JO		 2005 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2006 ret = -EAGAIN;
aecb0565 2007 goto out;
f8d9802f 2008 }
aecb0565 2009
f5fc0f86
LC		 2010 ret = wl1271_ps_elp_wakeup(wl, false);
2011 if (ret < 0)
2012 goto out;
2013
2014 ret = wl1271_acx_rts_threshold(wl, (u16) value);
2015 if (ret < 0)
2016 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2017
2018 wl1271_ps_elp_sleep(wl);
2019
2020out:
2021 mutex_unlock(&wl->mutex);
2022
2023 return ret;
2024}
2025
e78a287a 2026static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2027 int offset)
30240fc7 2028{
2f6724b2 2029 u8 *ptr = skb->data + offset;
30240fc7
JO		 2030
2031 /* find the location of the ssid in the beacon */
2f6724b2 2032 while (ptr < skb->data + skb->len) {
30240fc7
JO		 2033 if (ptr[0] == WLAN_EID_SSID) {
2034 wl->ssid_len = ptr[1];
2035 memcpy(wl->ssid, ptr+2, wl->ssid_len);
e78a287a 2036 return 0;
30240fc7 2037 }
2f6724b2 2038 ptr += (ptr[1] + 2);
30240fc7 2039 }
e78a287a 2040
2f6724b2 2041 wl1271_error("No SSID in IEs!\n");
e78a287a 2042 return -ENOENT;
30240fc7
JO		 2043}
2044
e78a287a 2045static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2046 struct ieee80211_bss_conf *bss_conf,
2047 u32 changed)
2048{
e78a287a 2049 int ret = 0;
f5fc0f86 2050
e78a287a
AN		 2051 if (changed & BSS_CHANGED_ERP_SLOT) {
2052 if (bss_conf->use_short_slot)
2053 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2054 else
2055 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2056 if (ret < 0) {
2057 wl1271_warning("Set slot time failed %d", ret);
2058 goto out;
2059 }
2060 }
f5fc0f86 2061
e78a287a
AN		 2062 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2063 if (bss_conf->use_short_preamble)
2064 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2065 else
2066 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2067 }
f5fc0f86 2068
e78a287a
AN		 2069 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2070 if (bss_conf->use_cts_prot)
2071 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2072 else
2073 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2074 if (ret < 0) {
2075 wl1271_warning("Set ctsprotect failed %d", ret);
2076 goto out;
2077 }
2078 }
f8d9802f 2079
e78a287a
AN		 2080out:
2081 return ret;
2082}
f5fc0f86 2083
e78a287a
AN		 2084static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2085 struct ieee80211_vif *vif,
2086 struct ieee80211_bss_conf *bss_conf,
2087 u32 changed)
2088{
2089 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2090 int ret = 0;
2091
2092 if ((changed & BSS_CHANGED_BEACON_INT)) {
2093 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 2094 bss_conf->beacon_int);
2095
2096 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 2097 }
2098
e78a287a
AN		 2099 if ((changed & BSS_CHANGED_BEACON)) {
2100 struct ieee80211_hdr *hdr;
2101 int ieoffset = offsetof(struct ieee80211_mgmt,
2102 u.beacon.variable);
2103 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2104 u16 tmpl_id;
2105
2106 if (!beacon)
2107 goto out;
2108
2109 wl1271_debug(DEBUG_MASTER, "beacon updated");
2110
2111 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2112 if (ret < 0) {
2113 dev_kfree_skb(beacon);
2114 goto out;
2115 }
2116 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2117 CMD_TEMPL_BEACON;
2118 ret = wl1271_cmd_template_set(wl, tmpl_id,
2119 beacon->data,
2120 beacon->len, 0,
2121 wl1271_tx_min_rate_get(wl));
2122 if (ret < 0) {
2123 dev_kfree_skb(beacon);
2124 goto out;
2125 }
2126
2127 hdr = (struct ieee80211_hdr *) beacon->data;
2128 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2129 IEEE80211_STYPE_PROBE_RESP);
2130
2131 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2132 CMD_TEMPL_PROBE_RESPONSE;
2133 ret = wl1271_cmd_template_set(wl,
2134 tmpl_id,
2135 beacon->data,
2136 beacon->len, 0,
2137 wl1271_tx_min_rate_get(wl));
2138 dev_kfree_skb(beacon);
2139 if (ret < 0)
2140 goto out;
2141 }
2142
2143out:
2144 return ret;
2145}
2146
2147/* AP mode changes */
2148static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2149 struct ieee80211_vif *vif,
2150 struct ieee80211_bss_conf *bss_conf,
2151 u32 changed)
2152{
2153 int ret = 0;
e0d8bbf0 2154
e78a287a
AN		 2155 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2156 u32 rates = bss_conf->basic_rates;
2157 struct conf_tx_rate_class mgmt_rc;
5da11dcd 2158
e78a287a
AN		 2159 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2160 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2161 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2162 wl->basic_rate_set);
2163
2164 /* update the AP management rate policy with the new rates */
2165 mgmt_rc.enabled_rates = wl->basic_rate_set;
2166 mgmt_rc.long_retry_limit = 10;
2167 mgmt_rc.short_retry_limit = 10;
2168 mgmt_rc.aflags = 0;
2169 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2170 ACX_TX_AP_MODE_MGMT_RATE);
2171 if (ret < 0) {
2172 wl1271_error("AP mgmt policy change failed %d", ret);
2173 goto out;
2174 }
2175 }
2f6724b2 2176
e78a287a
AN		 2177 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2178 if (ret < 0)
2179 goto out;
30240fc7 2180
e78a287a
AN		 2181 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2182 if (bss_conf->enable_beacon) {
2183 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2184 ret = wl1271_cmd_start_bss(wl);
2185 if (ret < 0)
2186 goto out;
e0d8bbf0 2187
e78a287a
AN		 2188 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2189 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 2190
2191 ret = wl1271_ap_init_hwenc(wl);
2192 if (ret < 0)
2193 goto out;
e0d8bbf0 2194 }
e78a287a
AN		 2195 } else {
2196 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2197 ret = wl1271_cmd_stop_bss(wl);
2198 if (ret < 0)
2199 goto out;
e0d8bbf0 2200
e78a287a
AN		 2201 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2202 wl1271_debug(DEBUG_AP, "stopped AP");
2203 }
2204 }
2205 }
e0d8bbf0 2206
e78a287a
AN		 2207 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2208 if (ret < 0)
2209 goto out;
2210out:
2211 return;
2212}
8bf29b0e 2213
e78a287a
AN		 2214/* STA/IBSS mode changes */
2215static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2216 struct ieee80211_vif *vif,
2217 struct ieee80211_bss_conf *bss_conf,
2218 u32 changed)
2219{
2220 bool do_join = false, set_assoc = false;
2221 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 2222 u32 sta_rate_set = 0;
e78a287a 2223 int ret;
2d6e4e76 2224 struct ieee80211_sta *sta;
a100885d
AN		 2225 bool sta_exists = false;
2226 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 2227
2228 if (is_ibss) {
2229 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2230 changed);
2231 if (ret < 0)
2232 goto out;
e0d8bbf0
JO		 2233 }
2234
e78a287a
AN		 2235 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2236 do_join = true;
2237
2238 /* Need to update the SSID (for filtering etc) */
2239 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2240 do_join = true;
2241
2242 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 2243 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2244 bss_conf->enable_beacon ? "enabled" : "disabled");
2245
2246 if (bss_conf->enable_beacon)
2247 wl->set_bss_type = BSS_TYPE_IBSS;
2248 else
2249 wl->set_bss_type = BSS_TYPE_STA_BSS;
2250 do_join = true;
2251 }
2252
e78a287a 2253 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 2254 bool enable = false;
2255 if (bss_conf->cqm_rssi_thold)
2256 enable = true;
2257 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2258 bss_conf->cqm_rssi_thold,
2259 bss_conf->cqm_rssi_hyst);
2260 if (ret < 0)
2261 goto out;
2262 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2263 }
2264
30240fc7
JO		 2265 if ((changed & BSS_CHANGED_BSSID) &&
2266 /*
2267 * Now we know the correct bssid, so we send a new join command
2268 * and enable the BSSID filter
2269 */
2270 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 2271 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 2272
fa287b8f
EP		 2273 if (!is_zero_ether_addr(wl->bssid)) {
2274 ret = wl1271_cmd_build_null_data(wl);
2275 if (ret < 0)
2276 goto out;
30240fc7 2277
fa287b8f
EP		 2278 ret = wl1271_build_qos_null_data(wl);
2279 if (ret < 0)
2280 goto out;
30240fc7 2281
fa287b8f
EP		 2282 /* filter out all packets not from this BSSID */
2283 wl1271_configure_filters(wl, 0);
14b228a0 2284
fa287b8f
EP		 2285 /* Need to update the BSSID (for filtering etc) */
2286 do_join = true;
2287 }
30240fc7
JO		 2288 }
2289
72c2d9e5
EP		 2290 rcu_read_lock();
2291 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2292 if (sta) {
2293 /* save the supp_rates of the ap */
2294 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2295 if (sta->ht_cap.ht_supported)
2296 sta_rate_set |=
2297 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 2298 sta_ht_cap = sta->ht_cap;
2299 sta_exists = true;
2300 }
2301 rcu_read_unlock();
72c2d9e5 2302
a100885d 2303 if (sta_exists) {
72c2d9e5
EP		 2304 /* handle new association with HT and HT information change */
2305 if ((changed & BSS_CHANGED_HT) &&
2306 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 2307 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2308 true);
2309 if (ret < 0) {
2310 wl1271_warning("Set ht cap true failed %d",
2311 ret);
72c2d9e5
EP		 2312 goto out;
2313 }
2314 ret = wl1271_acx_set_ht_information(wl,
2315 bss_conf->ht_operation_mode);
2316 if (ret < 0) {
2317 wl1271_warning("Set ht information failed %d",
2318 ret);
72c2d9e5
EP		 2319 goto out;
2320 }
2321 }
2322 /* handle new association without HT and disassociation */
2323 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 2324 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2325 false);
2326 if (ret < 0) {
2327 wl1271_warning("Set ht cap false failed %d",
2328 ret);
72c2d9e5
EP		 2329 goto out;
2330 }
2331 }
2332 }
72c2d9e5 2333
e78a287a 2334 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 2335 if (bss_conf->assoc) {
ebba60c6 2336 u32 rates;
2f6724b2 2337 int ieoffset;
f5fc0f86 2338 wl->aid = bss_conf->aid;
69e5434c 2339 set_assoc = true;
f5fc0f86 2340
90494a90
JO		 2341 wl->ps_poll_failures = 0;
2342
ebba60c6
JO		 2343 /*
2344 * use basic rates from AP, and determine lowest rate
2345 * to use with control frames.
2346 */
2347 rates = bss_conf->basic_rates;
2348 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2349 rates);
e0fe371b 2350 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 2351 if (sta_rate_set)
2352 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2353 sta_rate_set);
79b223f4 2354 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2355 if (ret < 0)
e78a287a 2356 goto out;
ebba60c6 2357
ae751bab
LC		 2358 /*
2359 * with wl1271, we don't need to update the
2360 * beacon_int and dtim_period, because the firmware
2361 * updates it by itself when the first beacon is
2362 * received after a join.
2363 */
f5fc0f86
LC		 2364 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2365 if (ret < 0)
e78a287a 2366 goto out;
f5fc0f86 2367
c2b2d99b 2368 /*
2f6724b2 2369 * Get a template for hardware connection maintenance
c2b2d99b 2370 */
2f6724b2
JO		 2371 dev_kfree_skb(wl->probereq);
2372 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2373 ieoffset = offsetof(struct ieee80211_mgmt,
2374 u.probe_req.variable);
2375 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 2376
6ccbb92e
JO		 2377 /* enable the connection monitoring feature */
2378 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 2379 if (ret < 0)
e78a287a 2380 goto out;
f5fc0f86
LC		 2381
2382 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 2383 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2384 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 2385 enum wl1271_cmd_ps_mode mode;
2386
f5fc0f86 2387 mode = STATION_POWER_SAVE_MODE;
65cddbf1 2388 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 2389 wl->basic_rate,
65cddbf1 2390 true);
f5fc0f86 2391 if (ret < 0)
e78a287a 2392 goto out;
f5fc0f86 2393 }
d94cd297
JO		 2394 } else {
2395 /* use defaults when not associated */
c2c192ac 2396 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
830fb67b 2397 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 2398 wl->aid = 0;
6ccbb92e 2399
2f6724b2
JO		 2400 /* free probe-request template */
2401 dev_kfree_skb(wl->probereq);
2402 wl->probereq = NULL;
2403
8d2ef7bd 2404 /* re-enable dynamic ps - just in case */
f532be6d 2405 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2406
ebba60c6
JO		 2407 /* revert back to minimum rates for the current band */
2408 wl1271_set_band_rate(wl);
e0fe371b 2409 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 2410 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2411 if (ret < 0)
e78a287a 2412 goto out;
ebba60c6 2413
6ccbb92e
JO		 2414 /* disable connection monitor features */
2415 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2416
2417 /* Disable the keep-alive feature */
2418 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 2419 if (ret < 0)
e78a287a 2420 goto out;
b84a7d3d
JO		 2421
2422 /* restore the bssid filter and go to dummy bssid */
2423 wl1271_unjoin(wl);
2424 wl1271_dummy_join(wl);
f5fc0f86 2425 }
f5fc0f86
LC		 2426 }
2427
e78a287a
AN		 2428 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2429 if (ret < 0)
2430 goto out;
f5fc0f86 2431
ca52a5eb
JO		 2432 if (changed & BSS_CHANGED_ARP_FILTER) {
2433 __be32 addr = bss_conf->arp_addr_list[0];
2434 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2435
c5312772
EP		 2436 if (bss_conf->arp_addr_cnt == 1 &&
2437 bss_conf->arp_filter_enabled) {
2438 /*
2439 * The template should have been configured only upon
2440 * association. however, it seems that the correct ip
2441 * isn't being set (when sending), so we have to
2442 * reconfigure the template upon every ip change.
2443 */
2444 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2445 if (ret < 0) {
2446 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 2447 goto out;
c5312772
EP		 2448 }
2449
2450 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 2451 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 2452 addr);
2453 } else
2454 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 2455
2456 if (ret < 0)
e78a287a 2457 goto out;
ca52a5eb
JO		 2458 }
2459
8bf29b0e 2460 if (do_join) {
69e5434c 2461 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2462 if (ret < 0) {
2463 wl1271_warning("cmd join failed %d", ret);
e78a287a 2464 goto out;
8bf29b0e 2465 }
c1899554
JO		 2466 }
2467
e78a287a
AN		 2468out:
2469 return;
2470}
2471
2472static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2473 struct ieee80211_vif *vif,
2474 struct ieee80211_bss_conf *bss_conf,
2475 u32 changed)
2476{
2477 struct wl1271 *wl = hw->priv;
2478 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2479 int ret;
2480
2481 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2482 (int)changed);
2483
2484 mutex_lock(&wl->mutex);
2485
2486 if (unlikely(wl->state == WL1271_STATE_OFF))
2487 goto out;
2488
2489 ret = wl1271_ps_elp_wakeup(wl, false);
2490 if (ret < 0)
2491 goto out;
2492
2493 if (is_ap)
2494 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2495 else
2496 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2497
f5fc0f86
LC		 2498 wl1271_ps_elp_sleep(wl);
2499
2500out:
2501 mutex_unlock(&wl->mutex);
2502}
2503
c6999d83
KV		 2504static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2505 const struct ieee80211_tx_queue_params *params)
2506{
2507 struct wl1271 *wl = hw->priv;
4695dc91 2508 u8 ps_scheme;
488fc540 2509 int ret = 0;
c6999d83
KV		 2510
2511 mutex_lock(&wl->mutex);
2512
2513 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2514
4695dc91
KV		 2515 if (params->uapsd)
2516 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2517 else
2518 ps_scheme = CONF_PS_SCHEME_LEGACY;
2519
488fc540
AN		 2520 if (wl->state == WL1271_STATE_OFF) {
2521 /*
2522 * If the state is off, the parameters will be recorded and
2523 * configured on init. This happens in AP-mode.
2524 */
2525 struct conf_tx_ac_category *conf_ac =
2526 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2527 struct conf_tx_tid *conf_tid =
2528 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2529
2530 conf_ac->ac = wl1271_tx_get_queue(queue);
2531 conf_ac->cw_min = (u8)params->cw_min;
2532 conf_ac->cw_max = params->cw_max;
2533 conf_ac->aifsn = params->aifs;
2534 conf_ac->tx_op_limit = params->txop << 5;
2535
2536 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2537 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2538 conf_tid->tsid = wl1271_tx_get_queue(queue);
2539 conf_tid->ps_scheme = ps_scheme;
2540 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2541 conf_tid->apsd_conf[0] = 0;
2542 conf_tid->apsd_conf[1] = 0;
2543 } else {
2544 ret = wl1271_ps_elp_wakeup(wl, false);
2545 if (ret < 0)
2546 goto out;
2547
2548 /*
2549 * the txop is confed in units of 32us by the mac80211,
2550 * we need us
2551 */
2552 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2553 params->cw_min, params->cw_max,
2554 params->aifs, params->txop << 5);
2555 if (ret < 0)
2556 goto out_sleep;
2557
2558 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2559 CONF_CHANNEL_TYPE_EDCF,
2560 wl1271_tx_get_queue(queue),
2561 ps_scheme, CONF_ACK_POLICY_LEGACY,
2562 0, 0);
2563 if (ret < 0)
2564 goto out_sleep;
c82c1dde
KV		 2565
2566out_sleep:
488fc540
AN		 2567 wl1271_ps_elp_sleep(wl);
2568 }
c6999d83
KV		 2569
2570out:
2571 mutex_unlock(&wl->mutex);
2572
2573 return ret;
2574}
2575
bbbb538e
JO		 2576static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2577{
2578
2579 struct wl1271 *wl = hw->priv;
2580 u64 mactime = ULLONG_MAX;
2581 int ret;
2582
2583 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2584
2585 mutex_lock(&wl->mutex);
2586
f8d9802f
JO		 2587 if (unlikely(wl->state == WL1271_STATE_OFF))
2588 goto out;
2589
bbbb538e
JO		 2590 ret = wl1271_ps_elp_wakeup(wl, false);
2591 if (ret < 0)
2592 goto out;
2593
2594 ret = wl1271_acx_tsf_info(wl, &mactime);
2595 if (ret < 0)
2596 goto out_sleep;
2597
2598out_sleep:
2599 wl1271_ps_elp_sleep(wl);
2600
2601out:
2602 mutex_unlock(&wl->mutex);
2603 return mactime;
2604}
f5fc0f86 2605
ece550d0
JL		 2606static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2607 struct survey_info *survey)
2608{
2609 struct wl1271 *wl = hw->priv;
2610 struct ieee80211_conf *conf = &hw->conf;
b739a42c 2611
ece550d0
JL		 2612 if (idx != 0)
2613 return -ENOENT;
b739a42c 2614
ece550d0
JL		 2615 survey->channel = conf->channel;
2616 survey->filled = SURVEY_INFO_NOISE_DBM;
2617 survey->noise = wl->noise;
b739a42c 2618
ece550d0
JL		 2619 return 0;
2620}
2621
f84f7d78
AN		 2622static int wl1271_allocate_hlid(struct wl1271 *wl,
2623 struct ieee80211_sta *sta,
2624 u8 *hlid)
2625{
2626 struct wl1271_station *wl_sta;
2627 int id;
2628
2629 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2630 if (id >= AP_MAX_STATIONS) {
2631 wl1271_warning("could not allocate HLID - too much stations");
2632 return -EBUSY;
2633 }
2634
2635 wl_sta = (struct wl1271_station *)sta->drv_priv;
2636
2637 __set_bit(id, wl->ap_hlid_map);
2638 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2639 *hlid = wl_sta->hlid;
2640 return 0;
2641}
2642
2643static void wl1271_free_hlid(struct wl1271 *wl, u8 hlid)
2644{
2645 int id = hlid - WL1271_AP_STA_HLID_START;
2646
2647 __clear_bit(id, wl->ap_hlid_map);
2648}
2649
2650static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2651 struct ieee80211_vif *vif,
2652 struct ieee80211_sta *sta)
2653{
2654 struct wl1271 *wl = hw->priv;
2655 int ret = 0;
2656 u8 hlid;
2657
2658 mutex_lock(&wl->mutex);
2659
2660 if (unlikely(wl->state == WL1271_STATE_OFF))
2661 goto out;
2662
2663 if (wl->bss_type != BSS_TYPE_AP_BSS)
2664 goto out;
2665
2666 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2667
2668 ret = wl1271_allocate_hlid(wl, sta, &hlid);
2669 if (ret < 0)
2670 goto out;
2671
2672 ret = wl1271_ps_elp_wakeup(wl, false);
2673 if (ret < 0)
2674 goto out;
2675
2676 ret = wl1271_cmd_add_sta(wl, sta, hlid);
2677 if (ret < 0)
2678 goto out_sleep;
2679
2680out_sleep:
2681 wl1271_ps_elp_sleep(wl);
2682
2683out:
2684 mutex_unlock(&wl->mutex);
2685 return ret;
2686}
2687
2688static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2689 struct ieee80211_vif *vif,
2690 struct ieee80211_sta *sta)
2691{
2692 struct wl1271 *wl = hw->priv;
2693 struct wl1271_station *wl_sta;
2694 int ret = 0, id;
2695
2696 mutex_lock(&wl->mutex);
2697
2698 if (unlikely(wl->state == WL1271_STATE_OFF))
2699 goto out;
2700
2701 if (wl->bss_type != BSS_TYPE_AP_BSS)
2702 goto out;
2703
2704 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
2705
2706 wl_sta = (struct wl1271_station *)sta->drv_priv;
2707 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
2708 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2709 goto out;
2710
2711 ret = wl1271_ps_elp_wakeup(wl, false);
2712 if (ret < 0)
2713 goto out;
2714
2715 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
2716 if (ret < 0)
2717 goto out_sleep;
2718
2719 wl1271_free_hlid(wl, wl_sta->hlid);
2720
2721out_sleep:
2722 wl1271_ps_elp_sleep(wl);
2723
2724out:
2725 mutex_unlock(&wl->mutex);
2726 return ret;
2727}
2728
bbba3e68 2729int wl1271_op_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7c3ee9e3
LC		 2730 enum ieee80211_ampdu_mlme_action action,
2731 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2732 u8 buf_size)
bbba3e68
LS		 2733{
2734 struct wl1271 *wl = hw->priv;
2735 int ret;
2736
2737 mutex_lock(&wl->mutex);
2738
2739 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2740 ret = -EAGAIN;
2741 goto out;
2742 }
2743
2744 ret = wl1271_ps_elp_wakeup(wl, false);
2745 if (ret < 0)
2746 goto out;
2747
2748 switch (action) {
2749 case IEEE80211_AMPDU_RX_START:
2750 if (wl->ba_support) {
2751 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
2752 true);
2753 if (!ret)
2754 wl->ba_rx_bitmap |= BIT(tid);
2755 } else {
2756 ret = -ENOTSUPP;
2757 }
2758 break;
2759
2760 case IEEE80211_AMPDU_RX_STOP:
2761 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
2762 if (!ret)
2763 wl->ba_rx_bitmap &= ~BIT(tid);
2764 break;
2765
2766 /*
2767 * The BA initiator session management in FW independently.
2768 * Falling break here on purpose for all TX APDU commands.
2769 */
2770 case IEEE80211_AMPDU_TX_START:
2771 case IEEE80211_AMPDU_TX_STOP:
2772 case IEEE80211_AMPDU_TX_OPERATIONAL:
2773 ret = -EINVAL;
2774 break;
2775
2776 default:
2777 wl1271_error("Incorrect ampdu action id=%x\n", action);
2778 ret = -EINVAL;
2779 }
2780
2781 wl1271_ps_elp_sleep(wl);
2782
2783out:
2784 mutex_unlock(&wl->mutex);
2785
2786 return ret;
2787}
2788
f5fc0f86
LC		 2789/* can't be const, mac80211 writes to this */
2790static struct ieee80211_rate wl1271_rates[] = {
2791 { .bitrate = 10,
2b60100b
JO		 2792 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2793 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 2794 { .bitrate = 20,
2b60100b
JO		 2795 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2796 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 2797 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2798 { .bitrate = 55,
2b60100b
JO		 2799 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2800 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 2801 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2802 { .bitrate = 110,
2b60100b
JO		 2803 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2804 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 2805 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2806 { .bitrate = 60,
2b60100b
JO		 2807 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2808 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 2809 { .bitrate = 90,
2b60100b
JO		 2810 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2811 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 2812 { .bitrate = 120,
2b60100b
JO		 2813 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2814 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 2815 { .bitrate = 180,
2b60100b
JO		 2816 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2817 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 2818 { .bitrate = 240,
2b60100b
JO		 2819 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2820 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 2821 { .bitrate = 360,
2b60100b
JO		 2822 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2823 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 2824 { .bitrate = 480,
2b60100b
JO		 2825 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2826 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 2827 { .bitrate = 540,
2b60100b
JO		 2828 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2829 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 2830};
2831
fa97f46b 2832/* can't be const, mac80211 writes to this */
f5fc0f86 2833static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 2834 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 2835 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 2836 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2837 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2838 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 2839 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 2840 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2841 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2842 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 2843 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 2844 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2845 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2846 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 2847 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 2848};
2849
f876bb9a 2850/* mapping to indexes for wl1271_rates */
a0ea9493 2851static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 2852 /* MCS rates are used only with 11n */
18357850
SL		 2853 7, /* CONF_HW_RXTX_RATE_MCS7 */
2854 6, /* CONF_HW_RXTX_RATE_MCS6 */
2855 5, /* CONF_HW_RXTX_RATE_MCS5 */
2856 4, /* CONF_HW_RXTX_RATE_MCS4 */
2857 3, /* CONF_HW_RXTX_RATE_MCS3 */
2858 2, /* CONF_HW_RXTX_RATE_MCS2 */
2859 1, /* CONF_HW_RXTX_RATE_MCS1 */
2860 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2861
2862 11, /* CONF_HW_RXTX_RATE_54 */
2863 10, /* CONF_HW_RXTX_RATE_48 */
2864 9, /* CONF_HW_RXTX_RATE_36 */
2865 8, /* CONF_HW_RXTX_RATE_24 */
2866
2867 /* TI-specific rate */
2868 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2869
2870 7, /* CONF_HW_RXTX_RATE_18 */
2871 6, /* CONF_HW_RXTX_RATE_12 */
2872 3, /* CONF_HW_RXTX_RATE_11 */
2873 5, /* CONF_HW_RXTX_RATE_9 */
2874 4, /* CONF_HW_RXTX_RATE_6 */
2875 2, /* CONF_HW_RXTX_RATE_5_5 */
2876 1, /* CONF_HW_RXTX_RATE_2 */
2877 0 /* CONF_HW_RXTX_RATE_1 */
2878};
2879
e8b03a2b
SL		 2880/* 11n STA capabilities */
2881#define HW_RX_HIGHEST_RATE 72
2882
00d20100
SL		 2883#ifdef CONFIG_WL12XX_HT
2884#define WL12XX_HT_CAP { \
e8b03a2b
SL		 2885 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2886 .ht_supported = true, \
2887 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2888 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2889 .mcs = { \
2890 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2891 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2892 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2893 }, \
2894}
18357850 2895#else
00d20100 2896#define WL12XX_HT_CAP { \
18357850
SL		 2897 .ht_supported = false, \
2898}
2899#endif
e8b03a2b 2900
f5fc0f86
LC		 2901/* can't be const, mac80211 writes to this */
2902static struct ieee80211_supported_band wl1271_band_2ghz = {
2903 .channels = wl1271_channels,
2904 .n_channels = ARRAY_SIZE(wl1271_channels),
2905 .bitrates = wl1271_rates,
2906 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 2907 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 2908};
2909
1ebec3d7
TP		 2910/* 5 GHz data rates for WL1273 */
2911static struct ieee80211_rate wl1271_rates_5ghz[] = {
2912 { .bitrate = 60,
2913 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2914 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2915 { .bitrate = 90,
2916 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2917 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2918 { .bitrate = 120,
2919 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2920 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2921 { .bitrate = 180,
2922 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2923 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2924 { .bitrate = 240,
2925 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2926 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2927 { .bitrate = 360,
2928 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2929 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2930 { .bitrate = 480,
2931 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2932 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2933 { .bitrate = 540,
2934 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2935 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2936};
2937
fa97f46b 2938/* 5 GHz band channels for WL1273 */
1ebec3d7 2939static struct ieee80211_channel wl1271_channels_5ghz[] = {
fa21c7a9 2940 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 2941 { .hw_value = 8, .center_freq = 5040},
2942 { .hw_value = 9, .center_freq = 5045},
2943 { .hw_value = 11, .center_freq = 5055},
2944 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 2945 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 2946 { .hw_value = 34, .center_freq = 5170},
2947 { .hw_value = 36, .center_freq = 5180},
2948 { .hw_value = 38, .center_freq = 5190},
2949 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 2950 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 2951 { .hw_value = 44, .center_freq = 5220},
2952 { .hw_value = 46, .center_freq = 5230},
2953 { .hw_value = 48, .center_freq = 5240},
2954 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 2955 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 2956 { .hw_value = 60, .center_freq = 5300},
2957 { .hw_value = 64, .center_freq = 5320},
2958 { .hw_value = 100, .center_freq = 5500},
2959 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 2960 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 2961 { .hw_value = 112, .center_freq = 5560},
2962 { .hw_value = 116, .center_freq = 5580},
2963 { .hw_value = 120, .center_freq = 5600},
2964 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 2965 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 2966 { .hw_value = 132, .center_freq = 5660},
2967 { .hw_value = 136, .center_freq = 5680},
2968 { .hw_value = 140, .center_freq = 5700},
2969 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 2970 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 2971 { .hw_value = 157, .center_freq = 5785},
2972 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 2973 { .hw_value = 165, .center_freq = 5825},
2974};
2975
f876bb9a 2976/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2977static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 2978 /* MCS rates are used only with 11n */
18357850
SL		 2979 7, /* CONF_HW_RXTX_RATE_MCS7 */
2980 6, /* CONF_HW_RXTX_RATE_MCS6 */
2981 5, /* CONF_HW_RXTX_RATE_MCS5 */
2982 4, /* CONF_HW_RXTX_RATE_MCS4 */
2983 3, /* CONF_HW_RXTX_RATE_MCS3 */
2984 2, /* CONF_HW_RXTX_RATE_MCS2 */
2985 1, /* CONF_HW_RXTX_RATE_MCS1 */
2986 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2987
2988 7, /* CONF_HW_RXTX_RATE_54 */
2989 6, /* CONF_HW_RXTX_RATE_48 */
2990 5, /* CONF_HW_RXTX_RATE_36 */
2991 4, /* CONF_HW_RXTX_RATE_24 */
2992
2993 /* TI-specific rate */
2994 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2995
2996 3, /* CONF_HW_RXTX_RATE_18 */
2997 2, /* CONF_HW_RXTX_RATE_12 */
2998 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
2999 1, /* CONF_HW_RXTX_RATE_9 */
3000 0, /* CONF_HW_RXTX_RATE_6 */
3001 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3002 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3003 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3004};
1ebec3d7
TP		 3005
3006static struct ieee80211_supported_band wl1271_band_5ghz = {
3007 .channels = wl1271_channels_5ghz,
3008 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3009 .bitrates = wl1271_rates_5ghz,
3010 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 3011 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 3012};
3013
a0ea9493 3014static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 3015 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3016 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3017};
3018
f5fc0f86
LC		 3019static const struct ieee80211_ops wl1271_ops = {
3020 .start = wl1271_op_start,
3021 .stop = wl1271_op_stop,
3022 .add_interface = wl1271_op_add_interface,
3023 .remove_interface = wl1271_op_remove_interface,
3024 .config = wl1271_op_config,
c87dec9f 3025 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 3026 .configure_filter = wl1271_op_configure_filter,
3027 .tx = wl1271_op_tx,
3028 .set_key = wl1271_op_set_key,
3029 .hw_scan = wl1271_op_hw_scan,
3030 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 3031 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 3032 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 3033 .conf_tx = wl1271_op_conf_tx,
bbbb538e 3034 .get_tsf = wl1271_op_get_tsf,
ece550d0 3035 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 3036 .sta_add = wl1271_op_sta_add,
3037 .sta_remove = wl1271_op_sta_remove,
bbba3e68 3038 .ampdu_action = wl1271_op_ampdu_action,
c8c90873 3039 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 3040};
3041
f876bb9a 3042
6a2de93b 3043u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 3044{
3045 u8 idx;
3046
6a2de93b 3047 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 3048
3049 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3050 wl1271_error("Illegal RX rate from HW: %d", rate);
3051 return 0;
3052 }
3053
6a2de93b 3054 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 3055 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3056 wl1271_error("Unsupported RX rate from HW: %d", rate);
3057 return 0;
3058 }
3059
3060 return idx;
3061}
3062
7fc3a864
JO		 3063static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3064 struct device_attribute *attr,
3065 char *buf)
3066{
3067 struct wl1271 *wl = dev_get_drvdata(dev);
3068 ssize_t len;
3069
2f63b011 3070 len = PAGE_SIZE;
7fc3a864
JO		 3071
3072 mutex_lock(&wl->mutex);
3073 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3074 wl->sg_enabled);
3075 mutex_unlock(&wl->mutex);
3076
3077 return len;
3078
3079}
3080
3081static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3082 struct device_attribute *attr,
3083 const char *buf, size_t count)
3084{
3085 struct wl1271 *wl = dev_get_drvdata(dev);
3086 unsigned long res;
3087 int ret;
3088
3089 ret = strict_strtoul(buf, 10, &res);
3090
3091 if (ret < 0) {
3092 wl1271_warning("incorrect value written to bt_coex_mode");
3093 return count;
3094 }
3095
3096 mutex_lock(&wl->mutex);
3097
3098 res = !!res;
3099
3100 if (res == wl->sg_enabled)
3101 goto out;
3102
3103 wl->sg_enabled = res;
3104
3105 if (wl->state == WL1271_STATE_OFF)
3106 goto out;
3107
3108 ret = wl1271_ps_elp_wakeup(wl, false);
3109 if (ret < 0)
3110 goto out;
3111
3112 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3113 wl1271_ps_elp_sleep(wl);
3114
3115 out:
3116 mutex_unlock(&wl->mutex);
3117 return count;
3118}
3119
3120static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3121 wl1271_sysfs_show_bt_coex_state,
3122 wl1271_sysfs_store_bt_coex_state);
3123
d717fd61
JO		 3124static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3125 struct device_attribute *attr,
3126 char *buf)
3127{
3128 struct wl1271 *wl = dev_get_drvdata(dev);
3129 ssize_t len;
3130
2f63b011 3131 len = PAGE_SIZE;
d717fd61
JO		 3132
3133 mutex_lock(&wl->mutex);
3134 if (wl->hw_pg_ver >= 0)
3135 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3136 else
3137 len = snprintf(buf, len, "n/a\n");
3138 mutex_unlock(&wl->mutex);
3139
3140 return len;
3141}
3142
3143static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3144 wl1271_sysfs_show_hw_pg_ver, NULL);
3145
2d5e82b8 3146int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 3147{
3148 int ret;
3149
3150 if (wl->mac80211_registered)
3151 return 0;
3152
31d26ec6
AN		 3153 ret = wl1271_fetch_nvs(wl);
3154 if (ret == 0) {
3155 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
3156
3157 wl->mac_addr[0] = nvs_ptr[11];
3158 wl->mac_addr[1] = nvs_ptr[10];
3159 wl->mac_addr[2] = nvs_ptr[6];
3160 wl->mac_addr[3] = nvs_ptr[5];
3161 wl->mac_addr[4] = nvs_ptr[4];
3162 wl->mac_addr[5] = nvs_ptr[3];
3163 }
3164
f5fc0f86
LC		 3165 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3166
3167 ret = ieee80211_register_hw(wl->hw);
3168 if (ret < 0) {
3169 wl1271_error("unable to register mac80211 hw: %d", ret);
3170 return ret;
3171 }
3172
3173 wl->mac80211_registered = true;
3174
d60080ae
EP		 3175 wl1271_debugfs_init(wl);
3176
c2c192ac
JO		 3177 register_netdevice_notifier(&wl1271_dev_notifier);
3178
f5fc0f86
LC		 3179 wl1271_notice("loaded");
3180
3181 return 0;
3182}
50b3eb4b 3183EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 3184
3b56dd6a
TP		 3185void wl1271_unregister_hw(struct wl1271 *wl)
3186{
4ae3fa87
JO		 3187 if (wl->state == WL1271_STATE_PLT)
3188 __wl1271_plt_stop(wl);
3189
c2c192ac 3190 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 3191 ieee80211_unregister_hw(wl->hw);
3192 wl->mac80211_registered = false;
3193
3194}
3195EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3196
2d5e82b8 3197int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 3198{
7a55724e
JO		 3199 static const u32 cipher_suites[] = {
3200 WLAN_CIPHER_SUITE_WEP40,
3201 WLAN_CIPHER_SUITE_WEP104,
3202 WLAN_CIPHER_SUITE_TKIP,
3203 WLAN_CIPHER_SUITE_CCMP,
3204 WL1271_CIPHER_SUITE_GEM,
3205 };
3206
1e2b7976
JO		 3207 /* The tx descriptor buffer and the TKIP space. */
3208 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3209 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 3210
3211 /* unit us */
3212 /* FIXME: find a proper value */
3213 wl->hw->channel_change_time = 10000;
50c500ad 3214 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 3215
3216 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 3217 IEEE80211_HW_BEACON_FILTER |
0a34332f 3218 IEEE80211_HW_SUPPORTS_PS |
4695dc91 3219 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 3220 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed
JO		 3221 IEEE80211_HW_CONNECTION_MONITOR |
3222 IEEE80211_HW_SUPPORTS_CQM_RSSI;
f5fc0f86 3223
7a55724e
JO		 3224 wl->hw->wiphy->cipher_suites = cipher_suites;
3225 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3226
e0d8bbf0 3227 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 3228 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 3229 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 3230 /*
3231 * Maximum length of elements in scanning probe request templates
3232 * should be the maximum length possible for a template, without
3233 * the IEEE80211 header of the template
3234 */
3235 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3236 sizeof(struct ieee80211_header);
a8aaaf53
LC		 3237
3238 /*
3239 * We keep local copies of the band structs because we need to
3240 * modify them on a per-device basis.
3241 */
3242 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3243 sizeof(wl1271_band_2ghz));
3244 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3245 sizeof(wl1271_band_5ghz));
3246
3247 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3248 &wl->bands[IEEE80211_BAND_2GHZ];
3249 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3250 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 3251
12bd8949 3252 wl->hw->queues = 4;
31627dc5 3253 wl->hw->max_rates = 1;
12bd8949 3254
b7417d93
JO		 3255 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3256
8197b711 3257 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 3258
f84f7d78
AN		 3259 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3260
4c9cfa78
LC		 3261 wl->hw->max_rx_aggregation_subframes = 8;
3262
f5fc0f86
LC		 3263 return 0;
3264}
50b3eb4b 3265EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 3266
f5fc0f86 3267#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 3268
2d5e82b8 3269struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 3270{
f5fc0f86 3271 struct ieee80211_hw *hw;
3b56dd6a 3272 struct platform_device *plat_dev = NULL;
f5fc0f86 3273 struct wl1271 *wl;
a1dd8187 3274 int i, ret;
1f37cbc9 3275 unsigned int order;
f5fc0f86
LC		 3276
3277 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3278 if (!hw) {
3279 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 3280 ret = -ENOMEM;
3b56dd6a
TP		 3281 goto err_hw_alloc;
3282 }
3283
929ebd30 3284 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 3285 if (!plat_dev) {
3286 wl1271_error("could not allocate platform_device");
3287 ret = -ENOMEM;
3288 goto err_plat_alloc;
f5fc0f86
LC		 3289 }
3290
3291 wl = hw->priv;
3292 memset(wl, 0, sizeof(*wl));
3293
01c09162
JO		 3294 INIT_LIST_HEAD(&wl->list);
3295
f5fc0f86 3296 wl->hw = hw;
3b56dd6a 3297 wl->plat_dev = plat_dev;
f5fc0f86 3298
6742f554
JO		 3299 for (i = 0; i < NUM_TX_QUEUES; i++)
3300 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 3301
37b70a81 3302 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 3303 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
117b38d0
JO		 3304 INIT_WORK(&wl->irq_work, wl1271_irq_work);
3305 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3306 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3307 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 3308 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 3309 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 3310 wl->default_key = 0;
f5fc0f86 3311 wl->rx_counter = 0;
ae113b57
AN		 3312 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3313 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
19ad0715 3314 wl->psm_entry_retry = 0;
f5fc0f86 3315 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 3316 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 3317 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 3318 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 3319 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 3320 wl->vif = NULL;
830fb67b 3321 wl->flags = 0;
7fc3a864 3322 wl->sg_enabled = true;
d717fd61 3323 wl->hw_pg_ver = -1;
166d504e
AN		 3324 wl->bss_type = MAX_BSS_TYPE;
3325 wl->set_bss_type = MAX_BSS_TYPE;
3326 wl->fw_bss_type = MAX_BSS_TYPE;
f5fc0f86 3327
25eeb9e3 3328 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 3329 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 3330 wl->tx_frames[i] = NULL;
3331
3332 spin_lock_init(&wl->wl_lock);
3333
f5fc0f86
LC		 3334 wl->state = WL1271_STATE_OFF;
3335 mutex_init(&wl->mutex);
3336
c332a4b8
TP		 3337 /* Apply default driver configuration. */
3338 wl1271_conf_init(wl);
3339
1f37cbc9
IY		 3340 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3341 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3342 if (!wl->aggr_buf) {
3343 ret = -ENOMEM;
3344 goto err_hw;
3345 }
3346
a1dd8187 3347 /* Register platform device */
3b56dd6a 3348 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 3349 if (ret) {
3350 wl1271_error("couldn't register platform device");
1f37cbc9 3351 goto err_aggr;
a1dd8187 3352 }
3b56dd6a 3353 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 3354
7fc3a864 3355 /* Create sysfs file to control bt coex state */
3b56dd6a 3356 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 3357 if (ret < 0) {
3358 wl1271_error("failed to create sysfs file bt_coex_state");
3359 goto err_platform;
3360 }
a1dd8187 3361
d717fd61
JO		 3362 /* Create sysfs file to get HW PG version */
3363 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3364 if (ret < 0) {
3365 wl1271_error("failed to create sysfs file hw_pg_ver");
3366 goto err_bt_coex_state;
3367 }
3368
c332a4b8 3369 return hw;
a1dd8187 3370
d717fd61
JO		 3371err_bt_coex_state:
3372 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3373
7fc3a864 3374err_platform:
3b56dd6a 3375 platform_device_unregister(wl->plat_dev);
7fc3a864 3376
1f37cbc9
IY		 3377err_aggr:
3378 free_pages((unsigned long)wl->aggr_buf, order);
3379
a1dd8187 3380err_hw:
3b56dd6a
TP		 3381 wl1271_debugfs_exit(wl);
3382 kfree(plat_dev);
3383
3384err_plat_alloc:
3385 ieee80211_free_hw(hw);
3386
3387err_hw_alloc:
a1dd8187 3388
a1dd8187 3389 return ERR_PTR(ret);
c332a4b8 3390}
50b3eb4b 3391EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 3392
3393int wl1271_free_hw(struct wl1271 *wl)
3394{
3b56dd6a 3395 platform_device_unregister(wl->plat_dev);
1f37cbc9
IY		 3396 free_pages((unsigned long)wl->aggr_buf,
3397 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 3398 kfree(wl->plat_dev);
c332a4b8
TP		 3399
3400 wl1271_debugfs_exit(wl);
3401
c332a4b8
TP		 3402 vfree(wl->fw);
3403 wl->fw = NULL;
3404 kfree(wl->nvs);
3405 wl->nvs = NULL;
3406
3407 kfree(wl->fw_status);
3408 kfree(wl->tx_res_if);
3409
3410 ieee80211_free_hw(wl->hw);
3411
3412 return 0;
3413}
50b3eb4b
TP		 3414EXPORT_SYMBOL_GPL(wl1271_free_hw);
3415
491bbd6b 3416u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 3417EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 3418module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 3419MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3420
50b3eb4b
TP		 3421MODULE_LICENSE("GPL");
3422MODULE_AUTHOR("Luciano Coelho <luciano.coelho@nokia.com>");
3423MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.483296 seconds and 5 git commands to generate.