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