projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: update acx commands
[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
418 ret = wl1271_cmd_set_sta_state(wl);
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;
d6e19d13 1985
13026dec
JO		 1986 /*
1987 * this is performed after the cancel_work calls and the associated
1988 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1989 * get executed before all these vars have been reset.
1990 */
1991 wl->flags = 0;
1992
4d56ad9c 1993 wl->tx_blocks_freed = 0;
f5fc0f86
LC		 1994
1995 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1996
1997 kfree(wl->fw_status);
1998 wl->fw_status = NULL;
1999 kfree(wl->tx_res_if);
2000 wl->tx_res_if = NULL;
2001 kfree(wl->target_mem_map);
2002 wl->target_mem_map = NULL;
52a2a375 2003}
bd9dc49c 2004
52a2a375
JO		 2005static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2006 struct ieee80211_vif *vif)
2007{
2008 struct wl1271 *wl = hw->priv;
2009
2010 mutex_lock(&wl->mutex);
67353299
JO		 2011 /*
2012 * wl->vif can be null here if someone shuts down the interface
2013 * just when hardware recovery has been started.
2014 */
2015 if (wl->vif) {
2016 WARN_ON(wl->vif != vif);
7dece1c8 2017 __wl1271_op_remove_interface(wl, true);
67353299 2018 }
52b0e7a6 2019
67353299 2020 mutex_unlock(&wl->mutex);
52b0e7a6 2021 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 2022}
2023
82429d32 2024static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 2025{
e0d8bbf0 2026 int ret = 0;
c7f43e45
LC		 2027 /* we need to use a dummy BSSID for now */
2028 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
2029 0xad, 0xbe, 0xef };
2030
c7f43e45
LC		 2031 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
2032
5da11dcd 2033 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 2034 if (ret < 0)
2035 goto out;
2036
71449f8d 2037 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 2038
2039out:
2040 return ret;
2041}
2042
69e5434c 2043static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 2044{
2045 int ret;
2046
69e5434c
JO		 2047 /*
2048 * One of the side effects of the JOIN command is that is clears
2049 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2050 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2051 * Currently the only valid scenario for JOIN during association
2052 * is on roaming, in which case we will also be given new keys.
2053 * Keep the below message for now, unless it starts bothering
2054 * users who really like to roam a lot :)
69e5434c
JO		 2055 */
2056 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2057 wl1271_info("JOIN while associated.");
2058
2059 if (set_assoc)
2060 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2061
82429d32
JO		 2062 ret = wl1271_cmd_join(wl, wl->set_bss_type);
2063 if (ret < 0)
2064 goto out;
2065
2066 set_bit(WL1271_FLAG_JOINED, &wl->flags);
2067
2068 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2069 goto out;
2070
2071 /*
2072 * The join command disable the keep-alive mode, shut down its process,
2073 * and also clear the template config, so we need to reset it all after
2074 * the join. The acx_aid starts the keep-alive process, and the order
2075 * of the commands below is relevant.
2076 */
2077 ret = wl1271_acx_keep_alive_mode(wl, true);
2078 if (ret < 0)
2079 goto out;
2080
2081 ret = wl1271_acx_aid(wl, wl->aid);
2082 if (ret < 0)
2083 goto out;
2084
2085 ret = wl1271_cmd_build_klv_null_data(wl);
2086 if (ret < 0)
2087 goto out;
2088
2089 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2090 ACX_KEEP_ALIVE_TPL_VALID);
2091 if (ret < 0)
2092 goto out;
2093
2094out:
2095 return ret;
2096}
2097
2098static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 2099{
2100 int ret;
2101
2102 /* to stop listening to a channel, we disconnect */
2103 ret = wl1271_cmd_disconnect(wl);
2104 if (ret < 0)
2105 goto out;
2106
71449f8d 2107 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 2108 memset(wl->bssid, 0, ETH_ALEN);
14b228a0 2109
b992c682
OK		 2110 /* reset TX security counters on a clean disconnect */
2111 wl->tx_security_last_seq_lsb = 0;
2112 wl->tx_security_seq = 0;
2113
c7f43e45
LC		 2114out:
2115 return ret;
2116}
2117
ebba60c6
JO		 2118static void wl1271_set_band_rate(struct wl1271 *wl)
2119{
2120 if (wl->band == IEEE80211_BAND_2GHZ)
2121 wl->basic_rate_set = wl->conf.tx.basic_rate;
2122 else
2123 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2124}
2125
bee0ffec 2126static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 2127{
2128 int ret;
2129
2130 if (idle) {
2131 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2132 ret = wl1271_unjoin(wl);
2133 if (ret < 0)
2134 goto out;
2135 }
e0fe371b 2136 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 2137 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 2138 if (ret < 0)
2139 goto out;
2140 ret = wl1271_acx_keep_alive_config(
2141 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2142 ACX_KEEP_ALIVE_TPL_INVALID);
2143 if (ret < 0)
2144 goto out;
2145 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2146 } else {
2147 /* increment the session counter */
2148 wl->session_counter++;
2149 if (wl->session_counter >= SESSION_COUNTER_MAX)
2150 wl->session_counter = 0;
33c2c06c
LC		 2151
2152 /* The current firmware only supports sched_scan in idle */
2153 if (wl->sched_scanning) {
2154 wl1271_scan_sched_scan_stop(wl);
2155 ieee80211_sched_scan_stopped(wl->hw);
2156 }
2157
0d58cbff
JO		 2158 ret = wl1271_dummy_join(wl);
2159 if (ret < 0)
2160 goto out;
2161 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2162 }
2163
2164out:
2165 return ret;
2166}
2167
f5fc0f86
LC		 2168static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2169{
2170 struct wl1271 *wl = hw->priv;
2171 struct ieee80211_conf *conf = &hw->conf;
2172 int channel, ret = 0;
bee0ffec 2173 bool is_ap;
f5fc0f86
LC		 2174
2175 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2176
bee0ffec
AN		 2177 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2178 " changed 0x%x",
f5fc0f86
LC		 2179 channel,
2180 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 2181 conf->power_level,
bee0ffec
AN		 2182 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2183 changed);
f5fc0f86 2184
781608c4
JO		 2185 /*
2186 * mac80211 will go to idle nearly immediately after transmitting some
2187 * frames, such as the deauth. To make sure those frames reach the air,
2188 * wait here until the TX queue is fully flushed.
2189 */
2190 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2191 (conf->flags & IEEE80211_CONF_IDLE))
2192 wl1271_tx_flush(wl);
2193
f5fc0f86
LC		 2194 mutex_lock(&wl->mutex);
2195
f8d9802f 2196 if (unlikely(wl->state == WL1271_STATE_OFF)) {
17e672d6
AN		 2197 /* we support configuring the channel and band while off */
2198 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2199 wl->band = conf->channel->band;
2200 wl->channel = channel;
2201 }
2202
097f8821
AN		 2203 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2204 wl->power_level = conf->power_level;
2205
2c10bb9c 2206 goto out;
f8d9802f 2207 }
8a5a37a6 2208
bee0ffec
AN		 2209 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2210
a620865e 2211 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2212 if (ret < 0)
2213 goto out;
2214
ebba60c6 2215 /* if the channel changes while joined, join again */
69e5434c
JO		 2216 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2217 ((wl->band != conf->channel->band) ||
2218 (wl->channel != channel))) {
ebba60c6
JO		 2219 wl->band = conf->channel->band;
2220 wl->channel = channel;
2221
bee0ffec
AN		 2222 if (!is_ap) {
2223 /*
2224 * FIXME: the mac80211 should really provide a fixed
2225 * rate to use here. for now, just use the smallest
2226 * possible rate for the band as a fixed rate for
2227 * association frames and other control messages.
2228 */
2229 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2230 wl1271_set_band_rate(wl);
2231
2232 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2233 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2234 if (ret < 0)
bee0ffec 2235 wl1271_warning("rate policy for channel "
ebba60c6 2236 "failed %d", ret);
bee0ffec
AN		 2237
2238 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
2239 ret = wl1271_join(wl, false);
2240 if (ret < 0)
2241 wl1271_warning("cmd join on channel "
2242 "failed %d", ret);
2243 }
ebba60c6
JO		 2244 }
2245 }
2246
bee0ffec
AN		 2247 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2248 ret = wl1271_sta_handle_idle(wl,
2249 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 2250 if (ret < 0)
2251 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 2252 }
2253
90494a90
JO		 2254 /*
2255 * if mac80211 changes the PSM mode, make sure the mode is not
2256 * incorrectly changed after the pspoll failure active window.
2257 */
2258 if (changed & IEEE80211_CONF_CHANGE_PS)
2259 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2260
71449f8d
JO		 2261 if (conf->flags & IEEE80211_CONF_PS &&
2262 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2263 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 2264
2265 /*
2266 * We enter PSM only if we're already associated.
2267 * If we're not, we'll enter it when joining an SSID,
2268 * through the bss_info_changed() hook.
2269 */
830fb67b 2270 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 2271 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 2272 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 2273 wl->basic_rate, true);
af5e084b 2274 }
f5fc0f86 2275 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 2276 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 2277 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 2278
71449f8d 2279 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 2280
71449f8d 2281 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 2282 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 2283 wl->basic_rate, true);
f5fc0f86
LC		 2284 }
2285
2286 if (conf->power_level != wl->power_level) {
2287 ret = wl1271_acx_tx_power(wl, conf->power_level);
2288 if (ret < 0)
c6317a54 2289 goto out_sleep;
f5fc0f86
LC		 2290
2291 wl->power_level = conf->power_level;
2292 }
2293
2294out_sleep:
2295 wl1271_ps_elp_sleep(wl);
2296
2297out:
2298 mutex_unlock(&wl->mutex);
2299
2300 return ret;
2301}
2302
b54853f1
JO		 2303struct wl1271_filter_params {
2304 bool enabled;
2305 int mc_list_length;
2306 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2307};
2308
22bedad3
JP		 2309static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2310 struct netdev_hw_addr_list *mc_list)
c87dec9f 2311{
c87dec9f 2312 struct wl1271_filter_params *fp;
22bedad3 2313 struct netdev_hw_addr *ha;
2c10bb9c 2314 struct wl1271 *wl = hw->priv;
c87dec9f 2315
2c10bb9c
SD		 2316 if (unlikely(wl->state == WL1271_STATE_OFF))
2317 return 0;
c87dec9f 2318
74441130 2319 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 2320 if (!fp) {
2321 wl1271_error("Out of memory setting filters.");
2322 return 0;
2323 }
2324
2325 /* update multicast filtering parameters */
c87dec9f 2326 fp->mc_list_length = 0;
22bedad3
JP		 2327 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2328 fp->enabled = false;
2329 } else {
2330 fp->enabled = true;
2331 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 2332 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 2333 ha->addr, ETH_ALEN);
c87dec9f 2334 fp->mc_list_length++;
22bedad3 2335 }
c87dec9f
JO		 2336 }
2337
b54853f1 2338 return (u64)(unsigned long)fp;
c87dec9f 2339}
f5fc0f86 2340
b54853f1
JO		 2341#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2342 FIF_ALLMULTI | \
2343 FIF_FCSFAIL | \
2344 FIF_BCN_PRBRESP_PROMISC | \
2345 FIF_CONTROL | \
2346 FIF_OTHER_BSS)
2347
f5fc0f86
LC		 2348static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2349 unsigned int changed,
c87dec9f 2350 unsigned int *total, u64 multicast)
f5fc0f86 2351{
b54853f1 2352 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2353 struct wl1271 *wl = hw->priv;
b54853f1 2354 int ret;
f5fc0f86 2355
7d057869
AN		 2356 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2357 " total %x", changed, *total);
f5fc0f86 2358
b54853f1
JO		 2359 mutex_lock(&wl->mutex);
2360
2c10bb9c
SD		 2361 *total &= WL1271_SUPPORTED_FILTERS;
2362 changed &= WL1271_SUPPORTED_FILTERS;
2363
2364 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2365 goto out;
2366
a620865e 2367 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2368 if (ret < 0)
2369 goto out;
2370
7d057869
AN		 2371 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2372 if (*total & FIF_ALLMULTI)
2373 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2374 else if (fp)
2375 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2376 fp->mc_list,
2377 fp->mc_list_length);
2378 if (ret < 0)
2379 goto out_sleep;
2380 }
f5fc0f86 2381
08c1d1c7
EP		 2382 /*
2383 * the fw doesn't provide an api to configure the filters. instead,
2384 * the filters configuration is based on the active roles / ROC
2385 * state.
2386 */
b54853f1
JO		 2387
2388out_sleep:
2389 wl1271_ps_elp_sleep(wl);
2390
2391out:
2392 mutex_unlock(&wl->mutex);
14b228a0 2393 kfree(fp);
f5fc0f86
LC		 2394}
2395
7f179b46
AN		 2396static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2397 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2398 u16 tx_seq_16)
2399{
2400 struct wl1271_ap_key *ap_key;
2401 int i;
2402
2403 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2404
2405 if (key_size > MAX_KEY_SIZE)
2406 return -EINVAL;
2407
2408 /*
2409 * Find next free entry in ap_keys. Also check we are not replacing
2410 * an existing key.
2411 */
2412 for (i = 0; i < MAX_NUM_KEYS; i++) {
2413 if (wl->recorded_ap_keys[i] == NULL)
2414 break;
2415
2416 if (wl->recorded_ap_keys[i]->id == id) {
2417 wl1271_warning("trying to record key replacement");
2418 return -EINVAL;
2419 }
2420 }
2421
2422 if (i == MAX_NUM_KEYS)
2423 return -EBUSY;
2424
2425 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2426 if (!ap_key)
2427 return -ENOMEM;
2428
2429 ap_key->id = id;
2430 ap_key->key_type = key_type;
2431 ap_key->key_size = key_size;
2432 memcpy(ap_key->key, key, key_size);
2433 ap_key->hlid = hlid;
2434 ap_key->tx_seq_32 = tx_seq_32;
2435 ap_key->tx_seq_16 = tx_seq_16;
2436
2437 wl->recorded_ap_keys[i] = ap_key;
2438 return 0;
2439}
2440
2441static void wl1271_free_ap_keys(struct wl1271 *wl)
2442{
2443 int i;
2444
2445 for (i = 0; i < MAX_NUM_KEYS; i++) {
2446 kfree(wl->recorded_ap_keys[i]);
2447 wl->recorded_ap_keys[i] = NULL;
2448 }
2449}
2450
2451static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2452{
2453 int i, ret = 0;
2454 struct wl1271_ap_key *key;
2455 bool wep_key_added = false;
2456
2457 for (i = 0; i < MAX_NUM_KEYS; i++) {
2458 if (wl->recorded_ap_keys[i] == NULL)
2459 break;
2460
2461 key = wl->recorded_ap_keys[i];
2462 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2463 key->id, key->key_type,
2464 key->key_size, key->key,
2465 key->hlid, key->tx_seq_32,
2466 key->tx_seq_16);
2467 if (ret < 0)
2468 goto out;
2469
2470 if (key->key_type == KEY_WEP)
2471 wep_key_added = true;
2472 }
2473
2474 if (wep_key_added) {
2475 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2476 if (ret < 0)
2477 goto out;
2478 }
2479
2480out:
2481 wl1271_free_ap_keys(wl);
2482 return ret;
2483}
2484
2485static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2486 u8 key_size, const u8 *key, u32 tx_seq_32,
2487 u16 tx_seq_16, struct ieee80211_sta *sta)
2488{
2489 int ret;
2490 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2491
2492 if (is_ap) {
2493 struct wl1271_station *wl_sta;
2494 u8 hlid;
2495
2496 if (sta) {
2497 wl_sta = (struct wl1271_station *)sta->drv_priv;
2498 hlid = wl_sta->hlid;
2499 } else {
2500 hlid = WL1271_AP_BROADCAST_HLID;
2501 }
2502
2503 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2504 /*
2505 * We do not support removing keys after AP shutdown.
2506 * Pretend we do to make mac80211 happy.
2507 */
2508 if (action != KEY_ADD_OR_REPLACE)
2509 return 0;
2510
2511 ret = wl1271_record_ap_key(wl, id,
2512 key_type, key_size,
2513 key, hlid, tx_seq_32,
2514 tx_seq_16);
2515 } else {
2516 ret = wl1271_cmd_set_ap_key(wl, action,
2517 id, key_type, key_size,
2518 key, hlid, tx_seq_32,
2519 tx_seq_16);
2520 }
2521
2522 if (ret < 0)
2523 return ret;
2524 } else {
2525 const u8 *addr;
2526 static const u8 bcast_addr[ETH_ALEN] = {
2527 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2528 };
2529
2530 addr = sta ? sta->addr : bcast_addr;
2531
2532 if (is_zero_ether_addr(addr)) {
2533 /* We dont support TX only encryption */
2534 return -EOPNOTSUPP;
2535 }
2536
2537 /* The wl1271 does not allow to remove unicast keys - they
2538 will be cleared automatically on next CMD_JOIN. Ignore the
2539 request silently, as we dont want the mac80211 to emit
2540 an error message. */
2541 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2542 return 0;
2543
2544 ret = wl1271_cmd_set_sta_key(wl, action,
2545 id, key_type, key_size,
2546 key, addr, tx_seq_32,
2547 tx_seq_16);
2548 if (ret < 0)
2549 return ret;
2550
2551 /* the default WEP key needs to be configured at least once */
2552 if (key_type == KEY_WEP) {
2553 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2554 wl->default_key);
2555 if (ret < 0)
2556 return ret;
2557 }
2558 }
2559
2560 return 0;
2561}
2562
f5fc0f86
LC		 2563static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2564 struct ieee80211_vif *vif,
2565 struct ieee80211_sta *sta,
2566 struct ieee80211_key_conf *key_conf)
2567{
2568 struct wl1271 *wl = hw->priv;
f5fc0f86 2569 int ret;
ac4e4ce5
JO		 2570 u32 tx_seq_32 = 0;
2571 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2572 u8 key_type;
2573
f5fc0f86
LC		 2574 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2575
7f179b46 2576 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2577 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2578 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2579 key_conf->keylen, key_conf->flags);
2580 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2581
f5fc0f86
LC		 2582 mutex_lock(&wl->mutex);
2583
f8d9802f
JO		 2584 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2585 ret = -EAGAIN;
2586 goto out_unlock;
2587 }
2588
a620865e 2589 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2590 if (ret < 0)
2591 goto out_unlock;
2592
97359d12
JB		 2593 switch (key_conf->cipher) {
2594 case WLAN_CIPHER_SUITE_WEP40:
2595 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2596 key_type = KEY_WEP;
2597
2598 key_conf->hw_key_idx = key_conf->keyidx;
2599 break;
97359d12 2600 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2601 key_type = KEY_TKIP;
2602
2603 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 2604 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2605 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2606 break;
97359d12 2607 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 2608 key_type = KEY_AES;
2609
2610 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 2611 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2612 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2613 break;
7a55724e
JO		 2614 case WL1271_CIPHER_SUITE_GEM:
2615 key_type = KEY_GEM;
2616 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2617 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2618 break;
f5fc0f86 2619 default:
97359d12 2620 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 2621
2622 ret = -EOPNOTSUPP;
2623 goto out_sleep;
2624 }
2625
2626 switch (cmd) {
2627 case SET_KEY:
7f179b46
AN		 2628 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2629 key_conf->keyidx, key_type,
2630 key_conf->keylen, key_conf->key,
2631 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 2632 if (ret < 0) {
2633 wl1271_error("Could not add or replace key");
2634 goto out_sleep;
2635 }
2636 break;
2637
2638 case DISABLE_KEY:
7f179b46
AN		 2639 ret = wl1271_set_key(wl, KEY_REMOVE,
2640 key_conf->keyidx, key_type,
2641 key_conf->keylen, key_conf->key,
2642 0, 0, sta);
f5fc0f86
LC		 2643 if (ret < 0) {
2644 wl1271_error("Could not remove key");
2645 goto out_sleep;
2646 }
2647 break;
2648
2649 default:
2650 wl1271_error("Unsupported key cmd 0x%x", cmd);
2651 ret = -EOPNOTSUPP;
f5fc0f86
LC		 2652 break;
2653 }
2654
2655out_sleep:
2656 wl1271_ps_elp_sleep(wl);
2657
2658out_unlock:
2659 mutex_unlock(&wl->mutex);
2660
f5fc0f86
LC		 2661 return ret;
2662}
2663
2664static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 2665 struct ieee80211_vif *vif,
f5fc0f86
LC		 2666 struct cfg80211_scan_request *req)
2667{
2668 struct wl1271 *wl = hw->priv;
2669 int ret;
2670 u8 *ssid = NULL;
abb0b3bf 2671 size_t len = 0;
f5fc0f86
LC		 2672
2673 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2674
2675 if (req->n_ssids) {
2676 ssid = req->ssids[0].ssid;
abb0b3bf 2677 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 2678 }
2679
2680 mutex_lock(&wl->mutex);
2681
b739a42c
JO		 2682 if (wl->state == WL1271_STATE_OFF) {
2683 /*
2684 * We cannot return -EBUSY here because cfg80211 will expect
2685 * a call to ieee80211_scan_completed if we do - in this case
2686 * there won't be any call.
2687 */
2688 ret = -EAGAIN;
2689 goto out;
2690 }
2691
a620865e 2692 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2693 if (ret < 0)
2694 goto out;
2695
5924f89d 2696 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 2697
2698 wl1271_ps_elp_sleep(wl);
2699
2700out:
2701 mutex_unlock(&wl->mutex);
2702
2703 return ret;
2704}
2705
73ecce31
EP		 2706static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2707 struct ieee80211_vif *vif)
2708{
2709 struct wl1271 *wl = hw->priv;
2710 int ret;
2711
2712 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2713
2714 mutex_lock(&wl->mutex);
2715
2716 if (wl->state == WL1271_STATE_OFF)
2717 goto out;
2718
2719 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2720 goto out;
2721
2722 ret = wl1271_ps_elp_wakeup(wl);
2723 if (ret < 0)
2724 goto out;
2725
2726 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2727 ret = wl1271_scan_stop(wl);
2728 if (ret < 0)
2729 goto out_sleep;
2730 }
2731 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2732 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2733 wl->scan.req = NULL;
2734 ieee80211_scan_completed(wl->hw, true);
2735
2736out_sleep:
2737 wl1271_ps_elp_sleep(wl);
2738out:
2739 mutex_unlock(&wl->mutex);
2740
2741 cancel_delayed_work_sync(&wl->scan_complete_work);
2742}
2743
33c2c06c
LC		 2744static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2745 struct ieee80211_vif *vif,
2746 struct cfg80211_sched_scan_request *req,
2747 struct ieee80211_sched_scan_ies *ies)
2748{
2749 struct wl1271 *wl = hw->priv;
2750 int ret;
2751
2752 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2753
2754 mutex_lock(&wl->mutex);
2755
2756 ret = wl1271_ps_elp_wakeup(wl);
2757 if (ret < 0)
2758 goto out;
2759
2760 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2761 if (ret < 0)
2762 goto out_sleep;
2763
2764 ret = wl1271_scan_sched_scan_start(wl);
2765 if (ret < 0)
2766 goto out_sleep;
2767
2768 wl->sched_scanning = true;
2769
2770out_sleep:
2771 wl1271_ps_elp_sleep(wl);
2772out:
2773 mutex_unlock(&wl->mutex);
2774 return ret;
2775}
2776
2777static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2778 struct ieee80211_vif *vif)
2779{
2780 struct wl1271 *wl = hw->priv;
2781 int ret;
2782
2783 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2784
2785 mutex_lock(&wl->mutex);
2786
2787 ret = wl1271_ps_elp_wakeup(wl);
2788 if (ret < 0)
2789 goto out;
2790
2791 wl1271_scan_sched_scan_stop(wl);
2792
2793 wl1271_ps_elp_sleep(wl);
2794out:
2795 mutex_unlock(&wl->mutex);
2796}
2797
68d069c4
AN		 2798static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2799{
2800 struct wl1271 *wl = hw->priv;
2801 int ret = 0;
2802
2803 mutex_lock(&wl->mutex);
2804
2805 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2806 ret = -EAGAIN;
2807 goto out;
2808 }
2809
a620865e 2810 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 2811 if (ret < 0)
2812 goto out;
2813
5f704d18 2814 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 2815 if (ret < 0)
2816 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2817
2818 wl1271_ps_elp_sleep(wl);
2819
2820out:
2821 mutex_unlock(&wl->mutex);
2822
2823 return ret;
2824}
2825
f5fc0f86
LC		 2826static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2827{
2828 struct wl1271 *wl = hw->priv;
aecb0565 2829 int ret = 0;
f5fc0f86
LC		 2830
2831 mutex_lock(&wl->mutex);
2832
f8d9802f
JO		 2833 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2834 ret = -EAGAIN;
aecb0565 2835 goto out;
f8d9802f 2836 }
aecb0565 2837
a620865e 2838 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2839 if (ret < 0)
2840 goto out;
2841
5f704d18 2842 ret = wl1271_acx_rts_threshold(wl, value);
f5fc0f86
LC		 2843 if (ret < 0)
2844 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2845
2846 wl1271_ps_elp_sleep(wl);
2847
2848out:
2849 mutex_unlock(&wl->mutex);
2850
2851 return ret;
2852}
2853
e78a287a 2854static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2855 int offset)
30240fc7 2856{
889cb360
EP		 2857 u8 ssid_len;
2858 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2859 skb->len - offset);
30240fc7 2860
889cb360
EP		 2861 if (!ptr) {
2862 wl1271_error("No SSID in IEs!");
2863 return -ENOENT;
2864 }
2865
2866 ssid_len = ptr[1];
2867 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2868 wl1271_error("SSID is too long!");
2869 return -EINVAL;
30240fc7 2870 }
e78a287a 2871
889cb360
EP		 2872 wl->ssid_len = ssid_len;
2873 memcpy(wl->ssid, ptr+2, ssid_len);
2874 return 0;
30240fc7
JO		 2875}
2876
e78a287a 2877static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2878 struct ieee80211_bss_conf *bss_conf,
2879 u32 changed)
2880{
e78a287a 2881 int ret = 0;
f5fc0f86 2882
e78a287a
AN		 2883 if (changed & BSS_CHANGED_ERP_SLOT) {
2884 if (bss_conf->use_short_slot)
2885 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2886 else
2887 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2888 if (ret < 0) {
2889 wl1271_warning("Set slot time failed %d", ret);
2890 goto out;
2891 }
2892 }
f5fc0f86 2893
e78a287a
AN		 2894 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2895 if (bss_conf->use_short_preamble)
2896 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2897 else
2898 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2899 }
f5fc0f86 2900
e78a287a
AN		 2901 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2902 if (bss_conf->use_cts_prot)
2903 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2904 else
2905 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2906 if (ret < 0) {
2907 wl1271_warning("Set ctsprotect failed %d", ret);
2908 goto out;
2909 }
2910 }
f8d9802f 2911
e78a287a
AN		 2912out:
2913 return ret;
2914}
f5fc0f86 2915
e78a287a
AN		 2916static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2917 struct ieee80211_vif *vif,
2918 struct ieee80211_bss_conf *bss_conf,
2919 u32 changed)
2920{
2921 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2922 int ret = 0;
2923
2924 if ((changed & BSS_CHANGED_BEACON_INT)) {
2925 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 2926 bss_conf->beacon_int);
2927
2928 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 2929 }
2930
e78a287a
AN		 2931 if ((changed & BSS_CHANGED_BEACON)) {
2932 struct ieee80211_hdr *hdr;
2933 int ieoffset = offsetof(struct ieee80211_mgmt,
2934 u.beacon.variable);
2935 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2936 u16 tmpl_id;
2937
2938 if (!beacon)
2939 goto out;
2940
2941 wl1271_debug(DEBUG_MASTER, "beacon updated");
2942
2943 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2944 if (ret < 0) {
2945 dev_kfree_skb(beacon);
2946 goto out;
2947 }
2948 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2949 CMD_TEMPL_BEACON;
2950 ret = wl1271_cmd_template_set(wl, tmpl_id,
2951 beacon->data,
2952 beacon->len, 0,
2953 wl1271_tx_min_rate_get(wl));
2954 if (ret < 0) {
2955 dev_kfree_skb(beacon);
2956 goto out;
2957 }
2958
2959 hdr = (struct ieee80211_hdr *) beacon->data;
2960 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2961 IEEE80211_STYPE_PROBE_RESP);
2962
2963 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2964 CMD_TEMPL_PROBE_RESPONSE;
2965 ret = wl1271_cmd_template_set(wl,
2966 tmpl_id,
2967 beacon->data,
2968 beacon->len, 0,
2969 wl1271_tx_min_rate_get(wl));
2970 dev_kfree_skb(beacon);
2971 if (ret < 0)
2972 goto out;
2973 }
2974
2975out:
2976 return ret;
2977}
2978
2979/* AP mode changes */
2980static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2981 struct ieee80211_vif *vif,
2982 struct ieee80211_bss_conf *bss_conf,
2983 u32 changed)
2984{
2985 int ret = 0;
e0d8bbf0 2986
e78a287a
AN		 2987 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2988 u32 rates = bss_conf->basic_rates;
5da11dcd 2989
e78a287a
AN		 2990 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2991 wl->basic_rate = wl1271_tx_min_rate_get(wl);
70f47424
AN		 2992
2993 ret = wl1271_init_ap_rates(wl);
e78a287a 2994 if (ret < 0) {
70f47424 2995 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 2996 goto out;
2997 }
c45a85b5
AN		 2998
2999 ret = wl1271_ap_init_templates(wl);
3000 if (ret < 0)
3001 goto out;
e78a287a 3002 }
2f6724b2 3003
e78a287a
AN		 3004 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3005 if (ret < 0)
3006 goto out;
30240fc7 3007
e78a287a
AN		 3008 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3009 if (bss_conf->enable_beacon) {
3010 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3011 ret = wl1271_cmd_start_bss(wl);
3012 if (ret < 0)
3013 goto out;
e0d8bbf0 3014
e78a287a
AN		 3015 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3016 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 3017
3018 ret = wl1271_ap_init_hwenc(wl);
3019 if (ret < 0)
3020 goto out;
e0d8bbf0 3021 }
e78a287a
AN		 3022 } else {
3023 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
3024 ret = wl1271_cmd_stop_bss(wl);
3025 if (ret < 0)
3026 goto out;
e0d8bbf0 3027
e78a287a
AN		 3028 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3029 wl1271_debug(DEBUG_AP, "stopped AP");
3030 }
3031 }
3032 }
e0d8bbf0 3033
e78a287a
AN		 3034 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3035 if (ret < 0)
3036 goto out;
3037out:
3038 return;
3039}
8bf29b0e 3040
e78a287a
AN		 3041/* STA/IBSS mode changes */
3042static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3043 struct ieee80211_vif *vif,
3044 struct ieee80211_bss_conf *bss_conf,
3045 u32 changed)
3046{
3047 bool do_join = false, set_assoc = false;
3048 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 3049 u32 sta_rate_set = 0;
e78a287a 3050 int ret;
2d6e4e76 3051 struct ieee80211_sta *sta;
a100885d
AN		 3052 bool sta_exists = false;
3053 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 3054
3055 if (is_ibss) {
3056 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3057 changed);
3058 if (ret < 0)
3059 goto out;
e0d8bbf0
JO		 3060 }
3061
e78a287a
AN		 3062 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
3063 do_join = true;
3064
3065 /* Need to update the SSID (for filtering etc) */
3066 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
3067 do_join = true;
3068
3069 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 3070 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3071 bss_conf->enable_beacon ? "enabled" : "disabled");
3072
3073 if (bss_conf->enable_beacon)
3074 wl->set_bss_type = BSS_TYPE_IBSS;
3075 else
3076 wl->set_bss_type = BSS_TYPE_STA_BSS;
3077 do_join = true;
3078 }
3079
e78a287a 3080 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 3081 bool enable = false;
3082 if (bss_conf->cqm_rssi_thold)
3083 enable = true;
3084 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3085 bss_conf->cqm_rssi_thold,
3086 bss_conf->cqm_rssi_hyst);
3087 if (ret < 0)
3088 goto out;
3089 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3090 }
3091
30240fc7
JO		 3092 if ((changed & BSS_CHANGED_BSSID) &&
3093 /*
3094 * Now we know the correct bssid, so we send a new join command
3095 * and enable the BSSID filter
3096 */
3097 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 3098 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 3099
fa287b8f
EP		 3100 if (!is_zero_ether_addr(wl->bssid)) {
3101 ret = wl1271_cmd_build_null_data(wl);
3102 if (ret < 0)
3103 goto out;
30240fc7 3104
fa287b8f
EP		 3105 ret = wl1271_build_qos_null_data(wl);
3106 if (ret < 0)
3107 goto out;
30240fc7 3108
fa287b8f
EP		 3109 /* Need to update the BSSID (for filtering etc) */
3110 do_join = true;
3111 }
30240fc7
JO		 3112 }
3113
72c2d9e5
EP		 3114 rcu_read_lock();
3115 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3116 if (sta) {
3117 /* save the supp_rates of the ap */
3118 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3119 if (sta->ht_cap.ht_supported)
3120 sta_rate_set |=
3121 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 3122 sta_ht_cap = sta->ht_cap;
3123 sta_exists = true;
3124 }
3125 rcu_read_unlock();
72c2d9e5 3126
a100885d 3127 if (sta_exists) {
72c2d9e5
EP		 3128 /* handle new association with HT and HT information change */
3129 if ((changed & BSS_CHANGED_HT) &&
3130 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 3131 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 3132 true);
3133 if (ret < 0) {
3134 wl1271_warning("Set ht cap true failed %d",
3135 ret);
72c2d9e5
EP		 3136 goto out;
3137 }
3138 ret = wl1271_acx_set_ht_information(wl,
3139 bss_conf->ht_operation_mode);
3140 if (ret < 0) {
3141 wl1271_warning("Set ht information failed %d",
3142 ret);
72c2d9e5
EP		 3143 goto out;
3144 }
3145 }
3146 /* handle new association without HT and disassociation */
3147 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 3148 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 3149 false);
3150 if (ret < 0) {
3151 wl1271_warning("Set ht cap false failed %d",
3152 ret);
72c2d9e5
EP		 3153 goto out;
3154 }
3155 }
3156 }
72c2d9e5 3157
e78a287a 3158 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 3159 if (bss_conf->assoc) {
ebba60c6 3160 u32 rates;
2f6724b2 3161 int ieoffset;
f5fc0f86 3162 wl->aid = bss_conf->aid;
69e5434c 3163 set_assoc = true;
f5fc0f86 3164
90494a90
JO		 3165 wl->ps_poll_failures = 0;
3166
ebba60c6
JO		 3167 /*
3168 * use basic rates from AP, and determine lowest rate
3169 * to use with control frames.
3170 */
3171 rates = bss_conf->basic_rates;
3172 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3173 rates);
e0fe371b 3174 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 3175 if (sta_rate_set)
3176 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3177 sta_rate_set);
79b223f4 3178 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3179 if (ret < 0)
e78a287a 3180 goto out;
ebba60c6 3181
ae751bab
LC		 3182 /*
3183 * with wl1271, we don't need to update the
3184 * beacon_int and dtim_period, because the firmware
3185 * updates it by itself when the first beacon is
3186 * received after a join.
3187 */
f5fc0f86
LC		 3188 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3189 if (ret < 0)
e78a287a 3190 goto out;
f5fc0f86 3191
c2b2d99b 3192 /*
2f6724b2 3193 * Get a template for hardware connection maintenance
c2b2d99b 3194 */
2f6724b2
JO		 3195 dev_kfree_skb(wl->probereq);
3196 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3197 ieoffset = offsetof(struct ieee80211_mgmt,
3198 u.probe_req.variable);
3199 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 3200
6ccbb92e
JO		 3201 /* enable the connection monitoring feature */
3202 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 3203 if (ret < 0)
e78a287a 3204 goto out;
f5fc0f86
LC		 3205
3206 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 3207 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3208 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 3209 enum wl1271_cmd_ps_mode mode;
3210
f5fc0f86 3211 mode = STATION_POWER_SAVE_MODE;
65cddbf1 3212 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 3213 wl->basic_rate,
65cddbf1 3214 true);
f5fc0f86 3215 if (ret < 0)
e78a287a 3216 goto out;
f5fc0f86 3217 }
d94cd297
JO		 3218 } else {
3219 /* use defaults when not associated */
30df14d0
EP		 3220 bool was_assoc =
3221 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3222 &wl->flags);
c2c192ac 3223 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
d94cd297 3224 wl->aid = 0;
6ccbb92e 3225
2f6724b2
JO		 3226 /* free probe-request template */
3227 dev_kfree_skb(wl->probereq);
3228 wl->probereq = NULL;
3229
8d2ef7bd 3230 /* re-enable dynamic ps - just in case */
f532be6d 3231 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 3232
ebba60c6
JO		 3233 /* revert back to minimum rates for the current band */
3234 wl1271_set_band_rate(wl);
e0fe371b 3235 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 3236 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3237 if (ret < 0)
e78a287a 3238 goto out;
ebba60c6 3239
6ccbb92e
JO		 3240 /* disable connection monitor features */
3241 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 3242
3243 /* Disable the keep-alive feature */
3244 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 3245 if (ret < 0)
e78a287a 3246 goto out;
b84a7d3d
JO		 3247
3248 /* restore the bssid filter and go to dummy bssid */
30df14d0
EP		 3249 if (was_assoc) {
3250 wl1271_unjoin(wl);
3251 wl1271_dummy_join(wl);
3252 }
f5fc0f86 3253 }
f5fc0f86
LC		 3254 }
3255
d192d268
EP		 3256 if (changed & BSS_CHANGED_IBSS) {
3257 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3258 bss_conf->ibss_joined);
3259
3260 if (bss_conf->ibss_joined) {
3261 u32 rates = bss_conf->basic_rates;
3262 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3263 rates);
3264 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3265
3266 /* by default, use 11b rates */
3267 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3268 ret = wl1271_acx_sta_rate_policies(wl);
3269 if (ret < 0)
3270 goto out;
3271 }
3272 }
3273
e78a287a
AN		 3274 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3275 if (ret < 0)
3276 goto out;
f5fc0f86 3277
ca52a5eb
JO		 3278 if (changed & BSS_CHANGED_ARP_FILTER) {
3279 __be32 addr = bss_conf->arp_addr_list[0];
3280 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3281
c5312772
EP		 3282 if (bss_conf->arp_addr_cnt == 1 &&
3283 bss_conf->arp_filter_enabled) {
3284 /*
3285 * The template should have been configured only upon
3286 * association. however, it seems that the correct ip
3287 * isn't being set (when sending), so we have to
3288 * reconfigure the template upon every ip change.
3289 */
3290 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3291 if (ret < 0) {
3292 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 3293 goto out;
c5312772
EP		 3294 }
3295
3296 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 3297 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 3298 addr);
3299 } else
3300 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 3301
3302 if (ret < 0)
e78a287a 3303 goto out;
ca52a5eb
JO		 3304 }
3305
8bf29b0e 3306 if (do_join) {
69e5434c 3307 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 3308 if (ret < 0) {
3309 wl1271_warning("cmd join failed %d", ret);
e78a287a 3310 goto out;
8bf29b0e 3311 }
ef4b29e9 3312 wl1271_check_operstate(wl, ieee80211_get_operstate(vif));
c1899554
JO		 3313 }
3314
e78a287a
AN		 3315out:
3316 return;
3317}
3318
3319static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3320 struct ieee80211_vif *vif,
3321 struct ieee80211_bss_conf *bss_conf,
3322 u32 changed)
3323{
3324 struct wl1271 *wl = hw->priv;
3325 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3326 int ret;
3327
3328 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3329 (int)changed);
3330
3331 mutex_lock(&wl->mutex);
3332
3333 if (unlikely(wl->state == WL1271_STATE_OFF))
3334 goto out;
3335
a620865e 3336 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3337 if (ret < 0)
3338 goto out;
3339
3340 if (is_ap)
3341 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3342 else
3343 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3344
f5fc0f86
LC		 3345 wl1271_ps_elp_sleep(wl);
3346
3347out:
3348 mutex_unlock(&wl->mutex);
3349}
3350
c6999d83
KV		 3351static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3352 const struct ieee80211_tx_queue_params *params)
3353{
3354 struct wl1271 *wl = hw->priv;
4695dc91 3355 u8 ps_scheme;
488fc540 3356 int ret = 0;
c6999d83
KV		 3357
3358 mutex_lock(&wl->mutex);
3359
3360 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3361
4695dc91
KV		 3362 if (params->uapsd)
3363 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3364 else
3365 ps_scheme = CONF_PS_SCHEME_LEGACY;
3366
488fc540
AN		 3367 if (wl->state == WL1271_STATE_OFF) {
3368 /*
3369 * If the state is off, the parameters will be recorded and
3370 * configured on init. This happens in AP-mode.
3371 */
3372 struct conf_tx_ac_category *conf_ac =
3373 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3374 struct conf_tx_tid *conf_tid =
3375 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3376
3377 conf_ac->ac = wl1271_tx_get_queue(queue);
3378 conf_ac->cw_min = (u8)params->cw_min;
3379 conf_ac->cw_max = params->cw_max;
3380 conf_ac->aifsn = params->aifs;
3381 conf_ac->tx_op_limit = params->txop << 5;
3382
3383 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3384 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3385 conf_tid->tsid = wl1271_tx_get_queue(queue);
3386 conf_tid->ps_scheme = ps_scheme;
3387 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3388 conf_tid->apsd_conf[0] = 0;
3389 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3390 goto out;
3391 }
488fc540 3392
c1b193eb
EP		 3393 ret = wl1271_ps_elp_wakeup(wl);
3394 if (ret < 0)
3395 goto out;
488fc540 3396
c1b193eb
EP		 3397 /*
3398 * the txop is confed in units of 32us by the mac80211,
3399 * we need us
3400 */
3401 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3402 params->cw_min, params->cw_max,
3403 params->aifs, params->txop << 5);
3404 if (ret < 0)
3405 goto out_sleep;
3406
3407 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3408 CONF_CHANNEL_TYPE_EDCF,
3409 wl1271_tx_get_queue(queue),
3410 ps_scheme, CONF_ACK_POLICY_LEGACY,
3411 0, 0);
c82c1dde
KV		 3412
3413out_sleep:
c1b193eb 3414 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 3415
3416out:
3417 mutex_unlock(&wl->mutex);
3418
3419 return ret;
3420}
3421
bbbb538e
JO		 3422static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3423{
3424
3425 struct wl1271 *wl = hw->priv;
3426 u64 mactime = ULLONG_MAX;
3427 int ret;
3428
3429 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3430
3431 mutex_lock(&wl->mutex);
3432
f8d9802f
JO		 3433 if (unlikely(wl->state == WL1271_STATE_OFF))
3434 goto out;
3435
a620865e 3436 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 3437 if (ret < 0)
3438 goto out;
3439
3440 ret = wl1271_acx_tsf_info(wl, &mactime);
3441 if (ret < 0)
3442 goto out_sleep;
3443
3444out_sleep:
3445 wl1271_ps_elp_sleep(wl);
3446
3447out:
3448 mutex_unlock(&wl->mutex);
3449 return mactime;
3450}
f5fc0f86 3451
ece550d0
JL		 3452static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3453 struct survey_info *survey)
3454{
3455 struct wl1271 *wl = hw->priv;
3456 struct ieee80211_conf *conf = &hw->conf;
b739a42c 3457
ece550d0
JL		 3458 if (idx != 0)
3459 return -ENOENT;
b739a42c 3460
ece550d0
JL		 3461 survey->channel = conf->channel;
3462 survey->filled = SURVEY_INFO_NOISE_DBM;
3463 survey->noise = wl->noise;
b739a42c 3464
ece550d0
JL		 3465 return 0;
3466}
3467
409622ec 3468static int wl1271_allocate_sta(struct wl1271 *wl,
f84f7d78
AN		 3469 struct ieee80211_sta *sta,
3470 u8 *hlid)
3471{
3472 struct wl1271_station *wl_sta;
3473 int id;
3474
3475 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3476 if (id >= AP_MAX_STATIONS) {
3477 wl1271_warning("could not allocate HLID - too much stations");
3478 return -EBUSY;
3479 }
3480
3481 wl_sta = (struct wl1271_station *)sta->drv_priv;
f84f7d78
AN		 3482 __set_bit(id, wl->ap_hlid_map);
3483 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3484 *hlid = wl_sta->hlid;
b622d992 3485 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
f84f7d78
AN		 3486 return 0;
3487}
3488
409622ec 3489static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
f84f7d78
AN		 3490{
3491 int id = hlid - WL1271_AP_STA_HLID_START;
3492
409622ec
AN		 3493 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3494 return;
3495
f84f7d78 3496 __clear_bit(id, wl->ap_hlid_map);
b622d992 3497 memset(wl->links[hlid].addr, 0, ETH_ALEN);
a8c0ddb5 3498 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 3499 __clear_bit(hlid, &wl->ap_ps_map);
3500 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
f84f7d78
AN		 3501}
3502
3618f30f
AN		 3503bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
3504{
3505 int id = hlid - WL1271_AP_STA_HLID_START;
3506 return test_bit(id, wl->ap_hlid_map);
3507}
3508
f84f7d78
AN		 3509static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3510 struct ieee80211_vif *vif,
3511 struct ieee80211_sta *sta)
3512{
3513 struct wl1271 *wl = hw->priv;
3514 int ret = 0;
3515 u8 hlid;
3516
3517 mutex_lock(&wl->mutex);
3518
3519 if (unlikely(wl->state == WL1271_STATE_OFF))
3520 goto out;
3521
3522 if (wl->bss_type != BSS_TYPE_AP_BSS)
3523 goto out;
3524
3525 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3526
409622ec 3527 ret = wl1271_allocate_sta(wl, sta, &hlid);
f84f7d78
AN		 3528 if (ret < 0)
3529 goto out;
3530
a620865e 3531 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 3532 if (ret < 0)
409622ec 3533 goto out_free_sta;
f84f7d78
AN		 3534
3535 ret = wl1271_cmd_add_sta(wl, sta, hlid);
3536 if (ret < 0)
3537 goto out_sleep;
3538
3539out_sleep:
3540 wl1271_ps_elp_sleep(wl);
3541
409622ec
AN		 3542out_free_sta:
3543 if (ret < 0)
3544 wl1271_free_sta(wl, hlid);
3545
f84f7d78
AN		 3546out:
3547 mutex_unlock(&wl->mutex);
3548 return ret;
3549}
3550
3551static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3552 struct ieee80211_vif *vif,
3553 struct ieee80211_sta *sta)
3554{
3555 struct wl1271 *wl = hw->priv;
3556 struct wl1271_station *wl_sta;
3557 int ret = 0, id;
3558
3559 mutex_lock(&wl->mutex);
3560
3561 if (unlikely(wl->state == WL1271_STATE_OFF))
3562 goto out;
3563
3564 if (wl->bss_type != BSS_TYPE_AP_BSS)
3565 goto out;
3566
3567 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3568
3569 wl_sta = (struct wl1271_station *)sta->drv_priv;
3570 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3571 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3572 goto out;
3573
a620865e 3574 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 3575 if (ret < 0)
3576 goto out;
3577
3578 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3579 if (ret < 0)
3580 goto out_sleep;
3581
409622ec 3582 wl1271_free_sta(wl, wl_sta->hlid);
f84f7d78
AN		 3583
3584out_sleep:
3585 wl1271_ps_elp_sleep(wl);
3586
3587out:
3588 mutex_unlock(&wl->mutex);
3589 return ret;
3590}
3591
4623ec7d
LC		 3592static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3593 struct ieee80211_vif *vif,
3594 enum ieee80211_ampdu_mlme_action action,
3595 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3596 u8 buf_size)
bbba3e68
LS		 3597{
3598 struct wl1271 *wl = hw->priv;
3599 int ret;
3600
3601 mutex_lock(&wl->mutex);
3602
3603 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3604 ret = -EAGAIN;
3605 goto out;
3606 }
3607
a620865e 3608 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 3609 if (ret < 0)
3610 goto out;
3611
70559a06
SL		 3612 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3613 tid, action);
3614
bbba3e68
LS		 3615 switch (action) {
3616 case IEEE80211_AMPDU_RX_START:
70559a06 3617 if ((wl->ba_support) && (wl->ba_allowed)) {
bbba3e68
LS		 3618 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3619 true);
3620 if (!ret)
3621 wl->ba_rx_bitmap |= BIT(tid);
3622 } else {
3623 ret = -ENOTSUPP;
3624 }
3625 break;
3626
3627 case IEEE80211_AMPDU_RX_STOP:
3628 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3629 if (!ret)
3630 wl->ba_rx_bitmap &= ~BIT(tid);
3631 break;
3632
3633 /*
3634 * The BA initiator session management in FW independently.
3635 * Falling break here on purpose for all TX APDU commands.
3636 */
3637 case IEEE80211_AMPDU_TX_START:
3638 case IEEE80211_AMPDU_TX_STOP:
3639 case IEEE80211_AMPDU_TX_OPERATIONAL:
3640 ret = -EINVAL;
3641 break;
3642
3643 default:
3644 wl1271_error("Incorrect ampdu action id=%x\n", action);
3645 ret = -EINVAL;
3646 }
3647
3648 wl1271_ps_elp_sleep(wl);
3649
3650out:
3651 mutex_unlock(&wl->mutex);
3652
3653 return ret;
3654}
3655
33437893
AN		 3656static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3657{
3658 struct wl1271 *wl = hw->priv;
3659 bool ret = false;
3660
3661 mutex_lock(&wl->mutex);
3662
3663 if (unlikely(wl->state == WL1271_STATE_OFF))
3664 goto out;
3665
3666 /* packets are considered pending if in the TX queue or the FW */
f1a46384 3667 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 3668
3669 /* the above is appropriate for STA mode for PS purposes */
3670 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3671
3672out:
3673 mutex_unlock(&wl->mutex);
3674
3675 return ret;
3676}
3677
f5fc0f86
LC		 3678/* can't be const, mac80211 writes to this */
3679static struct ieee80211_rate wl1271_rates[] = {
3680 { .bitrate = 10,
2b60100b
JO		 3681 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3682 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 3683 { .bitrate = 20,
2b60100b
JO		 3684 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3685 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 3686 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3687 { .bitrate = 55,
2b60100b
JO		 3688 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3689 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 3690 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3691 { .bitrate = 110,
2b60100b
JO		 3692 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3693 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 3694 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3695 { .bitrate = 60,
2b60100b
JO		 3696 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3697 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 3698 { .bitrate = 90,
2b60100b
JO		 3699 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3700 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 3701 { .bitrate = 120,
2b60100b
JO		 3702 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3703 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 3704 { .bitrate = 180,
2b60100b
JO		 3705 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3706 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 3707 { .bitrate = 240,
2b60100b
JO		 3708 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3709 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 3710 { .bitrate = 360,
2b60100b
JO		 3711 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3712 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 3713 { .bitrate = 480,
2b60100b
JO		 3714 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3715 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 3716 { .bitrate = 540,
2b60100b
JO		 3717 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3718 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 3719};
3720
fa97f46b 3721/* can't be const, mac80211 writes to this */
f5fc0f86 3722static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 3723 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 3724 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 3725 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3726 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3727 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 3728 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 3729 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3730 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3731 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 3732 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 3733 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3734 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3735 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 3736 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 3737};
3738
f876bb9a 3739/* mapping to indexes for wl1271_rates */
a0ea9493 3740static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 3741 /* MCS rates are used only with 11n */
18357850
SL		 3742 7, /* CONF_HW_RXTX_RATE_MCS7 */
3743 6, /* CONF_HW_RXTX_RATE_MCS6 */
3744 5, /* CONF_HW_RXTX_RATE_MCS5 */
3745 4, /* CONF_HW_RXTX_RATE_MCS4 */
3746 3, /* CONF_HW_RXTX_RATE_MCS3 */
3747 2, /* CONF_HW_RXTX_RATE_MCS2 */
3748 1, /* CONF_HW_RXTX_RATE_MCS1 */
3749 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3750
3751 11, /* CONF_HW_RXTX_RATE_54 */
3752 10, /* CONF_HW_RXTX_RATE_48 */
3753 9, /* CONF_HW_RXTX_RATE_36 */
3754 8, /* CONF_HW_RXTX_RATE_24 */
3755
3756 /* TI-specific rate */
3757 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3758
3759 7, /* CONF_HW_RXTX_RATE_18 */
3760 6, /* CONF_HW_RXTX_RATE_12 */
3761 3, /* CONF_HW_RXTX_RATE_11 */
3762 5, /* CONF_HW_RXTX_RATE_9 */
3763 4, /* CONF_HW_RXTX_RATE_6 */
3764 2, /* CONF_HW_RXTX_RATE_5_5 */
3765 1, /* CONF_HW_RXTX_RATE_2 */
3766 0 /* CONF_HW_RXTX_RATE_1 */
3767};
3768
e8b03a2b
SL		 3769/* 11n STA capabilities */
3770#define HW_RX_HIGHEST_RATE 72
3771
00d20100
SL		 3772#ifdef CONFIG_WL12XX_HT
3773#define WL12XX_HT_CAP { \
871d0c3b
SL		 3774 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3775 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 3776 .ht_supported = true, \
3777 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3778 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3779 .mcs = { \
3780 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3781 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3782 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3783 }, \
3784}
18357850 3785#else
00d20100 3786#define WL12XX_HT_CAP { \
18357850
SL		 3787 .ht_supported = false, \
3788}
3789#endif
e8b03a2b 3790
f5fc0f86
LC		 3791/* can't be const, mac80211 writes to this */
3792static struct ieee80211_supported_band wl1271_band_2ghz = {
3793 .channels = wl1271_channels,
3794 .n_channels = ARRAY_SIZE(wl1271_channels),
3795 .bitrates = wl1271_rates,
3796 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 3797 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 3798};
3799
1ebec3d7
TP		 3800/* 5 GHz data rates for WL1273 */
3801static struct ieee80211_rate wl1271_rates_5ghz[] = {
3802 { .bitrate = 60,
3803 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3804 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3805 { .bitrate = 90,
3806 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3807 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3808 { .bitrate = 120,
3809 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3810 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3811 { .bitrate = 180,
3812 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3813 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3814 { .bitrate = 240,
3815 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3816 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3817 { .bitrate = 360,
3818 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3819 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3820 { .bitrate = 480,
3821 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3822 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3823 { .bitrate = 540,
3824 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3825 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3826};
3827
fa97f46b 3828/* 5 GHz band channels for WL1273 */
1ebec3d7 3829static struct ieee80211_channel wl1271_channels_5ghz[] = {
6cfa5cff
AN		 3830 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
3831 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
3832 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
3833 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
3834 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
3835 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
3836 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
3837 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
3838 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
3839 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
3840 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
3841 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
3842 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
3843 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
3844 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
3845 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
3846 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
3847 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
3848 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
3849 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
3850 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
3851 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
3852 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
3853 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
3854 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
3855 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
3856 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
3857 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
3858 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
3859 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
3860 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
3861 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
3862 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
3863 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
1ebec3d7
TP		 3864};
3865
f876bb9a 3866/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 3867static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 3868 /* MCS rates are used only with 11n */
18357850
SL		 3869 7, /* CONF_HW_RXTX_RATE_MCS7 */
3870 6, /* CONF_HW_RXTX_RATE_MCS6 */
3871 5, /* CONF_HW_RXTX_RATE_MCS5 */
3872 4, /* CONF_HW_RXTX_RATE_MCS4 */
3873 3, /* CONF_HW_RXTX_RATE_MCS3 */
3874 2, /* CONF_HW_RXTX_RATE_MCS2 */
3875 1, /* CONF_HW_RXTX_RATE_MCS1 */
3876 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3877
3878 7, /* CONF_HW_RXTX_RATE_54 */
3879 6, /* CONF_HW_RXTX_RATE_48 */
3880 5, /* CONF_HW_RXTX_RATE_36 */
3881 4, /* CONF_HW_RXTX_RATE_24 */
3882
3883 /* TI-specific rate */
3884 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3885
3886 3, /* CONF_HW_RXTX_RATE_18 */
3887 2, /* CONF_HW_RXTX_RATE_12 */
3888 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3889 1, /* CONF_HW_RXTX_RATE_9 */
3890 0, /* CONF_HW_RXTX_RATE_6 */
3891 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3892 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3893 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3894};
1ebec3d7
TP		 3895
3896static struct ieee80211_supported_band wl1271_band_5ghz = {
3897 .channels = wl1271_channels_5ghz,
3898 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3899 .bitrates = wl1271_rates_5ghz,
3900 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 3901 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 3902};
3903
a0ea9493 3904static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 3905 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3906 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3907};
3908
f5fc0f86
LC		 3909static const struct ieee80211_ops wl1271_ops = {
3910 .start = wl1271_op_start,
3911 .stop = wl1271_op_stop,
3912 .add_interface = wl1271_op_add_interface,
3913 .remove_interface = wl1271_op_remove_interface,
f634a4e7 3914#ifdef CONFIG_PM
402e4861
EP		 3915 .suspend = wl1271_op_suspend,
3916 .resume = wl1271_op_resume,
f634a4e7 3917#endif
f5fc0f86 3918 .config = wl1271_op_config,
c87dec9f 3919 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 3920 .configure_filter = wl1271_op_configure_filter,
3921 .tx = wl1271_op_tx,
3922 .set_key = wl1271_op_set_key,
3923 .hw_scan = wl1271_op_hw_scan,
73ecce31 3924 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 3925 .sched_scan_start = wl1271_op_sched_scan_start,
3926 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 3927 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 3928 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 3929 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 3930 .conf_tx = wl1271_op_conf_tx,
bbbb538e 3931 .get_tsf = wl1271_op_get_tsf,
ece550d0 3932 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 3933 .sta_add = wl1271_op_sta_add,
3934 .sta_remove = wl1271_op_sta_remove,
bbba3e68 3935 .ampdu_action = wl1271_op_ampdu_action,
33437893 3936 .tx_frames_pending = wl1271_tx_frames_pending,
c8c90873 3937 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 3938};
3939
f876bb9a 3940
6a2de93b 3941u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 3942{
3943 u8 idx;
3944
6a2de93b 3945 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 3946
3947 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3948 wl1271_error("Illegal RX rate from HW: %d", rate);
3949 return 0;
3950 }
3951
6a2de93b 3952 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 3953 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3954 wl1271_error("Unsupported RX rate from HW: %d", rate);
3955 return 0;
3956 }
3957
3958 return idx;
3959}
3960
7fc3a864
JO		 3961static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3962 struct device_attribute *attr,
3963 char *buf)
3964{
3965 struct wl1271 *wl = dev_get_drvdata(dev);
3966 ssize_t len;
3967
2f63b011 3968 len = PAGE_SIZE;
7fc3a864
JO		 3969
3970 mutex_lock(&wl->mutex);
3971 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3972 wl->sg_enabled);
3973 mutex_unlock(&wl->mutex);
3974
3975 return len;
3976
3977}
3978
3979static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3980 struct device_attribute *attr,
3981 const char *buf, size_t count)
3982{
3983 struct wl1271 *wl = dev_get_drvdata(dev);
3984 unsigned long res;
3985 int ret;
3986
6277ed65 3987 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 3988 if (ret < 0) {
3989 wl1271_warning("incorrect value written to bt_coex_mode");
3990 return count;
3991 }
3992
3993 mutex_lock(&wl->mutex);
3994
3995 res = !!res;
3996
3997 if (res == wl->sg_enabled)
3998 goto out;
3999
4000 wl->sg_enabled = res;
4001
4002 if (wl->state == WL1271_STATE_OFF)
4003 goto out;
4004
a620865e 4005 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 4006 if (ret < 0)
4007 goto out;
4008
4009 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4010 wl1271_ps_elp_sleep(wl);
4011
4012 out:
4013 mutex_unlock(&wl->mutex);
4014 return count;
4015}
4016
4017static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4018 wl1271_sysfs_show_bt_coex_state,
4019 wl1271_sysfs_store_bt_coex_state);
4020
d717fd61
JO		 4021static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4022 struct device_attribute *attr,
4023 char *buf)
4024{
4025 struct wl1271 *wl = dev_get_drvdata(dev);
4026 ssize_t len;
4027
2f63b011 4028 len = PAGE_SIZE;
d717fd61
JO		 4029
4030 mutex_lock(&wl->mutex);
4031 if (wl->hw_pg_ver >= 0)
4032 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4033 else
4034 len = snprintf(buf, len, "n/a\n");
4035 mutex_unlock(&wl->mutex);
4036
4037 return len;
4038}
4039
6f07b72a 4040static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
d717fd61
JO		 4041 wl1271_sysfs_show_hw_pg_ver, NULL);
4042
95dac04f
IY		 4043static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4044 struct bin_attribute *bin_attr,
4045 char *buffer, loff_t pos, size_t count)
4046{
4047 struct device *dev = container_of(kobj, struct device, kobj);
4048 struct wl1271 *wl = dev_get_drvdata(dev);
4049 ssize_t len;
4050 int ret;
4051
4052 ret = mutex_lock_interruptible(&wl->mutex);
4053 if (ret < 0)
4054 return -ERESTARTSYS;
4055
4056 /* Let only one thread read the log at a time, blocking others */
4057 while (wl->fwlog_size == 0) {
4058 DEFINE_WAIT(wait);
4059
4060 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4061 &wait,
4062 TASK_INTERRUPTIBLE);
4063
4064 if (wl->fwlog_size != 0) {
4065 finish_wait(&wl->fwlog_waitq, &wait);
4066 break;
4067 }
4068
4069 mutex_unlock(&wl->mutex);
4070
4071 schedule();
4072 finish_wait(&wl->fwlog_waitq, &wait);
4073
4074 if (signal_pending(current))
4075 return -ERESTARTSYS;
4076
4077 ret = mutex_lock_interruptible(&wl->mutex);
4078 if (ret < 0)
4079 return -ERESTARTSYS;
4080 }
4081
4082 /* Check if the fwlog is still valid */
4083 if (wl->fwlog_size < 0) {
4084 mutex_unlock(&wl->mutex);
4085 return 0;
4086 }
4087
4088 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4089 len = min(count, (size_t)wl->fwlog_size);
4090 wl->fwlog_size -= len;
4091 memcpy(buffer, wl->fwlog, len);
4092
4093 /* Make room for new messages */
4094 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4095
4096 mutex_unlock(&wl->mutex);
4097
4098 return len;
4099}
4100
4101static struct bin_attribute fwlog_attr = {
4102 .attr = {.name = "fwlog", .mode = S_IRUSR},
4103 .read = wl1271_sysfs_read_fwlog,
4104};
4105
2d5e82b8 4106int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 4107{
4108 int ret;
4109
4110 if (wl->mac80211_registered)
4111 return 0;
4112
31d26ec6
AN		 4113 ret = wl1271_fetch_nvs(wl);
4114 if (ret == 0) {
bc765bf3
SL		 4115 /* NOTE: The wl->nvs->nvs element must be first, in
4116 * order to simplify the casting, we assume it is at
4117 * the beginning of the wl->nvs structure.
4118 */
4119 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 4120
4121 wl->mac_addr[0] = nvs_ptr[11];
4122 wl->mac_addr[1] = nvs_ptr[10];
4123 wl->mac_addr[2] = nvs_ptr[6];
4124 wl->mac_addr[3] = nvs_ptr[5];
4125 wl->mac_addr[4] = nvs_ptr[4];
4126 wl->mac_addr[5] = nvs_ptr[3];
4127 }
4128
f5fc0f86
LC		 4129 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4130
4131 ret = ieee80211_register_hw(wl->hw);
4132 if (ret < 0) {
4133 wl1271_error("unable to register mac80211 hw: %d", ret);
4134 return ret;
4135 }
4136
4137 wl->mac80211_registered = true;
4138
d60080ae
EP		 4139 wl1271_debugfs_init(wl);
4140
c2c192ac
JO		 4141 register_netdevice_notifier(&wl1271_dev_notifier);
4142
f5fc0f86
LC		 4143 wl1271_notice("loaded");
4144
4145 return 0;
4146}
50b3eb4b 4147EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 4148
3b56dd6a
TP		 4149void wl1271_unregister_hw(struct wl1271 *wl)
4150{
4ae3fa87
JO		 4151 if (wl->state == WL1271_STATE_PLT)
4152 __wl1271_plt_stop(wl);
4153
c2c192ac 4154 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 4155 ieee80211_unregister_hw(wl->hw);
4156 wl->mac80211_registered = false;
4157
4158}
4159EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4160
2d5e82b8 4161int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 4162{
7a55724e
JO		 4163 static const u32 cipher_suites[] = {
4164 WLAN_CIPHER_SUITE_WEP40,
4165 WLAN_CIPHER_SUITE_WEP104,
4166 WLAN_CIPHER_SUITE_TKIP,
4167 WLAN_CIPHER_SUITE_CCMP,
4168 WL1271_CIPHER_SUITE_GEM,
4169 };
4170
1e2b7976
JO		 4171 /* The tx descriptor buffer and the TKIP space. */
4172 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4173 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 4174
4175 /* unit us */
4176 /* FIXME: find a proper value */
4177 wl->hw->channel_change_time = 10000;
50c500ad 4178 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 4179
4180 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 4181 IEEE80211_HW_BEACON_FILTER |
0a34332f 4182 IEEE80211_HW_SUPPORTS_PS |
4695dc91 4183 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 4184 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 4185 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 4186 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 4187 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 4188 IEEE80211_HW_SPECTRUM_MGMT |
ba7c082a 4189 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 4190
7a55724e
JO		 4191 wl->hw->wiphy->cipher_suites = cipher_suites;
4192 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4193
e0d8bbf0 4194 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 4195 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 4196 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 4197 /*
4198 * Maximum length of elements in scanning probe request templates
4199 * should be the maximum length possible for a template, without
4200 * the IEEE80211 header of the template
4201 */
4202 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
4203 sizeof(struct ieee80211_header);
a8aaaf53 4204
4a31c11c
LC		 4205 /* make sure all our channels fit in the scanned_ch bitmask */
4206 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4207 ARRAY_SIZE(wl1271_channels_5ghz) >
4208 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 4209 /*
4210 * We keep local copies of the band structs because we need to
4211 * modify them on a per-device basis.
4212 */
4213 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4214 sizeof(wl1271_band_2ghz));
4215 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4216 sizeof(wl1271_band_5ghz));
4217
4218 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4219 &wl->bands[IEEE80211_BAND_2GHZ];
4220 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4221 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 4222
12bd8949 4223 wl->hw->queues = 4;
31627dc5 4224 wl->hw->max_rates = 1;
12bd8949 4225
b7417d93
JO		 4226 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4227
8197b711 4228 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 4229
f84f7d78
AN		 4230 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4231
4c9cfa78
LC		 4232 wl->hw->max_rx_aggregation_subframes = 8;
4233
f5fc0f86
LC		 4234 return 0;
4235}
50b3eb4b 4236EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 4237
f5fc0f86 4238#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 4239
2d5e82b8 4240struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 4241{
f5fc0f86 4242 struct ieee80211_hw *hw;
3b56dd6a 4243 struct platform_device *plat_dev = NULL;
f5fc0f86 4244 struct wl1271 *wl;
a8c0ddb5 4245 int i, j, ret;
1f37cbc9 4246 unsigned int order;
f5fc0f86
LC		 4247
4248 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4249 if (!hw) {
4250 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 4251 ret = -ENOMEM;
3b56dd6a
TP		 4252 goto err_hw_alloc;
4253 }
4254
929ebd30 4255 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 4256 if (!plat_dev) {
4257 wl1271_error("could not allocate platform_device");
4258 ret = -ENOMEM;
4259 goto err_plat_alloc;
f5fc0f86
LC		 4260 }
4261
4262 wl = hw->priv;
4263 memset(wl, 0, sizeof(*wl));
4264
01c09162
JO		 4265 INIT_LIST_HEAD(&wl->list);
4266
f5fc0f86 4267 wl->hw = hw;
3b56dd6a 4268 wl->plat_dev = plat_dev;
f5fc0f86 4269
6742f554
JO		 4270 for (i = 0; i < NUM_TX_QUEUES; i++)
4271 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 4272
a8c0ddb5
AN		 4273 for (i = 0; i < NUM_TX_QUEUES; i++)
4274 for (j = 0; j < AP_MAX_LINKS; j++)
4275 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4276
a620865e
IY		 4277 skb_queue_head_init(&wl->deferred_rx_queue);
4278 skb_queue_head_init(&wl->deferred_tx_queue);
4279
37b70a81 4280 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 4281 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
a620865e 4282 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 4283 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4284 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4285 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
77ddaa10
EP		 4286 INIT_WORK(&wl->rx_streaming_enable_work,
4287 wl1271_rx_streaming_enable_work);
4288 INIT_WORK(&wl->rx_streaming_disable_work,
4289 wl1271_rx_streaming_disable_work);
4290
92ef8960
EP		 4291 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4292 if (!wl->freezable_wq) {
4293 ret = -ENOMEM;
4294 goto err_hw;
4295 }
4296
f5fc0f86 4297 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 4298 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 4299 wl->default_key = 0;
f5fc0f86 4300 wl->rx_counter = 0;
19ad0715 4301 wl->psm_entry_retry = 0;
f5fc0f86 4302 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 4303 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 4304 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 4305 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 4306 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 4307 wl->vif = NULL;
830fb67b 4308 wl->flags = 0;
7fc3a864 4309 wl->sg_enabled = true;
d717fd61 4310 wl->hw_pg_ver = -1;
166d504e
AN		 4311 wl->bss_type = MAX_BSS_TYPE;
4312 wl->set_bss_type = MAX_BSS_TYPE;
a8c0ddb5 4313 wl->last_tx_hlid = 0;
b622d992
AN		 4314 wl->ap_ps_map = 0;
4315 wl->ap_fw_ps_map = 0;
606ea9fa 4316 wl->quirks = 0;
341b7cde 4317 wl->platform_quirks = 0;
33c2c06c 4318 wl->sched_scanning = false;
b992c682
OK		 4319 wl->tx_security_seq = 0;
4320 wl->tx_security_last_seq_lsb = 0;
7f097988
EP		 4321 wl->role_id = WL12XX_INVALID_ROLE_ID;
4322 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
b992c682 4323
77ddaa10
EP		 4324 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4325 (unsigned long) wl);
95dac04f
IY		 4326 wl->fwlog_size = 0;
4327 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 4328
25eeb9e3 4329 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 4330 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 4331 wl->tx_frames[i] = NULL;
4332
4333 spin_lock_init(&wl->wl_lock);
4334
f5fc0f86
LC		 4335 wl->state = WL1271_STATE_OFF;
4336 mutex_init(&wl->mutex);
4337
c332a4b8
TP		 4338 /* Apply default driver configuration. */
4339 wl1271_conf_init(wl);
4340
1f37cbc9
IY		 4341 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4342 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4343 if (!wl->aggr_buf) {
4344 ret = -ENOMEM;
92ef8960 4345 goto err_wq;
1f37cbc9
IY		 4346 }
4347
990f5de7
IY		 4348 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4349 if (!wl->dummy_packet) {
4350 ret = -ENOMEM;
4351 goto err_aggr;
4352 }
4353
95dac04f
IY		 4354 /* Allocate one page for the FW log */
4355 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4356 if (!wl->fwlog) {
4357 ret = -ENOMEM;
4358 goto err_dummy_packet;
4359 }
4360
a1dd8187 4361 /* Register platform device */
3b56dd6a 4362 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 4363 if (ret) {
4364 wl1271_error("couldn't register platform device");
95dac04f 4365 goto err_fwlog;
a1dd8187 4366 }
3b56dd6a 4367 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 4368
7fc3a864 4369 /* Create sysfs file to control bt coex state */
3b56dd6a 4370 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 4371 if (ret < 0) {
4372 wl1271_error("failed to create sysfs file bt_coex_state");
4373 goto err_platform;
4374 }
a1dd8187 4375
d717fd61
JO		 4376 /* Create sysfs file to get HW PG version */
4377 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4378 if (ret < 0) {
4379 wl1271_error("failed to create sysfs file hw_pg_ver");
4380 goto err_bt_coex_state;
4381 }
4382
95dac04f
IY		 4383 /* Create sysfs file for the FW log */
4384 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4385 if (ret < 0) {
4386 wl1271_error("failed to create sysfs file fwlog");
4387 goto err_hw_pg_ver;
4388 }
4389
c332a4b8 4390 return hw;
a1dd8187 4391
95dac04f
IY		 4392err_hw_pg_ver:
4393 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4394
d717fd61
JO		 4395err_bt_coex_state:
4396 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4397
7fc3a864 4398err_platform:
3b56dd6a 4399 platform_device_unregister(wl->plat_dev);
7fc3a864 4400
95dac04f
IY		 4401err_fwlog:
4402 free_page((unsigned long)wl->fwlog);
4403
990f5de7
IY		 4404err_dummy_packet:
4405 dev_kfree_skb(wl->dummy_packet);
4406
1f37cbc9
IY		 4407err_aggr:
4408 free_pages((unsigned long)wl->aggr_buf, order);
4409
92ef8960
EP		 4410err_wq:
4411 destroy_workqueue(wl->freezable_wq);
4412
a1dd8187 4413err_hw:
3b56dd6a
TP		 4414 wl1271_debugfs_exit(wl);
4415 kfree(plat_dev);
4416
4417err_plat_alloc:
4418 ieee80211_free_hw(hw);
4419
4420err_hw_alloc:
a1dd8187 4421
a1dd8187 4422 return ERR_PTR(ret);
c332a4b8 4423}
50b3eb4b 4424EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 4425
4426int wl1271_free_hw(struct wl1271 *wl)
4427{
95dac04f
IY		 4428 /* Unblock any fwlog readers */
4429 mutex_lock(&wl->mutex);
4430 wl->fwlog_size = -1;
4431 wake_up_interruptible_all(&wl->fwlog_waitq);
4432 mutex_unlock(&wl->mutex);
4433
4434 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
6f07b72a
GK		 4435
4436 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4437
4438 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3b56dd6a 4439 platform_device_unregister(wl->plat_dev);
95dac04f 4440 free_page((unsigned long)wl->fwlog);
990f5de7 4441 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 4442 free_pages((unsigned long)wl->aggr_buf,
4443 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 4444 kfree(wl->plat_dev);
c332a4b8
TP		 4445
4446 wl1271_debugfs_exit(wl);
4447
c332a4b8
TP		 4448 vfree(wl->fw);
4449 wl->fw = NULL;
4450 kfree(wl->nvs);
4451 wl->nvs = NULL;
4452
4453 kfree(wl->fw_status);
4454 kfree(wl->tx_res_if);
92ef8960 4455 destroy_workqueue(wl->freezable_wq);
c332a4b8
TP		 4456
4457 ieee80211_free_hw(wl->hw);
4458
4459 return 0;
4460}
50b3eb4b
TP		 4461EXPORT_SYMBOL_GPL(wl1271_free_hw);
4462
491bbd6b 4463u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 4464EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 4465module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 4466MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4467
95dac04f
IY		 4468module_param_named(fwlog, fwlog_param, charp, 0);
4469MODULE_PARM_DESC(keymap,
4470 "FW logger options: continuous, ondemand, dbgpins or disable");
4471
50b3eb4b 4472MODULE_LICENSE("GPL");
b1a48cab 4473MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 4474MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)