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