projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: AP-mode - support HW based link PS monitoring
[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;
a8c0ddb5 987 u8 hlid = 0;
f5fc0f86 988
830fb67b 989 spin_lock_irqsave(&wl->wl_lock, flags);
6742f554 990 wl->tx_queue_count++;
f4d08ddd
AN		 991
992 /*
993 * The workqueue is slow to process the tx_queue and we need stop
994 * the queue here, otherwise the queue will get too long.
995 */
996 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
997 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
998 ieee80211_stop_queues(wl->hw);
999 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1000 }
1001
830fb67b
JO		 1002 spin_unlock_irqrestore(&wl->wl_lock, flags);
1003
1004 /* queue the packet */
6742f554 1005 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
a8c0ddb5
AN		 1006 if (wl->bss_type == BSS_TYPE_AP_BSS) {
1007 hlid = wl1271_tx_get_hlid(skb);
1008 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1009 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1010 } else {
1011 skb_queue_tail(&wl->tx_queue[q], skb);
1012 }
f5fc0f86
LC		 1013
1014 /*
1015 * The chip specific setup must run before the first TX packet -
1016 * before that, the tx_work will not be initialized!
1017 */
1018
a522550a
IY		 1019 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1020 ieee80211_queue_work(wl->hw, &wl->tx_work);
f5fc0f86 1021
f5fc0f86
LC		 1022 return NETDEV_TX_OK;
1023}
1024
c2c192ac
JO		 1025static struct notifier_block wl1271_dev_notifier = {
1026 .notifier_call = wl1271_dev_notify,
1027};
1028
f5fc0f86 1029static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1030{
1031 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1032
1033 /*
1034 * We have to delay the booting of the hardware because
1035 * we need to know the local MAC address before downloading and
1036 * initializing the firmware. The MAC address cannot be changed
1037 * after boot, and without the proper MAC address, the firmware
1038 * will not function properly.
1039 *
1040 * The MAC address is first known when the corresponding interface
1041 * is added. That is where we will initialize the hardware.
166d504e
AN		 1042 *
1043 * In addition, we currently have different firmwares for AP and managed
1044 * operation. We will know which to boot according to interface type.
1b72aecd
JO		 1045 */
1046
1047 return 0;
1048}
1049
1050static void wl1271_op_stop(struct ieee80211_hw *hw)
1051{
1052 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1053}
1054
1055static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1056 struct ieee80211_vif *vif)
f5fc0f86
LC		 1057{
1058 struct wl1271 *wl = hw->priv;
ac01e948 1059 struct wiphy *wiphy = hw->wiphy;
9ccd9217 1060 int retries = WL1271_BOOT_RETRIES;
f5fc0f86 1061 int ret = 0;
71125abd 1062 bool booted = false;
f5fc0f86 1063
1b72aecd
JO		 1064 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1065 vif->type, vif->addr);
f5fc0f86
LC		 1066
1067 mutex_lock(&wl->mutex);
1b72aecd 1068 if (wl->vif) {
71125abd
EP		 1069 wl1271_debug(DEBUG_MAC80211,
1070 "multiple vifs are not supported yet");
1b72aecd
JO		 1071 ret = -EBUSY;
1072 goto out;
1073 }
1074
1b72aecd
JO		 1075 switch (vif->type) {
1076 case NL80211_IFTYPE_STATION:
1077 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 1078 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 1079 break;
1080 case NL80211_IFTYPE_ADHOC:
1081 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 1082 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd 1083 break;
038d925b
AN		 1084 case NL80211_IFTYPE_AP:
1085 wl->bss_type = BSS_TYPE_AP_BSS;
1086 break;
1b72aecd
JO		 1087 default:
1088 ret = -EOPNOTSUPP;
1089 goto out;
1090 }
1091
1092 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 1093
1094 if (wl->state != WL1271_STATE_OFF) {
1095 wl1271_error("cannot start because not in off state: %d",
1096 wl->state);
1097 ret = -EBUSY;
1098 goto out;
1099 }
1100
9ccd9217
JO		 1101 while (retries) {
1102 retries--;
1103 ret = wl1271_chip_wakeup(wl);
1104 if (ret < 0)
1105 goto power_off;
f5fc0f86 1106
9ccd9217
JO		 1107 ret = wl1271_boot(wl);
1108 if (ret < 0)
1109 goto power_off;
f5fc0f86 1110
9ccd9217
JO		 1111 ret = wl1271_hw_init(wl);
1112 if (ret < 0)
1113 goto irq_disable;
f5fc0f86 1114
71125abd
EP		 1115 booted = true;
1116 break;
eb5b28d0 1117
9ccd9217
JO		 1118irq_disable:
1119 wl1271_disable_interrupts(wl);
1120 mutex_unlock(&wl->mutex);
1121 /* Unlocking the mutex in the middle of handling is
1122 inherently unsafe. In this case we deem it safe to do,
1123 because we need to let any possibly pending IRQ out of
1124 the system (and while we are WL1271_STATE_OFF the IRQ
1125 work function will not do anything.) Also, any other
1126 possible concurrent operations will fail due to the
1127 current state, hence the wl1271 struct should be safe. */
1128 cancel_work_sync(&wl->irq_work);
1129 mutex_lock(&wl->mutex);
1130power_off:
1131 wl1271_power_off(wl);
1132 }
eb5b28d0 1133
71125abd
EP		 1134 if (!booted) {
1135 wl1271_error("firmware boot failed despite %d retries",
1136 WL1271_BOOT_RETRIES);
1137 goto out;
1138 }
1139
1140 wl->vif = vif;
1141 wl->state = WL1271_STATE_ON;
4b7fac77 1142 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 1143
1144 /* update hw/fw version info in wiphy struct */
1145 wiphy->hw_version = wl->chip.id;
4b7fac77 1146 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 1147 sizeof(wiphy->fw_version));
1148
fb6a6819
LC		 1149 /*
1150 * Now we know if 11a is supported (info from the NVS), so disable
1151 * 11a channels if not supported
1152 */
1153 if (!wl->enable_11a)
1154 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1155
1156 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1157 wl->enable_11a ? "" : "not ");
1158
eb5b28d0 1159out:
f5fc0f86
LC		 1160 mutex_unlock(&wl->mutex);
1161
eb887dfd 1162 if (!ret)
01c09162 1163 list_add(&wl->list, &wl_list);
01c09162 1164
f5fc0f86
LC		 1165 return ret;
1166}
1167
52a2a375 1168static void __wl1271_op_remove_interface(struct wl1271 *wl)
f5fc0f86 1169{
f5fc0f86
LC		 1170 int i;
1171
1b72aecd 1172 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 1173
1b72aecd 1174 wl1271_info("down");
f5fc0f86 1175
01c09162
JO		 1176 list_del(&wl->list);
1177
f5fc0f86
LC		 1178 WARN_ON(wl->state != WL1271_STATE_ON);
1179
8d2ef7bd 1180 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 1181 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 1182 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1183
08688d6b 1184 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b
LC		 1185 wl->scan.state = WL1271_SCAN_STATE_IDLE;
1186 kfree(wl->scan.scanned_ch);
1187 wl->scan.scanned_ch = NULL;
b739a42c 1188 wl->scan.req = NULL;
76a029fb 1189 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 1190 }
1191
1192 wl->state = WL1271_STATE_OFF;
1193
1194 wl1271_disable_interrupts(wl);
1195
1196 mutex_unlock(&wl->mutex);
1197
78abd320 1198 cancel_delayed_work_sync(&wl->scan_complete_work);
f5fc0f86
LC		 1199 cancel_work_sync(&wl->irq_work);
1200 cancel_work_sync(&wl->tx_work);
90494a90 1201 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1202 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1203
1204 mutex_lock(&wl->mutex);
1205
1206 /* let's notify MAC80211 about the remaining pending TX frames */
781608c4 1207 wl1271_tx_reset(wl);
f5fc0f86
LC		 1208 wl1271_power_off(wl);
1209
1210 memset(wl->bssid, 0, ETH_ALEN);
1211 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1212 wl->ssid_len = 0;
f5fc0f86 1213 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 1214 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 1215 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1216
1217 wl->rx_counter = 0;
19ad0715 1218 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1219 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1220 wl->tx_blocks_available = 0;
1221 wl->tx_results_count = 0;
1222 wl->tx_packets_count = 0;
ac4e4ce5 1223 wl->tx_security_last_seq = 0;
04e36fc5 1224 wl->tx_security_seq = 0;
f5fc0f86
LC		 1225 wl->time_offset = 0;
1226 wl->session_counter = 0;
830fb67b 1227 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
830fb67b 1228 wl->flags = 0;
1b72aecd 1229 wl->vif = NULL;
14b228a0 1230 wl->filters = 0;
7f179b46 1231 wl1271_free_ap_keys(wl);
f84f7d78 1232 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
d6e19d13 1233
f5fc0f86
LC		 1234 for (i = 0; i < NUM_TX_QUEUES; i++)
1235 wl->tx_blocks_freed[i] = 0;
1236
1237 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1238
1239 kfree(wl->fw_status);
1240 wl->fw_status = NULL;
1241 kfree(wl->tx_res_if);
1242 wl->tx_res_if = NULL;
1243 kfree(wl->target_mem_map);
1244 wl->target_mem_map = NULL;
52a2a375 1245}
bd9dc49c 1246
52a2a375
JO		 1247static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1248 struct ieee80211_vif *vif)
1249{
1250 struct wl1271 *wl = hw->priv;
1251
1252 mutex_lock(&wl->mutex);
67353299
JO		 1253 /*
1254 * wl->vif can be null here if someone shuts down the interface
1255 * just when hardware recovery has been started.
1256 */
1257 if (wl->vif) {
1258 WARN_ON(wl->vif != vif);
1259 __wl1271_op_remove_interface(wl);
1260 }
52b0e7a6 1261
67353299 1262 mutex_unlock(&wl->mutex);
52b0e7a6 1263 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1264}
1265
14b228a0
JO		 1266static void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
1267{
ae113b57 1268 wl1271_set_default_filters(wl);
14b228a0
JO		 1269
1270 /* combine requested filters with current filter config */
1271 filters = wl->filters | filters;
1272
1273 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1274
1275 if (filters & FIF_PROMISC_IN_BSS) {
1276 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1277 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1278 wl->rx_config |= CFG_BSSID_FILTER_EN;
1279 }
1280 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1281 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1282 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1283 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1284 }
1285 if (filters & FIF_OTHER_BSS) {
1286 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1287 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1288 }
1289 if (filters & FIF_CONTROL) {
1290 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1291 wl->rx_filter |= CFG_RX_CTL_EN;
1292 }
1293 if (filters & FIF_FCSFAIL) {
1294 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1295 wl->rx_filter |= CFG_RX_FCS_ERROR;
1296 }
1297}
1298
82429d32 1299static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1300{
e0d8bbf0 1301 int ret = 0;
c7f43e45
LC		 1302 /* we need to use a dummy BSSID for now */
1303 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1304 0xad, 0xbe, 0xef };
1305
c7f43e45
LC		 1306 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1307
14b228a0
JO		 1308 /* pass through frames from all BSS */
1309 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1310
5da11dcd 1311 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1312 if (ret < 0)
1313 goto out;
1314
71449f8d 1315 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1316
1317out:
1318 return ret;
1319}
1320
69e5434c 1321static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1322{
1323 int ret;
1324
69e5434c
JO		 1325 /*
1326 * One of the side effects of the JOIN command is that is clears
1327 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1328 * to a WPA/WPA2 access point will therefore kill the data-path.
1329 * Currently there is no supported scenario for JOIN during
1330 * association - if it becomes a supported scenario, the WPA/WPA2 keys
1331 * must be handled somehow.
1332 *
1333 */
1334 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1335 wl1271_info("JOIN while associated.");
1336
1337 if (set_assoc)
1338 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1339
82429d32
JO		 1340 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1341 if (ret < 0)
1342 goto out;
1343
1344 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1345
1346 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1347 goto out;
1348
1349 /*
1350 * The join command disable the keep-alive mode, shut down its process,
1351 * and also clear the template config, so we need to reset it all after
1352 * the join. The acx_aid starts the keep-alive process, and the order
1353 * of the commands below is relevant.
1354 */
1355 ret = wl1271_acx_keep_alive_mode(wl, true);
1356 if (ret < 0)
1357 goto out;
1358
1359 ret = wl1271_acx_aid(wl, wl->aid);
1360 if (ret < 0)
1361 goto out;
1362
1363 ret = wl1271_cmd_build_klv_null_data(wl);
1364 if (ret < 0)
1365 goto out;
1366
1367 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1368 ACX_KEEP_ALIVE_TPL_VALID);
1369 if (ret < 0)
1370 goto out;
1371
1372out:
1373 return ret;
1374}
1375
1376static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1377{
1378 int ret;
1379
1380 /* to stop listening to a channel, we disconnect */
1381 ret = wl1271_cmd_disconnect(wl);
1382 if (ret < 0)
1383 goto out;
1384
71449f8d 1385 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1386 memset(wl->bssid, 0, ETH_ALEN);
14b228a0
JO		 1387
1388 /* stop filterting packets based on bssid */
1389 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1390
1391out:
1392 return ret;
1393}
1394
ebba60c6
JO		 1395static void wl1271_set_band_rate(struct wl1271 *wl)
1396{
1397 if (wl->band == IEEE80211_BAND_2GHZ)
1398 wl->basic_rate_set = wl->conf.tx.basic_rate;
1399 else
1400 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1401}
1402
bee0ffec 1403static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 1404{
1405 int ret;
1406
1407 if (idle) {
1408 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1409 ret = wl1271_unjoin(wl);
1410 if (ret < 0)
1411 goto out;
1412 }
e0fe371b 1413 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 1414 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 1415 if (ret < 0)
1416 goto out;
1417 ret = wl1271_acx_keep_alive_config(
1418 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1419 ACX_KEEP_ALIVE_TPL_INVALID);
1420 if (ret < 0)
1421 goto out;
1422 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1423 } else {
1424 /* increment the session counter */
1425 wl->session_counter++;
1426 if (wl->session_counter >= SESSION_COUNTER_MAX)
1427 wl->session_counter = 0;
1428 ret = wl1271_dummy_join(wl);
1429 if (ret < 0)
1430 goto out;
1431 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1432 }
1433
1434out:
1435 return ret;
1436}
1437
f5fc0f86
LC		 1438static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1439{
1440 struct wl1271 *wl = hw->priv;
1441 struct ieee80211_conf *conf = &hw->conf;
1442 int channel, ret = 0;
bee0ffec 1443 bool is_ap;
f5fc0f86
LC		 1444
1445 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1446
bee0ffec
AN		 1447 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1448 " changed 0x%x",
f5fc0f86
LC		 1449 channel,
1450 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 1451 conf->power_level,
bee0ffec
AN		 1452 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1453 changed);
f5fc0f86 1454
781608c4
JO		 1455 /*
1456 * mac80211 will go to idle nearly immediately after transmitting some
1457 * frames, such as the deauth. To make sure those frames reach the air,
1458 * wait here until the TX queue is fully flushed.
1459 */
1460 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1461 (conf->flags & IEEE80211_CONF_IDLE))
1462 wl1271_tx_flush(wl);
1463
f5fc0f86
LC		 1464 mutex_lock(&wl->mutex);
1465
f8d9802f
JO		 1466 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1467 ret = -EAGAIN;
2c10bb9c 1468 goto out;
f8d9802f 1469 }
8a5a37a6 1470
bee0ffec
AN		 1471 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1472
f5fc0f86
LC		 1473 ret = wl1271_ps_elp_wakeup(wl, false);
1474 if (ret < 0)
1475 goto out;
1476
ebba60c6 1477 /* if the channel changes while joined, join again */
69e5434c
JO		 1478 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1479 ((wl->band != conf->channel->band) ||
1480 (wl->channel != channel))) {
ebba60c6
JO		 1481 wl->band = conf->channel->band;
1482 wl->channel = channel;
1483
bee0ffec
AN		 1484 if (!is_ap) {
1485 /*
1486 * FIXME: the mac80211 should really provide a fixed
1487 * rate to use here. for now, just use the smallest
1488 * possible rate for the band as a fixed rate for
1489 * association frames and other control messages.
1490 */
1491 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1492 wl1271_set_band_rate(wl);
1493
1494 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1495 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 1496 if (ret < 0)
bee0ffec 1497 wl1271_warning("rate policy for channel "
ebba60c6 1498 "failed %d", ret);
bee0ffec
AN		 1499
1500 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1501 ret = wl1271_join(wl, false);
1502 if (ret < 0)
1503 wl1271_warning("cmd join on channel "
1504 "failed %d", ret);
1505 }
ebba60c6
JO		 1506 }
1507 }
1508
bee0ffec
AN		 1509 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1510 ret = wl1271_sta_handle_idle(wl,
1511 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 1512 if (ret < 0)
1513 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1514 }
1515
90494a90
JO		 1516 /*
1517 * if mac80211 changes the PSM mode, make sure the mode is not
1518 * incorrectly changed after the pspoll failure active window.
1519 */
1520 if (changed & IEEE80211_CONF_CHANGE_PS)
1521 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1522
71449f8d
JO		 1523 if (conf->flags & IEEE80211_CONF_PS &&
1524 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1525 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1526
1527 /*
1528 * We enter PSM only if we're already associated.
1529 * If we're not, we'll enter it when joining an SSID,
1530 * through the bss_info_changed() hook.
1531 */
830fb67b 1532 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1533 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1534 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 1535 wl->basic_rate, true);
af5e084b 1536 }
f5fc0f86 1537 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1538 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1539 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1540
71449f8d 1541 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1542
71449f8d 1543 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1544 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 1545 wl->basic_rate, true);
f5fc0f86
LC		 1546 }
1547
1548 if (conf->power_level != wl->power_level) {
1549 ret = wl1271_acx_tx_power(wl, conf->power_level);
1550 if (ret < 0)
c6317a54 1551 goto out_sleep;
f5fc0f86
LC		 1552
1553 wl->power_level = conf->power_level;
1554 }
1555
1556out_sleep:
1557 wl1271_ps_elp_sleep(wl);
1558
1559out:
1560 mutex_unlock(&wl->mutex);
1561
1562 return ret;
1563}
1564
b54853f1
JO		 1565struct wl1271_filter_params {
1566 bool enabled;
1567 int mc_list_length;
1568 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1569};
1570
22bedad3
JP		 1571static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1572 struct netdev_hw_addr_list *mc_list)
c87dec9f 1573{
c87dec9f 1574 struct wl1271_filter_params *fp;
22bedad3 1575 struct netdev_hw_addr *ha;
2c10bb9c 1576 struct wl1271 *wl = hw->priv;
c87dec9f 1577
2c10bb9c
SD		 1578 if (unlikely(wl->state == WL1271_STATE_OFF))
1579 return 0;
c87dec9f 1580
74441130 1581 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1582 if (!fp) {
1583 wl1271_error("Out of memory setting filters.");
1584 return 0;
1585 }
1586
1587 /* update multicast filtering parameters */
c87dec9f 1588 fp->mc_list_length = 0;
22bedad3
JP		 1589 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1590 fp->enabled = false;
1591 } else {
1592 fp->enabled = true;
1593 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1594 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1595 ha->addr, ETH_ALEN);
c87dec9f 1596 fp->mc_list_length++;
22bedad3 1597 }
c87dec9f
JO		 1598 }
1599
b54853f1 1600 return (u64)(unsigned long)fp;
c87dec9f 1601}
f5fc0f86 1602
b54853f1
JO		 1603#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1604 FIF_ALLMULTI | \
1605 FIF_FCSFAIL | \
1606 FIF_BCN_PRBRESP_PROMISC | \
1607 FIF_CONTROL | \
1608 FIF_OTHER_BSS)
1609
f5fc0f86
LC		 1610static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1611 unsigned int changed,
c87dec9f 1612 unsigned int *total, u64 multicast)
f5fc0f86 1613{
b54853f1 1614 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 1615 struct wl1271 *wl = hw->priv;
b54853f1 1616 int ret;
f5fc0f86 1617
7d057869
AN		 1618 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
1619 " total %x", changed, *total);
f5fc0f86 1620
b54853f1
JO		 1621 mutex_lock(&wl->mutex);
1622
2c10bb9c
SD		 1623 *total &= WL1271_SUPPORTED_FILTERS;
1624 changed &= WL1271_SUPPORTED_FILTERS;
1625
1626 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 1627 goto out;
1628
1629 ret = wl1271_ps_elp_wakeup(wl, false);
1630 if (ret < 0)
1631 goto out;
1632
7d057869
AN		 1633 if (wl->bss_type != BSS_TYPE_AP_BSS) {
1634 if (*total & FIF_ALLMULTI)
1635 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
1636 else if (fp)
1637 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
1638 fp->mc_list,
1639 fp->mc_list_length);
1640 if (ret < 0)
1641 goto out_sleep;
1642 }
f5fc0f86 1643
b54853f1
JO		 1644 /* determine, whether supported filter values have changed */
1645 if (changed == 0)
1646 goto out_sleep;
c87dec9f 1647
14b228a0
JO		 1648 /* configure filters */
1649 wl->filters = *total;
1650 wl1271_configure_filters(wl, 0);
1651
b54853f1
JO		 1652 /* apply configured filters */
1653 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
1654 if (ret < 0)
1655 goto out_sleep;
1656
1657out_sleep:
1658 wl1271_ps_elp_sleep(wl);
1659
1660out:
1661 mutex_unlock(&wl->mutex);
14b228a0 1662 kfree(fp);
f5fc0f86
LC		 1663}
1664
7f179b46
AN		 1665static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
1666 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
1667 u16 tx_seq_16)
1668{
1669 struct wl1271_ap_key *ap_key;
1670 int i;
1671
1672 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
1673
1674 if (key_size > MAX_KEY_SIZE)
1675 return -EINVAL;
1676
1677 /*
1678 * Find next free entry in ap_keys. Also check we are not replacing
1679 * an existing key.
1680 */
1681 for (i = 0; i < MAX_NUM_KEYS; i++) {
1682 if (wl->recorded_ap_keys[i] == NULL)
1683 break;
1684
1685 if (wl->recorded_ap_keys[i]->id == id) {
1686 wl1271_warning("trying to record key replacement");
1687 return -EINVAL;
1688 }
1689 }
1690
1691 if (i == MAX_NUM_KEYS)
1692 return -EBUSY;
1693
1694 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
1695 if (!ap_key)
1696 return -ENOMEM;
1697
1698 ap_key->id = id;
1699 ap_key->key_type = key_type;
1700 ap_key->key_size = key_size;
1701 memcpy(ap_key->key, key, key_size);
1702 ap_key->hlid = hlid;
1703 ap_key->tx_seq_32 = tx_seq_32;
1704 ap_key->tx_seq_16 = tx_seq_16;
1705
1706 wl->recorded_ap_keys[i] = ap_key;
1707 return 0;
1708}
1709
1710static void wl1271_free_ap_keys(struct wl1271 *wl)
1711{
1712 int i;
1713
1714 for (i = 0; i < MAX_NUM_KEYS; i++) {
1715 kfree(wl->recorded_ap_keys[i]);
1716 wl->recorded_ap_keys[i] = NULL;
1717 }
1718}
1719
1720static int wl1271_ap_init_hwenc(struct wl1271 *wl)
1721{
1722 int i, ret = 0;
1723 struct wl1271_ap_key *key;
1724 bool wep_key_added = false;
1725
1726 for (i = 0; i < MAX_NUM_KEYS; i++) {
1727 if (wl->recorded_ap_keys[i] == NULL)
1728 break;
1729
1730 key = wl->recorded_ap_keys[i];
1731 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
1732 key->id, key->key_type,
1733 key->key_size, key->key,
1734 key->hlid, key->tx_seq_32,
1735 key->tx_seq_16);
1736 if (ret < 0)
1737 goto out;
1738
1739 if (key->key_type == KEY_WEP)
1740 wep_key_added = true;
1741 }
1742
1743 if (wep_key_added) {
1744 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
1745 if (ret < 0)
1746 goto out;
1747 }
1748
1749out:
1750 wl1271_free_ap_keys(wl);
1751 return ret;
1752}
1753
1754static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
1755 u8 key_size, const u8 *key, u32 tx_seq_32,
1756 u16 tx_seq_16, struct ieee80211_sta *sta)
1757{
1758 int ret;
1759 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1760
1761 if (is_ap) {
1762 struct wl1271_station *wl_sta;
1763 u8 hlid;
1764
1765 if (sta) {
1766 wl_sta = (struct wl1271_station *)sta->drv_priv;
1767 hlid = wl_sta->hlid;
1768 } else {
1769 hlid = WL1271_AP_BROADCAST_HLID;
1770 }
1771
1772 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
1773 /*
1774 * We do not support removing keys after AP shutdown.
1775 * Pretend we do to make mac80211 happy.
1776 */
1777 if (action != KEY_ADD_OR_REPLACE)
1778 return 0;
1779
1780 ret = wl1271_record_ap_key(wl, id,
1781 key_type, key_size,
1782 key, hlid, tx_seq_32,
1783 tx_seq_16);
1784 } else {
1785 ret = wl1271_cmd_set_ap_key(wl, action,
1786 id, key_type, key_size,
1787 key, hlid, tx_seq_32,
1788 tx_seq_16);
1789 }
1790
1791 if (ret < 0)
1792 return ret;
1793 } else {
1794 const u8 *addr;
1795 static const u8 bcast_addr[ETH_ALEN] = {
1796 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
1797 };
1798
1799 addr = sta ? sta->addr : bcast_addr;
1800
1801 if (is_zero_ether_addr(addr)) {
1802 /* We dont support TX only encryption */
1803 return -EOPNOTSUPP;
1804 }
1805
1806 /* The wl1271 does not allow to remove unicast keys - they
1807 will be cleared automatically on next CMD_JOIN. Ignore the
1808 request silently, as we dont want the mac80211 to emit
1809 an error message. */
1810 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
1811 return 0;
1812
1813 ret = wl1271_cmd_set_sta_key(wl, action,
1814 id, key_type, key_size,
1815 key, addr, tx_seq_32,
1816 tx_seq_16);
1817 if (ret < 0)
1818 return ret;
1819
1820 /* the default WEP key needs to be configured at least once */
1821 if (key_type == KEY_WEP) {
1822 ret = wl1271_cmd_set_sta_default_wep_key(wl,
1823 wl->default_key);
1824 if (ret < 0)
1825 return ret;
1826 }
1827 }
1828
1829 return 0;
1830}
1831
f5fc0f86
LC		 1832static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1833 struct ieee80211_vif *vif,
1834 struct ieee80211_sta *sta,
1835 struct ieee80211_key_conf *key_conf)
1836{
1837 struct wl1271 *wl = hw->priv;
f5fc0f86 1838 int ret;
ac4e4ce5
JO		 1839 u32 tx_seq_32 = 0;
1840 u16 tx_seq_16 = 0;
f5fc0f86
LC		 1841 u8 key_type;
1842
f5fc0f86
LC		 1843 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
1844
7f179b46 1845 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 1846 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 1847 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 1848 key_conf->keylen, key_conf->flags);
1849 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
1850
f5fc0f86
LC		 1851 mutex_lock(&wl->mutex);
1852
f8d9802f
JO		 1853 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1854 ret = -EAGAIN;
1855 goto out_unlock;
1856 }
1857
f5fc0f86
LC		 1858 ret = wl1271_ps_elp_wakeup(wl, false);
1859 if (ret < 0)
1860 goto out_unlock;
1861
97359d12
JB		 1862 switch (key_conf->cipher) {
1863 case WLAN_CIPHER_SUITE_WEP40:
1864 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 1865 key_type = KEY_WEP;
1866
1867 key_conf->hw_key_idx = key_conf->keyidx;
1868 break;
97359d12 1869 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 1870 key_type = KEY_TKIP;
1871
1872 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 1873 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1874 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1875 break;
97359d12 1876 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 1877 key_type = KEY_AES;
1878
1879 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 1880 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1881 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 1882 break;
7a55724e
JO		 1883 case WL1271_CIPHER_SUITE_GEM:
1884 key_type = KEY_GEM;
1885 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
1886 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
1887 break;
f5fc0f86 1888 default:
97359d12 1889 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 1890
1891 ret = -EOPNOTSUPP;
1892 goto out_sleep;
1893 }
1894
1895 switch (cmd) {
1896 case SET_KEY:
7f179b46
AN		 1897 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
1898 key_conf->keyidx, key_type,
1899 key_conf->keylen, key_conf->key,
1900 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 1901 if (ret < 0) {
1902 wl1271_error("Could not add or replace key");
1903 goto out_sleep;
1904 }
1905 break;
1906
1907 case DISABLE_KEY:
7f179b46
AN		 1908 ret = wl1271_set_key(wl, KEY_REMOVE,
1909 key_conf->keyidx, key_type,
1910 key_conf->keylen, key_conf->key,
1911 0, 0, sta);
f5fc0f86
LC		 1912 if (ret < 0) {
1913 wl1271_error("Could not remove key");
1914 goto out_sleep;
1915 }
1916 break;
1917
1918 default:
1919 wl1271_error("Unsupported key cmd 0x%x", cmd);
1920 ret = -EOPNOTSUPP;
f5fc0f86
LC		 1921 break;
1922 }
1923
1924out_sleep:
1925 wl1271_ps_elp_sleep(wl);
1926
1927out_unlock:
1928 mutex_unlock(&wl->mutex);
1929
f5fc0f86
LC		 1930 return ret;
1931}
1932
1933static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 1934 struct ieee80211_vif *vif,
f5fc0f86
LC		 1935 struct cfg80211_scan_request *req)
1936{
1937 struct wl1271 *wl = hw->priv;
1938 int ret;
1939 u8 *ssid = NULL;
abb0b3bf 1940 size_t len = 0;
f5fc0f86
LC		 1941
1942 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
1943
1944 if (req->n_ssids) {
1945 ssid = req->ssids[0].ssid;
abb0b3bf 1946 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 1947 }
1948
1949 mutex_lock(&wl->mutex);
1950
b739a42c
JO		 1951 if (wl->state == WL1271_STATE_OFF) {
1952 /*
1953 * We cannot return -EBUSY here because cfg80211 will expect
1954 * a call to ieee80211_scan_completed if we do - in this case
1955 * there won't be any call.
1956 */
1957 ret = -EAGAIN;
1958 goto out;
1959 }
1960
f5fc0f86
LC		 1961 ret = wl1271_ps_elp_wakeup(wl, false);
1962 if (ret < 0)
1963 goto out;
1964
5924f89d 1965 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 1966
1967 wl1271_ps_elp_sleep(wl);
1968
1969out:
1970 mutex_unlock(&wl->mutex);
1971
1972 return ret;
1973}
1974
68d069c4
AN		 1975static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
1976{
1977 struct wl1271 *wl = hw->priv;
1978 int ret = 0;
1979
1980 mutex_lock(&wl->mutex);
1981
1982 if (unlikely(wl->state == WL1271_STATE_OFF)) {
1983 ret = -EAGAIN;
1984 goto out;
1985 }
1986
1987 ret = wl1271_ps_elp_wakeup(wl, false);
1988 if (ret < 0)
1989 goto out;
1990
1991 ret = wl1271_acx_frag_threshold(wl, (u16)value);
1992 if (ret < 0)
1993 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
1994
1995 wl1271_ps_elp_sleep(wl);
1996
1997out:
1998 mutex_unlock(&wl->mutex);
1999
2000 return ret;
2001}
2002
f5fc0f86
LC		 2003static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2004{
2005 struct wl1271 *wl = hw->priv;
aecb0565 2006 int ret = 0;
f5fc0f86
LC		 2007
2008 mutex_lock(&wl->mutex);
2009
f8d9802f
JO		 2010 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2011 ret = -EAGAIN;
aecb0565 2012 goto out;
f8d9802f 2013 }
aecb0565 2014
f5fc0f86
LC		 2015 ret = wl1271_ps_elp_wakeup(wl, false);
2016 if (ret < 0)
2017 goto out;
2018
2019 ret = wl1271_acx_rts_threshold(wl, (u16) value);
2020 if (ret < 0)
2021 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2022
2023 wl1271_ps_elp_sleep(wl);
2024
2025out:
2026 mutex_unlock(&wl->mutex);
2027
2028 return ret;
2029}
2030
e78a287a 2031static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2032 int offset)
30240fc7 2033{
2f6724b2 2034 u8 *ptr = skb->data + offset;
30240fc7
JO		 2035
2036 /* find the location of the ssid in the beacon */
2f6724b2 2037 while (ptr < skb->data + skb->len) {
30240fc7
JO		 2038 if (ptr[0] == WLAN_EID_SSID) {
2039 wl->ssid_len = ptr[1];
2040 memcpy(wl->ssid, ptr+2, wl->ssid_len);
e78a287a 2041 return 0;
30240fc7 2042 }
2f6724b2 2043 ptr += (ptr[1] + 2);
30240fc7 2044 }
e78a287a 2045
2f6724b2 2046 wl1271_error("No SSID in IEs!\n");
e78a287a 2047 return -ENOENT;
30240fc7
JO		 2048}
2049
e78a287a 2050static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2051 struct ieee80211_bss_conf *bss_conf,
2052 u32 changed)
2053{
e78a287a 2054 int ret = 0;
f5fc0f86 2055
e78a287a
AN		 2056 if (changed & BSS_CHANGED_ERP_SLOT) {
2057 if (bss_conf->use_short_slot)
2058 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2059 else
2060 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2061 if (ret < 0) {
2062 wl1271_warning("Set slot time failed %d", ret);
2063 goto out;
2064 }
2065 }
f5fc0f86 2066
e78a287a
AN		 2067 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2068 if (bss_conf->use_short_preamble)
2069 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2070 else
2071 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2072 }
f5fc0f86 2073
e78a287a
AN		 2074 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2075 if (bss_conf->use_cts_prot)
2076 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2077 else
2078 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2079 if (ret < 0) {
2080 wl1271_warning("Set ctsprotect failed %d", ret);
2081 goto out;
2082 }
2083 }
f8d9802f 2084
e78a287a
AN		 2085out:
2086 return ret;
2087}
f5fc0f86 2088
e78a287a
AN		 2089static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2090 struct ieee80211_vif *vif,
2091 struct ieee80211_bss_conf *bss_conf,
2092 u32 changed)
2093{
2094 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2095 int ret = 0;
2096
2097 if ((changed & BSS_CHANGED_BEACON_INT)) {
2098 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 2099 bss_conf->beacon_int);
2100
2101 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 2102 }
2103
e78a287a
AN		 2104 if ((changed & BSS_CHANGED_BEACON)) {
2105 struct ieee80211_hdr *hdr;
2106 int ieoffset = offsetof(struct ieee80211_mgmt,
2107 u.beacon.variable);
2108 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2109 u16 tmpl_id;
2110
2111 if (!beacon)
2112 goto out;
2113
2114 wl1271_debug(DEBUG_MASTER, "beacon updated");
2115
2116 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2117 if (ret < 0) {
2118 dev_kfree_skb(beacon);
2119 goto out;
2120 }
2121 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2122 CMD_TEMPL_BEACON;
2123 ret = wl1271_cmd_template_set(wl, tmpl_id,
2124 beacon->data,
2125 beacon->len, 0,
2126 wl1271_tx_min_rate_get(wl));
2127 if (ret < 0) {
2128 dev_kfree_skb(beacon);
2129 goto out;
2130 }
2131
2132 hdr = (struct ieee80211_hdr *) beacon->data;
2133 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2134 IEEE80211_STYPE_PROBE_RESP);
2135
2136 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2137 CMD_TEMPL_PROBE_RESPONSE;
2138 ret = wl1271_cmd_template_set(wl,
2139 tmpl_id,
2140 beacon->data,
2141 beacon->len, 0,
2142 wl1271_tx_min_rate_get(wl));
2143 dev_kfree_skb(beacon);
2144 if (ret < 0)
2145 goto out;
2146 }
2147
2148out:
2149 return ret;
2150}
2151
2152/* AP mode changes */
2153static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2154 struct ieee80211_vif *vif,
2155 struct ieee80211_bss_conf *bss_conf,
2156 u32 changed)
2157{
2158 int ret = 0;
e0d8bbf0 2159
e78a287a
AN		 2160 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2161 u32 rates = bss_conf->basic_rates;
2162 struct conf_tx_rate_class mgmt_rc;
5da11dcd 2163
e78a287a
AN		 2164 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2165 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2166 wl1271_debug(DEBUG_AP, "basic rates: 0x%x",
2167 wl->basic_rate_set);
2168
2169 /* update the AP management rate policy with the new rates */
2170 mgmt_rc.enabled_rates = wl->basic_rate_set;
2171 mgmt_rc.long_retry_limit = 10;
2172 mgmt_rc.short_retry_limit = 10;
2173 mgmt_rc.aflags = 0;
2174 ret = wl1271_acx_ap_rate_policy(wl, &mgmt_rc,
2175 ACX_TX_AP_MODE_MGMT_RATE);
2176 if (ret < 0) {
2177 wl1271_error("AP mgmt policy change failed %d", ret);
2178 goto out;
2179 }
2180 }
2f6724b2 2181
e78a287a
AN		 2182 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2183 if (ret < 0)
2184 goto out;
30240fc7 2185
e78a287a
AN		 2186 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2187 if (bss_conf->enable_beacon) {
2188 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2189 ret = wl1271_cmd_start_bss(wl);
2190 if (ret < 0)
2191 goto out;
e0d8bbf0 2192
e78a287a
AN		 2193 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2194 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 2195
2196 ret = wl1271_ap_init_hwenc(wl);
2197 if (ret < 0)
2198 goto out;
e0d8bbf0 2199 }
e78a287a
AN		 2200 } else {
2201 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2202 ret = wl1271_cmd_stop_bss(wl);
2203 if (ret < 0)
2204 goto out;
e0d8bbf0 2205
e78a287a
AN		 2206 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2207 wl1271_debug(DEBUG_AP, "stopped AP");
2208 }
2209 }
2210 }
e0d8bbf0 2211
e78a287a
AN		 2212 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2213 if (ret < 0)
2214 goto out;
2215out:
2216 return;
2217}
8bf29b0e 2218
e78a287a
AN		 2219/* STA/IBSS mode changes */
2220static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2221 struct ieee80211_vif *vif,
2222 struct ieee80211_bss_conf *bss_conf,
2223 u32 changed)
2224{
2225 bool do_join = false, set_assoc = false;
2226 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 2227 u32 sta_rate_set = 0;
e78a287a 2228 int ret;
2d6e4e76 2229 struct ieee80211_sta *sta;
a100885d
AN		 2230 bool sta_exists = false;
2231 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 2232
2233 if (is_ibss) {
2234 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2235 changed);
2236 if (ret < 0)
2237 goto out;
e0d8bbf0
JO		 2238 }
2239
e78a287a
AN		 2240 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2241 do_join = true;
2242
2243 /* Need to update the SSID (for filtering etc) */
2244 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2245 do_join = true;
2246
2247 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 2248 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2249 bss_conf->enable_beacon ? "enabled" : "disabled");
2250
2251 if (bss_conf->enable_beacon)
2252 wl->set_bss_type = BSS_TYPE_IBSS;
2253 else
2254 wl->set_bss_type = BSS_TYPE_STA_BSS;
2255 do_join = true;
2256 }
2257
e78a287a 2258 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 2259 bool enable = false;
2260 if (bss_conf->cqm_rssi_thold)
2261 enable = true;
2262 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2263 bss_conf->cqm_rssi_thold,
2264 bss_conf->cqm_rssi_hyst);
2265 if (ret < 0)
2266 goto out;
2267 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2268 }
2269
30240fc7
JO		 2270 if ((changed & BSS_CHANGED_BSSID) &&
2271 /*
2272 * Now we know the correct bssid, so we send a new join command
2273 * and enable the BSSID filter
2274 */
2275 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 2276 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 2277
fa287b8f
EP		 2278 if (!is_zero_ether_addr(wl->bssid)) {
2279 ret = wl1271_cmd_build_null_data(wl);
2280 if (ret < 0)
2281 goto out;
30240fc7 2282
fa287b8f
EP		 2283 ret = wl1271_build_qos_null_data(wl);
2284 if (ret < 0)
2285 goto out;
30240fc7 2286
fa287b8f
EP		 2287 /* filter out all packets not from this BSSID */
2288 wl1271_configure_filters(wl, 0);
14b228a0 2289
fa287b8f
EP		 2290 /* Need to update the BSSID (for filtering etc) */
2291 do_join = true;
2292 }
30240fc7
JO		 2293 }
2294
72c2d9e5
EP		 2295 rcu_read_lock();
2296 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2297 if (sta) {
2298 /* save the supp_rates of the ap */
2299 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2300 if (sta->ht_cap.ht_supported)
2301 sta_rate_set |=
2302 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 2303 sta_ht_cap = sta->ht_cap;
2304 sta_exists = true;
2305 }
2306 rcu_read_unlock();
72c2d9e5 2307
a100885d 2308 if (sta_exists) {
72c2d9e5
EP		 2309 /* handle new association with HT and HT information change */
2310 if ((changed & BSS_CHANGED_HT) &&
2311 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 2312 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2313 true);
2314 if (ret < 0) {
2315 wl1271_warning("Set ht cap true failed %d",
2316 ret);
72c2d9e5
EP		 2317 goto out;
2318 }
2319 ret = wl1271_acx_set_ht_information(wl,
2320 bss_conf->ht_operation_mode);
2321 if (ret < 0) {
2322 wl1271_warning("Set ht information failed %d",
2323 ret);
72c2d9e5
EP		 2324 goto out;
2325 }
2326 }
2327 /* handle new association without HT and disassociation */
2328 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 2329 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2330 false);
2331 if (ret < 0) {
2332 wl1271_warning("Set ht cap false failed %d",
2333 ret);
72c2d9e5
EP		 2334 goto out;
2335 }
2336 }
2337 }
72c2d9e5 2338
e78a287a 2339 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 2340 if (bss_conf->assoc) {
ebba60c6 2341 u32 rates;
2f6724b2 2342 int ieoffset;
f5fc0f86 2343 wl->aid = bss_conf->aid;
69e5434c 2344 set_assoc = true;
f5fc0f86 2345
90494a90
JO		 2346 wl->ps_poll_failures = 0;
2347
ebba60c6
JO		 2348 /*
2349 * use basic rates from AP, and determine lowest rate
2350 * to use with control frames.
2351 */
2352 rates = bss_conf->basic_rates;
2353 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2354 rates);
e0fe371b 2355 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 2356 if (sta_rate_set)
2357 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2358 sta_rate_set);
79b223f4 2359 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2360 if (ret < 0)
e78a287a 2361 goto out;
ebba60c6 2362
ae751bab
LC		 2363 /*
2364 * with wl1271, we don't need to update the
2365 * beacon_int and dtim_period, because the firmware
2366 * updates it by itself when the first beacon is
2367 * received after a join.
2368 */
f5fc0f86
LC		 2369 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2370 if (ret < 0)
e78a287a 2371 goto out;
f5fc0f86 2372
c2b2d99b 2373 /*
2f6724b2 2374 * Get a template for hardware connection maintenance
c2b2d99b 2375 */
2f6724b2
JO		 2376 dev_kfree_skb(wl->probereq);
2377 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2378 ieoffset = offsetof(struct ieee80211_mgmt,
2379 u.probe_req.variable);
2380 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 2381
6ccbb92e
JO		 2382 /* enable the connection monitoring feature */
2383 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 2384 if (ret < 0)
e78a287a 2385 goto out;
f5fc0f86
LC		 2386
2387 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 2388 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2389 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 2390 enum wl1271_cmd_ps_mode mode;
2391
f5fc0f86 2392 mode = STATION_POWER_SAVE_MODE;
65cddbf1 2393 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 2394 wl->basic_rate,
65cddbf1 2395 true);
f5fc0f86 2396 if (ret < 0)
e78a287a 2397 goto out;
f5fc0f86 2398 }
d94cd297
JO		 2399 } else {
2400 /* use defaults when not associated */
c2c192ac 2401 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
830fb67b 2402 clear_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
d94cd297 2403 wl->aid = 0;
6ccbb92e 2404
2f6724b2
JO		 2405 /* free probe-request template */
2406 dev_kfree_skb(wl->probereq);
2407 wl->probereq = NULL;
2408
8d2ef7bd 2409 /* re-enable dynamic ps - just in case */
f532be6d 2410 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2411
ebba60c6
JO		 2412 /* revert back to minimum rates for the current band */
2413 wl1271_set_band_rate(wl);
e0fe371b 2414 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 2415 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2416 if (ret < 0)
e78a287a 2417 goto out;
ebba60c6 2418
6ccbb92e
JO		 2419 /* disable connection monitor features */
2420 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2421
2422 /* Disable the keep-alive feature */
2423 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 2424 if (ret < 0)
e78a287a 2425 goto out;
b84a7d3d
JO		 2426
2427 /* restore the bssid filter and go to dummy bssid */
2428 wl1271_unjoin(wl);
2429 wl1271_dummy_join(wl);
f5fc0f86 2430 }
f5fc0f86
LC		 2431 }
2432
e78a287a
AN		 2433 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2434 if (ret < 0)
2435 goto out;
f5fc0f86 2436
ca52a5eb
JO		 2437 if (changed & BSS_CHANGED_ARP_FILTER) {
2438 __be32 addr = bss_conf->arp_addr_list[0];
2439 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2440
c5312772
EP		 2441 if (bss_conf->arp_addr_cnt == 1 &&
2442 bss_conf->arp_filter_enabled) {
2443 /*
2444 * The template should have been configured only upon
2445 * association. however, it seems that the correct ip
2446 * isn't being set (when sending), so we have to
2447 * reconfigure the template upon every ip change.
2448 */
2449 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2450 if (ret < 0) {
2451 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 2452 goto out;
c5312772
EP		 2453 }
2454
2455 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 2456 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 2457 addr);
2458 } else
2459 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 2460
2461 if (ret < 0)
e78a287a 2462 goto out;
ca52a5eb
JO		 2463 }
2464
8bf29b0e 2465 if (do_join) {
69e5434c 2466 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2467 if (ret < 0) {
2468 wl1271_warning("cmd join failed %d", ret);
e78a287a 2469 goto out;
8bf29b0e 2470 }
c1899554
JO		 2471 }
2472
e78a287a
AN		 2473out:
2474 return;
2475}
2476
2477static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2478 struct ieee80211_vif *vif,
2479 struct ieee80211_bss_conf *bss_conf,
2480 u32 changed)
2481{
2482 struct wl1271 *wl = hw->priv;
2483 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2484 int ret;
2485
2486 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2487 (int)changed);
2488
2489 mutex_lock(&wl->mutex);
2490
2491 if (unlikely(wl->state == WL1271_STATE_OFF))
2492 goto out;
2493
2494 ret = wl1271_ps_elp_wakeup(wl, false);
2495 if (ret < 0)
2496 goto out;
2497
2498 if (is_ap)
2499 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2500 else
2501 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2502
f5fc0f86
LC		 2503 wl1271_ps_elp_sleep(wl);
2504
2505out:
2506 mutex_unlock(&wl->mutex);
2507}
2508
c6999d83
KV		 2509static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2510 const struct ieee80211_tx_queue_params *params)
2511{
2512 struct wl1271 *wl = hw->priv;
4695dc91 2513 u8 ps_scheme;
488fc540 2514 int ret = 0;
c6999d83
KV		 2515
2516 mutex_lock(&wl->mutex);
2517
2518 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2519
4695dc91
KV		 2520 if (params->uapsd)
2521 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2522 else
2523 ps_scheme = CONF_PS_SCHEME_LEGACY;
2524
488fc540
AN		 2525 if (wl->state == WL1271_STATE_OFF) {
2526 /*
2527 * If the state is off, the parameters will be recorded and
2528 * configured on init. This happens in AP-mode.
2529 */
2530 struct conf_tx_ac_category *conf_ac =
2531 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2532 struct conf_tx_tid *conf_tid =
2533 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2534
2535 conf_ac->ac = wl1271_tx_get_queue(queue);
2536 conf_ac->cw_min = (u8)params->cw_min;
2537 conf_ac->cw_max = params->cw_max;
2538 conf_ac->aifsn = params->aifs;
2539 conf_ac->tx_op_limit = params->txop << 5;
2540
2541 conf_tid->queue_id = wl1271_tx_get_queue(queue);
2542 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
2543 conf_tid->tsid = wl1271_tx_get_queue(queue);
2544 conf_tid->ps_scheme = ps_scheme;
2545 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
2546 conf_tid->apsd_conf[0] = 0;
2547 conf_tid->apsd_conf[1] = 0;
2548 } else {
2549 ret = wl1271_ps_elp_wakeup(wl, false);
2550 if (ret < 0)
2551 goto out;
2552
2553 /*
2554 * the txop is confed in units of 32us by the mac80211,
2555 * we need us
2556 */
2557 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
2558 params->cw_min, params->cw_max,
2559 params->aifs, params->txop << 5);
2560 if (ret < 0)
2561 goto out_sleep;
2562
2563 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
2564 CONF_CHANNEL_TYPE_EDCF,
2565 wl1271_tx_get_queue(queue),
2566 ps_scheme, CONF_ACK_POLICY_LEGACY,
2567 0, 0);
2568 if (ret < 0)
2569 goto out_sleep;
c82c1dde
KV		 2570
2571out_sleep:
488fc540
AN		 2572 wl1271_ps_elp_sleep(wl);
2573 }
c6999d83
KV		 2574
2575out:
2576 mutex_unlock(&wl->mutex);
2577
2578 return ret;
2579}
2580
bbbb538e
JO		 2581static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
2582{
2583
2584 struct wl1271 *wl = hw->priv;
2585 u64 mactime = ULLONG_MAX;
2586 int ret;
2587
2588 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
2589
2590 mutex_lock(&wl->mutex);
2591
f8d9802f
JO		 2592 if (unlikely(wl->state == WL1271_STATE_OFF))
2593 goto out;
2594
bbbb538e
JO		 2595 ret = wl1271_ps_elp_wakeup(wl, false);
2596 if (ret < 0)
2597 goto out;
2598
2599 ret = wl1271_acx_tsf_info(wl, &mactime);
2600 if (ret < 0)
2601 goto out_sleep;
2602
2603out_sleep:
2604 wl1271_ps_elp_sleep(wl);
2605
2606out:
2607 mutex_unlock(&wl->mutex);
2608 return mactime;
2609}
f5fc0f86 2610
ece550d0
JL		 2611static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
2612 struct survey_info *survey)
2613{
2614 struct wl1271 *wl = hw->priv;
2615 struct ieee80211_conf *conf = &hw->conf;
b739a42c 2616
ece550d0
JL		 2617 if (idx != 0)
2618 return -ENOENT;
b739a42c 2619
ece550d0
JL		 2620 survey->channel = conf->channel;
2621 survey->filled = SURVEY_INFO_NOISE_DBM;
2622 survey->noise = wl->noise;
b739a42c 2623
ece550d0
JL		 2624 return 0;
2625}
2626
f84f7d78
AN		 2627static int wl1271_allocate_hlid(struct wl1271 *wl,
2628 struct ieee80211_sta *sta,
2629 u8 *hlid)
2630{
2631 struct wl1271_station *wl_sta;
2632 int id;
2633
2634 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
2635 if (id >= AP_MAX_STATIONS) {
2636 wl1271_warning("could not allocate HLID - too much stations");
2637 return -EBUSY;
2638 }
2639
2640 wl_sta = (struct wl1271_station *)sta->drv_priv;
2641
2642 __set_bit(id, wl->ap_hlid_map);
2643 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
2644 *hlid = wl_sta->hlid;
2645 return 0;
2646}
2647
2648static void wl1271_free_hlid(struct wl1271 *wl, u8 hlid)
2649{
2650 int id = hlid - WL1271_AP_STA_HLID_START;
2651
2652 __clear_bit(id, wl->ap_hlid_map);
a8c0ddb5 2653 wl1271_tx_reset_link_queues(wl, hlid);
f84f7d78
AN		 2654}
2655
2656static int wl1271_op_sta_add(struct ieee80211_hw *hw,
2657 struct ieee80211_vif *vif,
2658 struct ieee80211_sta *sta)
2659{
2660 struct wl1271 *wl = hw->priv;
2661 int ret = 0;
2662 u8 hlid;
2663
2664 mutex_lock(&wl->mutex);
2665
2666 if (unlikely(wl->state == WL1271_STATE_OFF))
2667 goto out;
2668
2669 if (wl->bss_type != BSS_TYPE_AP_BSS)
2670 goto out;
2671
2672 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
2673
2674 ret = wl1271_allocate_hlid(wl, sta, &hlid);
2675 if (ret < 0)
2676 goto out;
2677
2678 ret = wl1271_ps_elp_wakeup(wl, false);
2679 if (ret < 0)
2680 goto out;
2681
2682 ret = wl1271_cmd_add_sta(wl, sta, hlid);
2683 if (ret < 0)
2684 goto out_sleep;
2685
2686out_sleep:
2687 wl1271_ps_elp_sleep(wl);
2688
2689out:
2690 mutex_unlock(&wl->mutex);
2691 return ret;
2692}
2693
2694static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
2695 struct ieee80211_vif *vif,
2696 struct ieee80211_sta *sta)
2697{
2698 struct wl1271 *wl = hw->priv;
2699 struct wl1271_station *wl_sta;
2700 int ret = 0, id;
2701
2702 mutex_lock(&wl->mutex);
2703
2704 if (unlikely(wl->state == WL1271_STATE_OFF))
2705 goto out;
2706
2707 if (wl->bss_type != BSS_TYPE_AP_BSS)
2708 goto out;
2709
2710 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
2711
2712 wl_sta = (struct wl1271_station *)sta->drv_priv;
2713 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
2714 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
2715 goto out;
2716
2717 ret = wl1271_ps_elp_wakeup(wl, false);
2718 if (ret < 0)
2719 goto out;
2720
2721 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
2722 if (ret < 0)
2723 goto out_sleep;
2724
2725 wl1271_free_hlid(wl, wl_sta->hlid);
2726
2727out_sleep:
2728 wl1271_ps_elp_sleep(wl);
2729
2730out:
2731 mutex_unlock(&wl->mutex);
2732 return ret;
2733}
2734
bbba3e68 2735int wl1271_op_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
7c3ee9e3
LC		 2736 enum ieee80211_ampdu_mlme_action action,
2737 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2738 u8 buf_size)
bbba3e68
LS		 2739{
2740 struct wl1271 *wl = hw->priv;
2741 int ret;
2742
2743 mutex_lock(&wl->mutex);
2744
2745 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2746 ret = -EAGAIN;
2747 goto out;
2748 }
2749
2750 ret = wl1271_ps_elp_wakeup(wl, false);
2751 if (ret < 0)
2752 goto out;
2753
2754 switch (action) {
2755 case IEEE80211_AMPDU_RX_START:
2756 if (wl->ba_support) {
2757 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
2758 true);
2759 if (!ret)
2760 wl->ba_rx_bitmap |= BIT(tid);
2761 } else {
2762 ret = -ENOTSUPP;
2763 }
2764 break;
2765
2766 case IEEE80211_AMPDU_RX_STOP:
2767 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
2768 if (!ret)
2769 wl->ba_rx_bitmap &= ~BIT(tid);
2770 break;
2771
2772 /*
2773 * The BA initiator session management in FW independently.
2774 * Falling break here on purpose for all TX APDU commands.
2775 */
2776 case IEEE80211_AMPDU_TX_START:
2777 case IEEE80211_AMPDU_TX_STOP:
2778 case IEEE80211_AMPDU_TX_OPERATIONAL:
2779 ret = -EINVAL;
2780 break;
2781
2782 default:
2783 wl1271_error("Incorrect ampdu action id=%x\n", action);
2784 ret = -EINVAL;
2785 }
2786
2787 wl1271_ps_elp_sleep(wl);
2788
2789out:
2790 mutex_unlock(&wl->mutex);
2791
2792 return ret;
2793}
2794
f5fc0f86
LC		 2795/* can't be const, mac80211 writes to this */
2796static struct ieee80211_rate wl1271_rates[] = {
2797 { .bitrate = 10,
2b60100b
JO		 2798 .hw_value = CONF_HW_BIT_RATE_1MBPS,
2799 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 2800 { .bitrate = 20,
2b60100b
JO		 2801 .hw_value = CONF_HW_BIT_RATE_2MBPS,
2802 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 2803 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2804 { .bitrate = 55,
2b60100b
JO		 2805 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
2806 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 2807 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2808 { .bitrate = 110,
2b60100b
JO		 2809 .hw_value = CONF_HW_BIT_RATE_11MBPS,
2810 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 2811 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
2812 { .bitrate = 60,
2b60100b
JO		 2813 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2814 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 2815 { .bitrate = 90,
2b60100b
JO		 2816 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2817 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 2818 { .bitrate = 120,
2b60100b
JO		 2819 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2820 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 2821 { .bitrate = 180,
2b60100b
JO		 2822 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2823 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 2824 { .bitrate = 240,
2b60100b
JO		 2825 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2826 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 2827 { .bitrate = 360,
2b60100b
JO		 2828 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2829 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 2830 { .bitrate = 480,
2b60100b
JO		 2831 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2832 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 2833 { .bitrate = 540,
2b60100b
JO		 2834 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2835 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 2836};
2837
fa97f46b 2838/* can't be const, mac80211 writes to this */
f5fc0f86 2839static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 2840 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 2841 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 2842 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
2843 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
2844 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 2845 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 2846 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
2847 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
2848 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 2849 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 2850 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
2851 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
2852 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 2853 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 2854};
2855
f876bb9a 2856/* mapping to indexes for wl1271_rates */
a0ea9493 2857static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 2858 /* MCS rates are used only with 11n */
18357850
SL		 2859 7, /* CONF_HW_RXTX_RATE_MCS7 */
2860 6, /* CONF_HW_RXTX_RATE_MCS6 */
2861 5, /* CONF_HW_RXTX_RATE_MCS5 */
2862 4, /* CONF_HW_RXTX_RATE_MCS4 */
2863 3, /* CONF_HW_RXTX_RATE_MCS3 */
2864 2, /* CONF_HW_RXTX_RATE_MCS2 */
2865 1, /* CONF_HW_RXTX_RATE_MCS1 */
2866 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2867
2868 11, /* CONF_HW_RXTX_RATE_54 */
2869 10, /* CONF_HW_RXTX_RATE_48 */
2870 9, /* CONF_HW_RXTX_RATE_36 */
2871 8, /* CONF_HW_RXTX_RATE_24 */
2872
2873 /* TI-specific rate */
2874 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
2875
2876 7, /* CONF_HW_RXTX_RATE_18 */
2877 6, /* CONF_HW_RXTX_RATE_12 */
2878 3, /* CONF_HW_RXTX_RATE_11 */
2879 5, /* CONF_HW_RXTX_RATE_9 */
2880 4, /* CONF_HW_RXTX_RATE_6 */
2881 2, /* CONF_HW_RXTX_RATE_5_5 */
2882 1, /* CONF_HW_RXTX_RATE_2 */
2883 0 /* CONF_HW_RXTX_RATE_1 */
2884};
2885
e8b03a2b
SL		 2886/* 11n STA capabilities */
2887#define HW_RX_HIGHEST_RATE 72
2888
00d20100
SL		 2889#ifdef CONFIG_WL12XX_HT
2890#define WL12XX_HT_CAP { \
e8b03a2b
SL		 2891 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20, \
2892 .ht_supported = true, \
2893 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
2894 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
2895 .mcs = { \
2896 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
2897 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
2898 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
2899 }, \
2900}
18357850 2901#else
00d20100 2902#define WL12XX_HT_CAP { \
18357850
SL		 2903 .ht_supported = false, \
2904}
2905#endif
e8b03a2b 2906
f5fc0f86
LC		 2907/* can't be const, mac80211 writes to this */
2908static struct ieee80211_supported_band wl1271_band_2ghz = {
2909 .channels = wl1271_channels,
2910 .n_channels = ARRAY_SIZE(wl1271_channels),
2911 .bitrates = wl1271_rates,
2912 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 2913 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 2914};
2915
1ebec3d7
TP		 2916/* 5 GHz data rates for WL1273 */
2917static struct ieee80211_rate wl1271_rates_5ghz[] = {
2918 { .bitrate = 60,
2919 .hw_value = CONF_HW_BIT_RATE_6MBPS,
2920 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
2921 { .bitrate = 90,
2922 .hw_value = CONF_HW_BIT_RATE_9MBPS,
2923 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
2924 { .bitrate = 120,
2925 .hw_value = CONF_HW_BIT_RATE_12MBPS,
2926 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
2927 { .bitrate = 180,
2928 .hw_value = CONF_HW_BIT_RATE_18MBPS,
2929 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
2930 { .bitrate = 240,
2931 .hw_value = CONF_HW_BIT_RATE_24MBPS,
2932 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
2933 { .bitrate = 360,
2934 .hw_value = CONF_HW_BIT_RATE_36MBPS,
2935 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
2936 { .bitrate = 480,
2937 .hw_value = CONF_HW_BIT_RATE_48MBPS,
2938 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
2939 { .bitrate = 540,
2940 .hw_value = CONF_HW_BIT_RATE_54MBPS,
2941 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
2942};
2943
fa97f46b 2944/* 5 GHz band channels for WL1273 */
1ebec3d7 2945static struct ieee80211_channel wl1271_channels_5ghz[] = {
fa21c7a9 2946 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 2947 { .hw_value = 8, .center_freq = 5040},
2948 { .hw_value = 9, .center_freq = 5045},
2949 { .hw_value = 11, .center_freq = 5055},
2950 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 2951 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 2952 { .hw_value = 34, .center_freq = 5170},
2953 { .hw_value = 36, .center_freq = 5180},
2954 { .hw_value = 38, .center_freq = 5190},
2955 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 2956 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 2957 { .hw_value = 44, .center_freq = 5220},
2958 { .hw_value = 46, .center_freq = 5230},
2959 { .hw_value = 48, .center_freq = 5240},
2960 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 2961 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 2962 { .hw_value = 60, .center_freq = 5300},
2963 { .hw_value = 64, .center_freq = 5320},
2964 { .hw_value = 100, .center_freq = 5500},
2965 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 2966 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 2967 { .hw_value = 112, .center_freq = 5560},
2968 { .hw_value = 116, .center_freq = 5580},
2969 { .hw_value = 120, .center_freq = 5600},
2970 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 2971 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 2972 { .hw_value = 132, .center_freq = 5660},
2973 { .hw_value = 136, .center_freq = 5680},
2974 { .hw_value = 140, .center_freq = 5700},
2975 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 2976 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 2977 { .hw_value = 157, .center_freq = 5785},
2978 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 2979 { .hw_value = 165, .center_freq = 5825},
2980};
2981
f876bb9a 2982/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 2983static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 2984 /* MCS rates are used only with 11n */
18357850
SL		 2985 7, /* CONF_HW_RXTX_RATE_MCS7 */
2986 6, /* CONF_HW_RXTX_RATE_MCS6 */
2987 5, /* CONF_HW_RXTX_RATE_MCS5 */
2988 4, /* CONF_HW_RXTX_RATE_MCS4 */
2989 3, /* CONF_HW_RXTX_RATE_MCS3 */
2990 2, /* CONF_HW_RXTX_RATE_MCS2 */
2991 1, /* CONF_HW_RXTX_RATE_MCS1 */
2992 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 2993
2994 7, /* CONF_HW_RXTX_RATE_54 */
2995 6, /* CONF_HW_RXTX_RATE_48 */
2996 5, /* CONF_HW_RXTX_RATE_36 */
2997 4, /* CONF_HW_RXTX_RATE_24 */
2998
2999 /* TI-specific rate */
3000 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3001
3002 3, /* CONF_HW_RXTX_RATE_18 */
3003 2, /* CONF_HW_RXTX_RATE_12 */
3004 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3005 1, /* CONF_HW_RXTX_RATE_9 */
3006 0, /* CONF_HW_RXTX_RATE_6 */
3007 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3008 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3009 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3010};
1ebec3d7
TP		 3011
3012static struct ieee80211_supported_band wl1271_band_5ghz = {
3013 .channels = wl1271_channels_5ghz,
3014 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3015 .bitrates = wl1271_rates_5ghz,
3016 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 3017 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 3018};
3019
a0ea9493 3020static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 3021 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3022 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3023};
3024
f5fc0f86
LC		 3025static const struct ieee80211_ops wl1271_ops = {
3026 .start = wl1271_op_start,
3027 .stop = wl1271_op_stop,
3028 .add_interface = wl1271_op_add_interface,
3029 .remove_interface = wl1271_op_remove_interface,
3030 .config = wl1271_op_config,
c87dec9f 3031 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 3032 .configure_filter = wl1271_op_configure_filter,
3033 .tx = wl1271_op_tx,
3034 .set_key = wl1271_op_set_key,
3035 .hw_scan = wl1271_op_hw_scan,
3036 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 3037 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 3038 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 3039 .conf_tx = wl1271_op_conf_tx,
bbbb538e 3040 .get_tsf = wl1271_op_get_tsf,
ece550d0 3041 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 3042 .sta_add = wl1271_op_sta_add,
3043 .sta_remove = wl1271_op_sta_remove,
bbba3e68 3044 .ampdu_action = wl1271_op_ampdu_action,
c8c90873 3045 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 3046};
3047
f876bb9a 3048
6a2de93b 3049u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 3050{
3051 u8 idx;
3052
6a2de93b 3053 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 3054
3055 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3056 wl1271_error("Illegal RX rate from HW: %d", rate);
3057 return 0;
3058 }
3059
6a2de93b 3060 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 3061 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3062 wl1271_error("Unsupported RX rate from HW: %d", rate);
3063 return 0;
3064 }
3065
3066 return idx;
3067}
3068
7fc3a864
JO		 3069static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3070 struct device_attribute *attr,
3071 char *buf)
3072{
3073 struct wl1271 *wl = dev_get_drvdata(dev);
3074 ssize_t len;
3075
2f63b011 3076 len = PAGE_SIZE;
7fc3a864
JO		 3077
3078 mutex_lock(&wl->mutex);
3079 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3080 wl->sg_enabled);
3081 mutex_unlock(&wl->mutex);
3082
3083 return len;
3084
3085}
3086
3087static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3088 struct device_attribute *attr,
3089 const char *buf, size_t count)
3090{
3091 struct wl1271 *wl = dev_get_drvdata(dev);
3092 unsigned long res;
3093 int ret;
3094
3095 ret = strict_strtoul(buf, 10, &res);
3096
3097 if (ret < 0) {
3098 wl1271_warning("incorrect value written to bt_coex_mode");
3099 return count;
3100 }
3101
3102 mutex_lock(&wl->mutex);
3103
3104 res = !!res;
3105
3106 if (res == wl->sg_enabled)
3107 goto out;
3108
3109 wl->sg_enabled = res;
3110
3111 if (wl->state == WL1271_STATE_OFF)
3112 goto out;
3113
3114 ret = wl1271_ps_elp_wakeup(wl, false);
3115 if (ret < 0)
3116 goto out;
3117
3118 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3119 wl1271_ps_elp_sleep(wl);
3120
3121 out:
3122 mutex_unlock(&wl->mutex);
3123 return count;
3124}
3125
3126static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3127 wl1271_sysfs_show_bt_coex_state,
3128 wl1271_sysfs_store_bt_coex_state);
3129
d717fd61
JO		 3130static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3131 struct device_attribute *attr,
3132 char *buf)
3133{
3134 struct wl1271 *wl = dev_get_drvdata(dev);
3135 ssize_t len;
3136
2f63b011 3137 len = PAGE_SIZE;
d717fd61
JO		 3138
3139 mutex_lock(&wl->mutex);
3140 if (wl->hw_pg_ver >= 0)
3141 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3142 else
3143 len = snprintf(buf, len, "n/a\n");
3144 mutex_unlock(&wl->mutex);
3145
3146 return len;
3147}
3148
3149static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3150 wl1271_sysfs_show_hw_pg_ver, NULL);
3151
2d5e82b8 3152int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 3153{
3154 int ret;
3155
3156 if (wl->mac80211_registered)
3157 return 0;
3158
31d26ec6
AN		 3159 ret = wl1271_fetch_nvs(wl);
3160 if (ret == 0) {
3161 u8 *nvs_ptr = (u8 *)wl->nvs->nvs;
3162
3163 wl->mac_addr[0] = nvs_ptr[11];
3164 wl->mac_addr[1] = nvs_ptr[10];
3165 wl->mac_addr[2] = nvs_ptr[6];
3166 wl->mac_addr[3] = nvs_ptr[5];
3167 wl->mac_addr[4] = nvs_ptr[4];
3168 wl->mac_addr[5] = nvs_ptr[3];
3169 }
3170
f5fc0f86
LC		 3171 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3172
3173 ret = ieee80211_register_hw(wl->hw);
3174 if (ret < 0) {
3175 wl1271_error("unable to register mac80211 hw: %d", ret);
3176 return ret;
3177 }
3178
3179 wl->mac80211_registered = true;
3180
d60080ae
EP		 3181 wl1271_debugfs_init(wl);
3182
c2c192ac
JO		 3183 register_netdevice_notifier(&wl1271_dev_notifier);
3184
f5fc0f86
LC		 3185 wl1271_notice("loaded");
3186
3187 return 0;
3188}
50b3eb4b 3189EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 3190
3b56dd6a
TP		 3191void wl1271_unregister_hw(struct wl1271 *wl)
3192{
4ae3fa87
JO		 3193 if (wl->state == WL1271_STATE_PLT)
3194 __wl1271_plt_stop(wl);
3195
c2c192ac 3196 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 3197 ieee80211_unregister_hw(wl->hw);
3198 wl->mac80211_registered = false;
3199
3200}
3201EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3202
2d5e82b8 3203int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 3204{
7a55724e
JO		 3205 static const u32 cipher_suites[] = {
3206 WLAN_CIPHER_SUITE_WEP40,
3207 WLAN_CIPHER_SUITE_WEP104,
3208 WLAN_CIPHER_SUITE_TKIP,
3209 WLAN_CIPHER_SUITE_CCMP,
3210 WL1271_CIPHER_SUITE_GEM,
3211 };
3212
1e2b7976
JO		 3213 /* The tx descriptor buffer and the TKIP space. */
3214 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3215 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 3216
3217 /* unit us */
3218 /* FIXME: find a proper value */
3219 wl->hw->channel_change_time = 10000;
50c500ad 3220 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 3221
3222 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 3223 IEEE80211_HW_BEACON_FILTER |
0a34332f 3224 IEEE80211_HW_SUPPORTS_PS |
4695dc91 3225 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 3226 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 3227 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 3228 IEEE80211_HW_SUPPORTS_CQM_RSSI |
ba7c082a
AN		 3229 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3230 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 3231
7a55724e
JO		 3232 wl->hw->wiphy->cipher_suites = cipher_suites;
3233 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3234
e0d8bbf0 3235 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 3236 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 3237 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 3238 /*
3239 * Maximum length of elements in scanning probe request templates
3240 * should be the maximum length possible for a template, without
3241 * the IEEE80211 header of the template
3242 */
3243 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3244 sizeof(struct ieee80211_header);
a8aaaf53
LC		 3245
3246 /*
3247 * We keep local copies of the band structs because we need to
3248 * modify them on a per-device basis.
3249 */
3250 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3251 sizeof(wl1271_band_2ghz));
3252 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3253 sizeof(wl1271_band_5ghz));
3254
3255 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3256 &wl->bands[IEEE80211_BAND_2GHZ];
3257 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3258 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 3259
12bd8949 3260 wl->hw->queues = 4;
31627dc5 3261 wl->hw->max_rates = 1;
12bd8949 3262
b7417d93
JO		 3263 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3264
8197b711 3265 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 3266
f84f7d78
AN		 3267 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3268
4c9cfa78
LC		 3269 wl->hw->max_rx_aggregation_subframes = 8;
3270
f5fc0f86
LC		 3271 return 0;
3272}
50b3eb4b 3273EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 3274
f5fc0f86 3275#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 3276
2d5e82b8 3277struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 3278{
f5fc0f86 3279 struct ieee80211_hw *hw;
3b56dd6a 3280 struct platform_device *plat_dev = NULL;
f5fc0f86 3281 struct wl1271 *wl;
a8c0ddb5 3282 int i, j, ret;
1f37cbc9 3283 unsigned int order;
f5fc0f86
LC		 3284
3285 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3286 if (!hw) {
3287 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 3288 ret = -ENOMEM;
3b56dd6a
TP		 3289 goto err_hw_alloc;
3290 }
3291
929ebd30 3292 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 3293 if (!plat_dev) {
3294 wl1271_error("could not allocate platform_device");
3295 ret = -ENOMEM;
3296 goto err_plat_alloc;
f5fc0f86
LC		 3297 }
3298
3299 wl = hw->priv;
3300 memset(wl, 0, sizeof(*wl));
3301
01c09162
JO		 3302 INIT_LIST_HEAD(&wl->list);
3303
f5fc0f86 3304 wl->hw = hw;
3b56dd6a 3305 wl->plat_dev = plat_dev;
f5fc0f86 3306
6742f554
JO		 3307 for (i = 0; i < NUM_TX_QUEUES; i++)
3308 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 3309
a8c0ddb5
AN		 3310 for (i = 0; i < NUM_TX_QUEUES; i++)
3311 for (j = 0; j < AP_MAX_LINKS; j++)
3312 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3313
37b70a81 3314 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 3315 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
117b38d0
JO		 3316 INIT_WORK(&wl->irq_work, wl1271_irq_work);
3317 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3318 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3319 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 3320 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 3321 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 3322 wl->default_key = 0;
f5fc0f86 3323 wl->rx_counter = 0;
ae113b57
AN		 3324 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3325 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
19ad0715 3326 wl->psm_entry_retry = 0;
f5fc0f86 3327 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 3328 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 3329 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 3330 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 3331 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 3332 wl->vif = NULL;
830fb67b 3333 wl->flags = 0;
7fc3a864 3334 wl->sg_enabled = true;
d717fd61 3335 wl->hw_pg_ver = -1;
166d504e
AN		 3336 wl->bss_type = MAX_BSS_TYPE;
3337 wl->set_bss_type = MAX_BSS_TYPE;
3338 wl->fw_bss_type = MAX_BSS_TYPE;
a8c0ddb5 3339 wl->last_tx_hlid = 0;
f5fc0f86 3340
25eeb9e3 3341 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 3342 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 3343 wl->tx_frames[i] = NULL;
3344
3345 spin_lock_init(&wl->wl_lock);
3346
f5fc0f86
LC		 3347 wl->state = WL1271_STATE_OFF;
3348 mutex_init(&wl->mutex);
3349
c332a4b8
TP		 3350 /* Apply default driver configuration. */
3351 wl1271_conf_init(wl);
3352
1f37cbc9
IY		 3353 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3354 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3355 if (!wl->aggr_buf) {
3356 ret = -ENOMEM;
3357 goto err_hw;
3358 }
3359
a1dd8187 3360 /* Register platform device */
3b56dd6a 3361 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 3362 if (ret) {
3363 wl1271_error("couldn't register platform device");
1f37cbc9 3364 goto err_aggr;
a1dd8187 3365 }
3b56dd6a 3366 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 3367
7fc3a864 3368 /* Create sysfs file to control bt coex state */
3b56dd6a 3369 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 3370 if (ret < 0) {
3371 wl1271_error("failed to create sysfs file bt_coex_state");
3372 goto err_platform;
3373 }
a1dd8187 3374
d717fd61
JO		 3375 /* Create sysfs file to get HW PG version */
3376 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3377 if (ret < 0) {
3378 wl1271_error("failed to create sysfs file hw_pg_ver");
3379 goto err_bt_coex_state;
3380 }
3381
c332a4b8 3382 return hw;
a1dd8187 3383
d717fd61
JO		 3384err_bt_coex_state:
3385 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3386
7fc3a864 3387err_platform:
3b56dd6a 3388 platform_device_unregister(wl->plat_dev);
7fc3a864 3389
1f37cbc9
IY		 3390err_aggr:
3391 free_pages((unsigned long)wl->aggr_buf, order);
3392
a1dd8187 3393err_hw:
3b56dd6a
TP		 3394 wl1271_debugfs_exit(wl);
3395 kfree(plat_dev);
3396
3397err_plat_alloc:
3398 ieee80211_free_hw(hw);
3399
3400err_hw_alloc:
a1dd8187 3401
a1dd8187 3402 return ERR_PTR(ret);
c332a4b8 3403}
50b3eb4b 3404EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 3405
3406int wl1271_free_hw(struct wl1271 *wl)
3407{
3b56dd6a 3408 platform_device_unregister(wl->plat_dev);
1f37cbc9
IY		 3409 free_pages((unsigned long)wl->aggr_buf,
3410 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 3411 kfree(wl->plat_dev);
c332a4b8
TP		 3412
3413 wl1271_debugfs_exit(wl);
3414
c332a4b8
TP		 3415 vfree(wl->fw);
3416 wl->fw = NULL;
3417 kfree(wl->nvs);
3418 wl->nvs = NULL;
3419
3420 kfree(wl->fw_status);
3421 kfree(wl->tx_res_if);
3422
3423 ieee80211_free_hw(wl->hw);
3424
3425 return 0;
3426}
50b3eb4b
TP		 3427EXPORT_SYMBOL_GPL(wl1271_free_hw);
3428
491bbd6b 3429u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 3430EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 3431module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 3432MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3433
50b3eb4b 3434MODULE_LICENSE("GPL");
b1a48cab 3435MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 3436MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.46513 seconds and 5 git commands to generate.