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