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