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