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