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