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