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