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