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