projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: add a platform device to the spi module
[deliverable/linux.git] / drivers / net / wireless / wl12xx / main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
341b7cde 33#include <linux/wl12xx.h>
95dac04f 34#include <linux/sched.h>
f5fc0f86 35
00d20100 36#include "wl12xx.h"
f5fc0f86 37#include "wl12xx_80211.h"
00d20100
SL		 38#include "reg.h"
39#include "io.h"
40#include "event.h"
41#include "tx.h"
42#include "rx.h"
43#include "ps.h"
44#include "init.h"
45#include "debugfs.h"
46#include "cmd.h"
47#include "boot.h"
48#include "testmode.h"
49#include "scan.h"
f5fc0f86 50
9ccd9217
JO		 51#define WL1271_BOOT_RETRIES 3
52
8a08048a
JO		 53static struct conf_drv_settings default_conf = {
54 .sg = {
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);
f750c820
EP		 2118 ret = wl1271_ps_elp_wakeup(wl);
2119 if (ret < 0)
2120 goto out_unlock;
2121
1d095475
EP		 2122 if (wl->vif) {
2123 wl1271_debug(DEBUG_MAC80211,
2124 "multiple vifs are not supported yet");
2125 ret = -EBUSY;
2126 goto out;
2127 }
2128
2129 /*
2130 * in some very corner case HW recovery scenarios its possible to
2131 * get here before __wl1271_op_remove_interface is complete, so
2132 * opt out if that is the case.
2133 */
10c8cd01
EP		 2134 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2135 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
1d095475
EP		 2136 ret = -EBUSY;
2137 goto out;
2138 }
2139
83587505 2140 ret = wl12xx_init_vif_data(wl, vif);
1d095475
EP		 2141 if (ret < 0)
2142 goto out;
2143
2144 wlvif->wl = wl;
2145 role_type = wl12xx_get_role_type(wl, wlvif);
2146 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2147 ret = -EINVAL;
2148 goto out;
2149 }
2150
2151 /*
2152 * TODO: after the nvs issue will be solved, move this block
2153 * to start(), and make sure here the driver is ON.
2154 */
2155 if (wl->state == WL1271_STATE_OFF) {
2156 /*
2157 * we still need this in order to configure the fw
2158 * while uploading the nvs
2159 */
2160 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
2161
2162 booted = wl12xx_init_fw(wl);
2163 if (!booted) {
2164 ret = -EINVAL;
2165 goto out;
2166 }
2167 }
2168
2169 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2170 wlvif->bss_type == BSS_TYPE_IBSS) {
2171 /*
2172 * The device role is a special role used for
2173 * rx and tx frames prior to association (as
2174 * the STA role can get packets only from
2175 * its associated bssid)
2176 */
2177 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2178 WL1271_ROLE_DEVICE,
2179 &wlvif->dev_role_id);
2180 if (ret < 0)
2181 goto out;
2182 }
2183
2184 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2185 role_type, &wlvif->role_id);
2186 if (ret < 0)
2187 goto out;
2188
2189 ret = wl1271_init_vif_specific(wl, vif);
2190 if (ret < 0)
2191 goto out;
2192
2193 wl->vif = vif;
87627214 2194 list_add(&wlvif->list, &wl->wlvif_list);
10c8cd01 2195 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
a4e4130d
EP		 2196
2197 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2198 wl->ap_count++;
2199 else
2200 wl->sta_count++;
eb5b28d0 2201out:
f750c820
EP		 2202 wl1271_ps_elp_sleep(wl);
2203out_unlock:
f5fc0f86
LC		 2204 mutex_unlock(&wl->mutex);
2205
f9f774c1 2206 mutex_lock(&wl_list_mutex);
eb887dfd 2207 if (!ret)
01c09162 2208 list_add(&wl->list, &wl_list);
f9f774c1 2209 mutex_unlock(&wl_list_mutex);
01c09162 2210
f5fc0f86
LC		 2211 return ret;
2212}
2213
7dece1c8 2214static void __wl1271_op_remove_interface(struct wl1271 *wl,
536129c8 2215 struct ieee80211_vif *vif,
7dece1c8 2216 bool reset_tx_queues)
f5fc0f86 2217{
536129c8 2218 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e5a359f8 2219 int i, ret;
f5fc0f86 2220
1b72aecd 2221 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 2222
10c8cd01
EP		 2223 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2224 return;
2225
13026dec
JO		 2226 /* because of hardware recovery, we may get here twice */
2227 if (wl->state != WL1271_STATE_ON)
2228 return;
2229
1b72aecd 2230 wl1271_info("down");
f5fc0f86 2231
8d2ef7bd 2232 /* enable dyn ps just in case (if left on due to fw crash etc) */
536129c8 2233 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
baf6277a 2234 ieee80211_enable_dyn_ps(vif);
8d2ef7bd 2235
baf6277a
EP		 2236 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2237 wl->scan_vif == vif) {
08688d6b 2238 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 2239 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
784f694d 2240 wl->scan_vif = NULL;
b739a42c 2241 wl->scan.req = NULL;
76a029fb 2242 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 2243 }
2244
b78b47eb
EP		 2245 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2246 /* disable active roles */
2247 ret = wl1271_ps_elp_wakeup(wl);
2248 if (ret < 0)
2249 goto deinit;
2250
536129c8 2251 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
7edebf56 2252 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
04e8079c
EP		 2253 if (ret < 0)
2254 goto deinit;
2255 }
2256
0603d891 2257 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
b78b47eb
EP		 2258 if (ret < 0)
2259 goto deinit;
2260
2261 wl1271_ps_elp_sleep(wl);
2262 }
2263deinit:
e51ae9be 2264 /* clear all hlids (except system_hlid) */
afaf8bdb 2265 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 2266
2267 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2268 wlvif->bss_type == BSS_TYPE_IBSS) {
2269 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2270 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2271 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2272 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2273 } else {
2274 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2275 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2276 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2277 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2278 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2279 wl12xx_free_rate_policy(wl,
2280 &wlvif->ap.ucast_rate_idx[i]);
2281 }
b78b47eb 2282
d6a3cc2e 2283 wl12xx_tx_reset_wlvif(wl, wlvif);
170d0e67 2284 wl1271_free_ap_keys(wl, wlvif);
e4120df9
EP		 2285 if (wl->last_wlvif == wlvif)
2286 wl->last_wlvif = NULL;
87627214 2287 list_del(&wlvif->list);
c7ffb902 2288 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
0603d891 2289 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
7edebf56 2290 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
d6e19d13 2291
a4e4130d
EP		 2292 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2293 wl->ap_count--;
2294 else
2295 wl->sta_count--;
2296
baf6277a 2297 mutex_unlock(&wl->mutex);
9eb599e9
EP		 2298 del_timer_sync(&wlvif->rx_streaming_timer);
2299 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2300 cancel_work_sync(&wlvif->rx_streaming_disable_work);
baf6277a 2301 cancel_delayed_work_sync(&wlvif->pspoll_work);
bd9dc49c 2302
baf6277a 2303 mutex_lock(&wl->mutex);
52a2a375 2304}
bd9dc49c 2305
52a2a375
JO		 2306static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2307 struct ieee80211_vif *vif)
2308{
2309 struct wl1271 *wl = hw->priv;
10c8cd01 2310 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
6e8cd331 2311 struct wl12xx_vif *iter;
52a2a375
JO		 2312
2313 mutex_lock(&wl->mutex);
10c8cd01
EP		 2314
2315 if (wl->state == WL1271_STATE_OFF ||
2316 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2317 goto out;
2318
67353299
JO		 2319 /*
2320 * wl->vif can be null here if someone shuts down the interface
2321 * just when hardware recovery has been started.
2322 */
6e8cd331
EP		 2323 wl12xx_for_each_wlvif(wl, iter) {
2324 if (iter != wlvif)
2325 continue;
2326
536129c8 2327 __wl1271_op_remove_interface(wl, vif, true);
6e8cd331 2328 break;
67353299 2329 }
6e8cd331 2330 WARN_ON(iter != wlvif);
10c8cd01 2331out:
67353299 2332 mutex_unlock(&wl->mutex);
52b0e7a6 2333 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 2334}
2335
87fbcb0f
EP		 2336static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2337 bool set_assoc)
82429d32
JO		 2338{
2339 int ret;
536129c8 2340 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
82429d32 2341
69e5434c
JO		 2342 /*
2343 * One of the side effects of the JOIN command is that is clears
2344 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2345 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2346 * Currently the only valid scenario for JOIN during association
2347 * is on roaming, in which case we will also be given new keys.
2348 * Keep the below message for now, unless it starts bothering
2349 * users who really like to roam a lot :)
69e5434c 2350 */
ba8447f6 2351 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
69e5434c
JO		 2352 wl1271_info("JOIN while associated.");
2353
2354 if (set_assoc)
ba8447f6 2355 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
69e5434c 2356
227e81e1 2357 if (is_ibss)
87fbcb0f 2358 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
227e81e1 2359 else
87fbcb0f 2360 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
82429d32
JO		 2361 if (ret < 0)
2362 goto out;
2363
ba8447f6 2364 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
82429d32
JO		 2365 goto out;
2366
2367 /*
2368 * The join command disable the keep-alive mode, shut down its process,
2369 * and also clear the template config, so we need to reset it all after
2370 * the join. The acx_aid starts the keep-alive process, and the order
2371 * of the commands below is relevant.
2372 */
0603d891 2373 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
82429d32
JO		 2374 if (ret < 0)
2375 goto out;
2376
0603d891 2377 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
82429d32
JO		 2378 if (ret < 0)
2379 goto out;
2380
d2d66c56 2381 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
82429d32
JO		 2382 if (ret < 0)
2383 goto out;
2384
0603d891
EP		 2385 ret = wl1271_acx_keep_alive_config(wl, wlvif,
2386 CMD_TEMPL_KLV_IDX_NULL_DATA,
82429d32
JO		 2387 ACX_KEEP_ALIVE_TPL_VALID);
2388 if (ret < 0)
2389 goto out;
2390
2391out:
2392 return ret;
2393}
2394
0603d891 2395static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
c7f43e45
LC		 2396{
2397 int ret;
2398
52630c5d 2399 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
6e8cd331
EP		 2400 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2401
6d158ff3 2402 wl12xx_cmd_stop_channel_switch(wl);
6e8cd331 2403 ieee80211_chswitch_done(vif, false);
6d158ff3
SL		 2404 }
2405
c7f43e45 2406 /* to stop listening to a channel, we disconnect */
0603d891 2407 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
c7f43e45
LC		 2408 if (ret < 0)
2409 goto out;
2410
b992c682 2411 /* reset TX security counters on a clean disconnect */
48e93e40
EP		 2412 wlvif->tx_security_last_seq_lsb = 0;
2413 wlvif->tx_security_seq = 0;
b992c682 2414
c7f43e45
LC		 2415out:
2416 return ret;
2417}
2418
87fbcb0f 2419static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ebba60c6 2420{
1b92f15e 2421 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
30d0c8fd 2422 wlvif->rate_set = wlvif->basic_rate_set;
ebba60c6
JO		 2423}
2424
251c177f
EP		 2425static bool wl12xx_is_roc(struct wl1271 *wl)
2426{
2427 u8 role_id;
2428
2429 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2430 if (role_id >= WL12XX_MAX_ROLES)
2431 return false;
2432
2433 return true;
2434}
2435
87fbcb0f
EP		 2436static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2437 bool idle)
0d58cbff
JO		 2438{
2439 int ret;
2440
2441 if (idle) {
251c177f
EP		 2442 /* no need to croc if we weren't busy (e.g. during boot) */
2443 if (wl12xx_is_roc(wl)) {
7edebf56 2444 ret = wl12xx_croc(wl, wlvif->dev_role_id);
251c177f
EP		 2445 if (ret < 0)
2446 goto out;
2447
7edebf56 2448 ret = wl12xx_cmd_role_stop_dev(wl, wlvif);
0d58cbff
JO		 2449 if (ret < 0)
2450 goto out;
2451 }
30d0c8fd
EP		 2452 wlvif->rate_set =
2453 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2454 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
0d58cbff
JO		 2455 if (ret < 0)
2456 goto out;
2457 ret = wl1271_acx_keep_alive_config(
0603d891 2458 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
0d58cbff
JO		 2459 ACX_KEEP_ALIVE_TPL_INVALID);
2460 if (ret < 0)
2461 goto out;
2462 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2463 } else {
33c2c06c
LC		 2464 /* The current firmware only supports sched_scan in idle */
2465 if (wl->sched_scanning) {
2466 wl1271_scan_sched_scan_stop(wl);
2467 ieee80211_sched_scan_stopped(wl->hw);
2468 }
2469
7edebf56 2470 ret = wl12xx_cmd_role_start_dev(wl, wlvif);
251c177f
EP		 2471 if (ret < 0)
2472 goto out;
2473
1b92f15e 2474 ret = wl12xx_roc(wl, wlvif, wlvif->dev_role_id);
0d58cbff
JO		 2475 if (ret < 0)
2476 goto out;
2477 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2478 }
2479
2480out:
2481 return ret;
2482}
2483
9f259c4e
EP		 2484static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2485 struct ieee80211_conf *conf, u32 changed)
f5fc0f86 2486{
9f259c4e
EP		 2487 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2488 int channel, ret;
f5fc0f86
LC		 2489
2490 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2491
ebba60c6 2492 /* if the channel changes while joined, join again */
69e5434c 2493 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1b92f15e 2494 ((wlvif->band != conf->channel->band) ||
61f845f4 2495 (wlvif->channel != channel))) {
c6930b07 2496 /* send all pending packets */
a32d0cdf 2497 wl1271_tx_work_locked(wl);
61f845f4
EP		 2498 wlvif->band = conf->channel->band;
2499 wlvif->channel = channel;
ebba60c6 2500
bee0ffec
AN		 2501 if (!is_ap) {
2502 /*
2503 * FIXME: the mac80211 should really provide a fixed
2504 * rate to use here. for now, just use the smallest
2505 * possible rate for the band as a fixed rate for
2506 * association frames and other control messages.
2507 */
ba8447f6 2508 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
87fbcb0f 2509 wl1271_set_band_rate(wl, wlvif);
bee0ffec 2510
d2d66c56 2511 wlvif->basic_rate =
87fbcb0f
EP		 2512 wl1271_tx_min_rate_get(wl,
2513 wlvif->basic_rate_set);
30d0c8fd 2514 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 2515 if (ret < 0)
bee0ffec 2516 wl1271_warning("rate policy for channel "
ebba60c6 2517 "failed %d", ret);
bee0ffec 2518
ba8447f6
EP		 2519 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED,
2520 &wlvif->flags)) {
251c177f
EP		 2521 if (wl12xx_is_roc(wl)) {
2522 /* roaming */
7edebf56
EP		 2523 ret = wl12xx_croc(wl,
2524 wlvif->dev_role_id);
251c177f 2525 if (ret < 0)
9f259c4e 2526 return ret;
251c177f 2527 }
87fbcb0f 2528 ret = wl1271_join(wl, wlvif, false);
bee0ffec
AN		 2529 if (ret < 0)
2530 wl1271_warning("cmd join on channel "
2531 "failed %d", ret);
251c177f
EP		 2532 } else {
2533 /*
2534 * change the ROC channel. do it only if we are
2535 * not idle. otherwise, CROC will be called
2536 * anyway.
2537 */
2538 if (wl12xx_is_roc(wl) &&
2539 !(conf->flags & IEEE80211_CONF_IDLE)) {
7edebf56
EP		 2540 ret = wl12xx_croc(wl,
2541 wlvif->dev_role_id);
251c177f 2542 if (ret < 0)
9f259c4e 2543 return ret;
251c177f 2544
1b92f15e 2545 ret = wl12xx_roc(wl, wlvif,
7edebf56 2546 wlvif->dev_role_id);
251c177f
EP		 2547 if (ret < 0)
2548 wl1271_warning("roc failed %d",
2549 ret);
2550 }
bee0ffec 2551 }
ebba60c6
JO		 2552 }
2553 }
2554
bee0ffec 2555 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
87fbcb0f 2556 ret = wl1271_sta_handle_idle(wl, wlvif,
bee0ffec 2557 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 2558 if (ret < 0)
2559 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 2560 }
2561
90494a90
JO		 2562 /*
2563 * if mac80211 changes the PSM mode, make sure the mode is not
2564 * incorrectly changed after the pspoll failure active window.
2565 */
2566 if (changed & IEEE80211_CONF_CHANGE_PS)
836d6600 2567 clear_bit(WLVIF_FLAG_PSPOLL_FAILURE, &wlvif->flags);
90494a90 2568
71449f8d 2569 if (conf->flags & IEEE80211_CONF_PS &&
c29bb001
EP		 2570 !test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags)) {
2571 set_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags);
f5fc0f86
LC		 2572
2573 /*
2574 * We enter PSM only if we're already associated.
2575 * If we're not, we'll enter it when joining an SSID,
2576 * through the bss_info_changed() hook.
2577 */
ba8447f6 2578 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
18f8d468 2579 wl1271_debug(DEBUG_PSM, "psm enabled");
0603d891
EP		 2580 ret = wl1271_ps_set_mode(wl, wlvif,
2581 STATION_POWER_SAVE_MODE,
d2d66c56 2582 wlvif->basic_rate, true);
af5e084b 2583 }
f5fc0f86 2584 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
c29bb001 2585 test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags)) {
18f8d468 2586 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 2587
c29bb001 2588 clear_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags);
f5fc0f86 2589
c29bb001 2590 if (test_bit(WLVIF_FLAG_PSM, &wlvif->flags))
0603d891
EP		 2591 ret = wl1271_ps_set_mode(wl, wlvif,
2592 STATION_ACTIVE_MODE,
d2d66c56 2593 wlvif->basic_rate, true);
f5fc0f86
LC		 2594 }
2595
6bd65029 2596 if (conf->power_level != wlvif->power_level) {
0603d891 2597 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
f5fc0f86 2598 if (ret < 0)
9f259c4e 2599 return ret;
f5fc0f86 2600
6bd65029 2601 wlvif->power_level = conf->power_level;
f5fc0f86
LC		 2602 }
2603
9f259c4e
EP		 2604 return 0;
2605}
2606
2607static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2608{
2609 struct wl1271 *wl = hw->priv;
2610 struct wl12xx_vif *wlvif;
2611 struct ieee80211_conf *conf = &hw->conf;
2612 int channel, ret = 0;
2613
2614 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2615
2616 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2617 " changed 0x%x",
2618 channel,
2619 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
2620 conf->power_level,
2621 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2622 changed);
2623
2624 /*
2625 * mac80211 will go to idle nearly immediately after transmitting some
2626 * frames, such as the deauth. To make sure those frames reach the air,
2627 * wait here until the TX queue is fully flushed.
2628 */
2629 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2630 (conf->flags & IEEE80211_CONF_IDLE))
2631 wl1271_tx_flush(wl);
2632
2633 mutex_lock(&wl->mutex);
2634
2635 /* we support configuring the channel and band even while off */
2636 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2637 wl->band = conf->channel->band;
2638 wl->channel = channel;
2639 }
2640
2641 if (changed & IEEE80211_CONF_CHANGE_POWER)
2642 wl->power_level = conf->power_level;
2643
2644 if (unlikely(wl->state == WL1271_STATE_OFF))
2645 goto out;
2646
2647 ret = wl1271_ps_elp_wakeup(wl);
2648 if (ret < 0)
2649 goto out;
2650
2651 /* configure each interface */
2652 wl12xx_for_each_wlvif(wl, wlvif) {
2653 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
2654 if (ret < 0)
2655 goto out_sleep;
2656 }
2657
f5fc0f86
LC		 2658out_sleep:
2659 wl1271_ps_elp_sleep(wl);
2660
2661out:
2662 mutex_unlock(&wl->mutex);
2663
2664 return ret;
2665}
2666
b54853f1
JO		 2667struct wl1271_filter_params {
2668 bool enabled;
2669 int mc_list_length;
2670 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2671};
2672
22bedad3
JP		 2673static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2674 struct netdev_hw_addr_list *mc_list)
c87dec9f 2675{
c87dec9f 2676 struct wl1271_filter_params *fp;
22bedad3 2677 struct netdev_hw_addr *ha;
2c10bb9c 2678 struct wl1271 *wl = hw->priv;
c87dec9f 2679
2c10bb9c
SD		 2680 if (unlikely(wl->state == WL1271_STATE_OFF))
2681 return 0;
c87dec9f 2682
74441130 2683 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 2684 if (!fp) {
2685 wl1271_error("Out of memory setting filters.");
2686 return 0;
2687 }
2688
2689 /* update multicast filtering parameters */
c87dec9f 2690 fp->mc_list_length = 0;
22bedad3
JP		 2691 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2692 fp->enabled = false;
2693 } else {
2694 fp->enabled = true;
2695 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 2696 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 2697 ha->addr, ETH_ALEN);
c87dec9f 2698 fp->mc_list_length++;
22bedad3 2699 }
c87dec9f
JO		 2700 }
2701
b54853f1 2702 return (u64)(unsigned long)fp;
c87dec9f 2703}
f5fc0f86 2704
b54853f1
JO		 2705#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2706 FIF_ALLMULTI | \
2707 FIF_FCSFAIL | \
2708 FIF_BCN_PRBRESP_PROMISC | \
2709 FIF_CONTROL | \
2710 FIF_OTHER_BSS)
2711
f5fc0f86
LC		 2712static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2713 unsigned int changed,
c87dec9f 2714 unsigned int *total, u64 multicast)
f5fc0f86 2715{
b54853f1 2716 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2717 struct wl1271 *wl = hw->priv;
6e8cd331 2718 struct wl12xx_vif *wlvif;
536129c8 2719
b54853f1 2720 int ret;
f5fc0f86 2721
7d057869
AN		 2722 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2723 " total %x", changed, *total);
f5fc0f86 2724
b54853f1
JO		 2725 mutex_lock(&wl->mutex);
2726
2c10bb9c
SD		 2727 *total &= WL1271_SUPPORTED_FILTERS;
2728 changed &= WL1271_SUPPORTED_FILTERS;
2729
2730 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2731 goto out;
2732
a620865e 2733 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2734 if (ret < 0)
2735 goto out;
2736
6e8cd331
EP		 2737 wl12xx_for_each_wlvif(wl, wlvif) {
2738 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
2739 if (*total & FIF_ALLMULTI)
2740 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2741 false,
2742 NULL, 0);
2743 else if (fp)
2744 ret = wl1271_acx_group_address_tbl(wl, wlvif,
2745 fp->enabled,
2746 fp->mc_list,
2747 fp->mc_list_length);
2748 if (ret < 0)
2749 goto out_sleep;
2750 }
7d057869 2751 }
f5fc0f86 2752
08c1d1c7
EP		 2753 /*
2754 * the fw doesn't provide an api to configure the filters. instead,
2755 * the filters configuration is based on the active roles / ROC
2756 * state.
2757 */
b54853f1
JO		 2758
2759out_sleep:
2760 wl1271_ps_elp_sleep(wl);
2761
2762out:
2763 mutex_unlock(&wl->mutex);
14b228a0 2764 kfree(fp);
f5fc0f86
LC		 2765}
2766
170d0e67
EP		 2767static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2768 u8 id, u8 key_type, u8 key_size,
2769 const u8 *key, u8 hlid, u32 tx_seq_32,
2770 u16 tx_seq_16)
7f179b46
AN		 2771{
2772 struct wl1271_ap_key *ap_key;
2773 int i;
2774
2775 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2776
2777 if (key_size > MAX_KEY_SIZE)
2778 return -EINVAL;
2779
2780 /*
2781 * Find next free entry in ap_keys. Also check we are not replacing
2782 * an existing key.
2783 */
2784 for (i = 0; i < MAX_NUM_KEYS; i++) {
170d0e67 2785 if (wlvif->ap.recorded_keys[i] == NULL)
7f179b46
AN		 2786 break;
2787
170d0e67 2788 if (wlvif->ap.recorded_keys[i]->id == id) {
7f179b46
AN		 2789 wl1271_warning("trying to record key replacement");
2790 return -EINVAL;
2791 }
2792 }
2793
2794 if (i == MAX_NUM_KEYS)
2795 return -EBUSY;
2796
2797 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2798 if (!ap_key)
2799 return -ENOMEM;
2800
2801 ap_key->id = id;
2802 ap_key->key_type = key_type;
2803 ap_key->key_size = key_size;
2804 memcpy(ap_key->key, key, key_size);
2805 ap_key->hlid = hlid;
2806 ap_key->tx_seq_32 = tx_seq_32;
2807 ap_key->tx_seq_16 = tx_seq_16;
2808
170d0e67 2809 wlvif->ap.recorded_keys[i] = ap_key;
7f179b46
AN		 2810 return 0;
2811}
2812
170d0e67 2813static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
7f179b46
AN		 2814{
2815 int i;
2816
2817 for (i = 0; i < MAX_NUM_KEYS; i++) {
170d0e67
EP		 2818 kfree(wlvif->ap.recorded_keys[i]);
2819 wlvif->ap.recorded_keys[i] = NULL;
7f179b46
AN		 2820 }
2821}
2822
a8ab39a4 2823static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
7f179b46
AN		 2824{
2825 int i, ret = 0;
2826 struct wl1271_ap_key *key;
2827 bool wep_key_added = false;
2828
2829 for (i = 0; i < MAX_NUM_KEYS; i++) {
7f97b487 2830 u8 hlid;
170d0e67 2831 if (wlvif->ap.recorded_keys[i] == NULL)
7f179b46
AN		 2832 break;
2833
170d0e67 2834 key = wlvif->ap.recorded_keys[i];
7f97b487
EP		 2835 hlid = key->hlid;
2836 if (hlid == WL12XX_INVALID_LINK_ID)
a8ab39a4 2837 hlid = wlvif->ap.bcast_hlid;
7f97b487 2838
a8ab39a4 2839 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
7f179b46
AN		 2840 key->id, key->key_type,
2841 key->key_size, key->key,
7f97b487 2842 hlid, key->tx_seq_32,
7f179b46
AN		 2843 key->tx_seq_16);
2844 if (ret < 0)
2845 goto out;
2846
2847 if (key->key_type == KEY_WEP)
2848 wep_key_added = true;
2849 }
2850
2851 if (wep_key_added) {
f75c753f 2852 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
a8ab39a4 2853 wlvif->ap.bcast_hlid);
7f179b46
AN		 2854 if (ret < 0)
2855 goto out;
2856 }
2857
2858out:
170d0e67 2859 wl1271_free_ap_keys(wl, wlvif);
7f179b46
AN		 2860 return ret;
2861}
2862
536129c8
EP		 2863static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2864 u16 action, u8 id, u8 key_type,
7f179b46
AN		 2865 u8 key_size, const u8 *key, u32 tx_seq_32,
2866 u16 tx_seq_16, struct ieee80211_sta *sta)
2867{
2868 int ret;
536129c8 2869 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
7f179b46
AN		 2870
2871 if (is_ap) {
2872 struct wl1271_station *wl_sta;
2873 u8 hlid;
2874
2875 if (sta) {
2876 wl_sta = (struct wl1271_station *)sta->drv_priv;
2877 hlid = wl_sta->hlid;
2878 } else {
a8ab39a4 2879 hlid = wlvif->ap.bcast_hlid;
7f179b46
AN		 2880 }
2881
53d40d0b 2882 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
7f179b46
AN		 2883 /*
2884 * We do not support removing keys after AP shutdown.
2885 * Pretend we do to make mac80211 happy.
2886 */
2887 if (action != KEY_ADD_OR_REPLACE)
2888 return 0;
2889
170d0e67 2890 ret = wl1271_record_ap_key(wl, wlvif, id,
7f179b46
AN		 2891 key_type, key_size,
2892 key, hlid, tx_seq_32,
2893 tx_seq_16);
2894 } else {
a8ab39a4 2895 ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
7f179b46
AN		 2896 id, key_type, key_size,
2897 key, hlid, tx_seq_32,
2898 tx_seq_16);
2899 }
2900
2901 if (ret < 0)
2902 return ret;
2903 } else {
2904 const u8 *addr;
2905 static const u8 bcast_addr[ETH_ALEN] = {
2906 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2907 };
2908
e9eb8cbe
GE		 2909 /*
2910 * A STA set to GEM cipher requires 2 tx spare blocks.
2911 * Return to default value when GEM cipher key is removed
2912 */
2913 if (key_type == KEY_GEM) {
2914 if (action == KEY_ADD_OR_REPLACE)
2915 wl->tx_spare_blocks = 2;
2916 else if (action == KEY_REMOVE)
2917 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2918 }
2919
7f179b46
AN		 2920 addr = sta ? sta->addr : bcast_addr;
2921
2922 if (is_zero_ether_addr(addr)) {
2923 /* We dont support TX only encryption */
2924 return -EOPNOTSUPP;
2925 }
2926
2927 /* The wl1271 does not allow to remove unicast keys - they
2928 will be cleared automatically on next CMD_JOIN. Ignore the
2929 request silently, as we dont want the mac80211 to emit
2930 an error message. */
2931 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2932 return 0;
2933
010d3d30
EP		 2934 /* don't remove key if hlid was already deleted */
2935 if (action == KEY_REMOVE &&
154da67c 2936 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
010d3d30
EP		 2937 return 0;
2938
a8ab39a4 2939 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
7f179b46
AN		 2940 id, key_type, key_size,
2941 key, addr, tx_seq_32,
2942 tx_seq_16);
2943 if (ret < 0)
2944 return ret;
2945
2946 /* the default WEP key needs to be configured at least once */
2947 if (key_type == KEY_WEP) {
c690ec81 2948 ret = wl12xx_cmd_set_default_wep_key(wl,
f75c753f
EP		 2949 wlvif->default_key,
2950 wlvif->sta.hlid);
7f179b46
AN		 2951 if (ret < 0)
2952 return ret;
2953 }
2954 }
2955
2956 return 0;
2957}
2958
f5fc0f86
LC		 2959static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2960 struct ieee80211_vif *vif,
2961 struct ieee80211_sta *sta,
2962 struct ieee80211_key_conf *key_conf)
2963{
2964 struct wl1271 *wl = hw->priv;
536129c8 2965 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
f5fc0f86 2966 int ret;
ac4e4ce5
JO		 2967 u32 tx_seq_32 = 0;
2968 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2969 u8 key_type;
2970
f5fc0f86
LC		 2971 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2972
7f179b46 2973 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2974 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2975 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2976 key_conf->keylen, key_conf->flags);
2977 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2978
f5fc0f86
LC		 2979 mutex_lock(&wl->mutex);
2980
f8d9802f
JO		 2981 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2982 ret = -EAGAIN;
2983 goto out_unlock;
2984 }
2985
a620865e 2986 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2987 if (ret < 0)
2988 goto out_unlock;
2989
97359d12
JB		 2990 switch (key_conf->cipher) {
2991 case WLAN_CIPHER_SUITE_WEP40:
2992 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2993 key_type = KEY_WEP;
2994
2995 key_conf->hw_key_idx = key_conf->keyidx;
2996 break;
97359d12 2997 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2998 key_type = KEY_TKIP;
2999
3000 key_conf->hw_key_idx = key_conf->keyidx;
48e93e40
EP		 3001 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3002 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
f5fc0f86 3003 break;
97359d12 3004 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 3005 key_type = KEY_AES;
3006
3007 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
48e93e40
EP		 3008 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3009 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
f5fc0f86 3010 break;
7a55724e
JO		 3011 case WL1271_CIPHER_SUITE_GEM:
3012 key_type = KEY_GEM;
48e93e40
EP		 3013 tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
3014 tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
7a55724e 3015 break;
f5fc0f86 3016 default:
97359d12 3017 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 3018
3019 ret = -EOPNOTSUPP;
3020 goto out_sleep;
3021 }
3022
3023 switch (cmd) {
3024 case SET_KEY:
536129c8 3025 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
7f179b46
AN		 3026 key_conf->keyidx, key_type,
3027 key_conf->keylen, key_conf->key,
3028 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 3029 if (ret < 0) {
3030 wl1271_error("Could not add or replace key");
3031 goto out_sleep;
3032 }
3033 break;
3034
3035 case DISABLE_KEY:
536129c8 3036 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
7f179b46
AN		 3037 key_conf->keyidx, key_type,
3038 key_conf->keylen, key_conf->key,
3039 0, 0, sta);
f5fc0f86
LC		 3040 if (ret < 0) {
3041 wl1271_error("Could not remove key");
3042 goto out_sleep;
3043 }
3044 break;
3045
3046 default:
3047 wl1271_error("Unsupported key cmd 0x%x", cmd);
3048 ret = -EOPNOTSUPP;
f5fc0f86
LC		 3049 break;
3050 }
3051
3052out_sleep:
3053 wl1271_ps_elp_sleep(wl);
3054
3055out_unlock:
3056 mutex_unlock(&wl->mutex);
3057
f5fc0f86
LC		 3058 return ret;
3059}
3060
3061static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 3062 struct ieee80211_vif *vif,
f5fc0f86
LC		 3063 struct cfg80211_scan_request *req)
3064{
3065 struct wl1271 *wl = hw->priv;
7edebf56
EP		 3066 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3067
f5fc0f86
LC		 3068 int ret;
3069 u8 *ssid = NULL;
abb0b3bf 3070 size_t len = 0;
f5fc0f86
LC		 3071
3072 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3073
3074 if (req->n_ssids) {
3075 ssid = req->ssids[0].ssid;
abb0b3bf 3076 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 3077 }
3078
3079 mutex_lock(&wl->mutex);
3080
b739a42c
JO		 3081 if (wl->state == WL1271_STATE_OFF) {
3082 /*
3083 * We cannot return -EBUSY here because cfg80211 will expect
3084 * a call to ieee80211_scan_completed if we do - in this case
3085 * there won't be any call.
3086 */
3087 ret = -EAGAIN;
3088 goto out;
3089 }
3090
a620865e 3091 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 3092 if (ret < 0)
3093 goto out;
3094
251c177f
EP		 3095 /* cancel ROC before scanning */
3096 if (wl12xx_is_roc(wl)) {
ba8447f6 3097 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
251c177f
EP		 3098 /* don't allow scanning right now */
3099 ret = -EBUSY;
3100 goto out_sleep;
3101 }
7edebf56
EP		 3102 wl12xx_croc(wl, wlvif->dev_role_id);
3103 wl12xx_cmd_role_stop_dev(wl, wlvif);
251c177f 3104 }
f5fc0f86 3105
784f694d 3106 ret = wl1271_scan(hw->priv, vif, ssid, len, req);
251c177f 3107out_sleep:
f5fc0f86 3108 wl1271_ps_elp_sleep(wl);
f5fc0f86
LC		 3109out:
3110 mutex_unlock(&wl->mutex);
3111
3112 return ret;
3113}
3114
73ecce31
EP		 3115static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3116 struct ieee80211_vif *vif)
3117{
3118 struct wl1271 *wl = hw->priv;
3119 int ret;
3120
3121 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3122
3123 mutex_lock(&wl->mutex);
3124
3125 if (wl->state == WL1271_STATE_OFF)
3126 goto out;
3127
3128 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3129 goto out;
3130
3131 ret = wl1271_ps_elp_wakeup(wl);
3132 if (ret < 0)
3133 goto out;
3134
3135 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3136 ret = wl1271_scan_stop(wl);
3137 if (ret < 0)
3138 goto out_sleep;
3139 }
3140 wl->scan.state = WL1271_SCAN_STATE_IDLE;
3141 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
784f694d 3142 wl->scan_vif = NULL;
73ecce31
EP		 3143 wl->scan.req = NULL;
3144 ieee80211_scan_completed(wl->hw, true);
3145
3146out_sleep:
3147 wl1271_ps_elp_sleep(wl);
3148out:
3149 mutex_unlock(&wl->mutex);
3150
3151 cancel_delayed_work_sync(&wl->scan_complete_work);
3152}
3153
33c2c06c
LC		 3154static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3155 struct ieee80211_vif *vif,
3156 struct cfg80211_sched_scan_request *req,
3157 struct ieee80211_sched_scan_ies *ies)
3158{
3159 struct wl1271 *wl = hw->priv;
536129c8 3160 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
33c2c06c
LC		 3161 int ret;
3162
3163 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3164
3165 mutex_lock(&wl->mutex);
3166
3167 ret = wl1271_ps_elp_wakeup(wl);
3168 if (ret < 0)
3169 goto out;
3170
536129c8 3171 ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies);
33c2c06c
LC		 3172 if (ret < 0)
3173 goto out_sleep;
3174
536129c8 3175 ret = wl1271_scan_sched_scan_start(wl, wlvif);
33c2c06c
LC		 3176 if (ret < 0)
3177 goto out_sleep;
3178
3179 wl->sched_scanning = true;
3180
3181out_sleep:
3182 wl1271_ps_elp_sleep(wl);
3183out:
3184 mutex_unlock(&wl->mutex);
3185 return ret;
3186}
3187
3188static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3189 struct ieee80211_vif *vif)
3190{
3191 struct wl1271 *wl = hw->priv;
3192 int ret;
3193
3194 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3195
3196 mutex_lock(&wl->mutex);
3197
3198 ret = wl1271_ps_elp_wakeup(wl);
3199 if (ret < 0)
3200 goto out;
3201
3202 wl1271_scan_sched_scan_stop(wl);
3203
3204 wl1271_ps_elp_sleep(wl);
3205out:
3206 mutex_unlock(&wl->mutex);
3207}
3208
68d069c4
AN		 3209static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3210{
3211 struct wl1271 *wl = hw->priv;
3212 int ret = 0;
3213
3214 mutex_lock(&wl->mutex);
3215
3216 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3217 ret = -EAGAIN;
3218 goto out;
3219 }
3220
a620865e 3221 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 3222 if (ret < 0)
3223 goto out;
3224
5f704d18 3225 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 3226 if (ret < 0)
3227 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3228
3229 wl1271_ps_elp_sleep(wl);
3230
3231out:
3232 mutex_unlock(&wl->mutex);
3233
3234 return ret;
3235}
3236
f5fc0f86
LC		 3237static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3238{
3239 struct wl1271 *wl = hw->priv;
6e8cd331 3240 struct wl12xx_vif *wlvif;
aecb0565 3241 int ret = 0;
f5fc0f86
LC		 3242
3243 mutex_lock(&wl->mutex);
3244
f8d9802f
JO		 3245 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3246 ret = -EAGAIN;
aecb0565 3247 goto out;
f8d9802f 3248 }
aecb0565 3249
a620865e 3250 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 3251 if (ret < 0)
3252 goto out;
3253
6e8cd331
EP		 3254 wl12xx_for_each_wlvif(wl, wlvif) {
3255 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3256 if (ret < 0)
3257 wl1271_warning("set rts threshold failed: %d", ret);
3258 }
f5fc0f86
LC		 3259 wl1271_ps_elp_sleep(wl);
3260
3261out:
3262 mutex_unlock(&wl->mutex);
3263
3264 return ret;
3265}
3266
1fe9f161 3267static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
2f6724b2 3268 int offset)
30240fc7 3269{
1fe9f161 3270 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
889cb360
EP		 3271 u8 ssid_len;
3272 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3273 skb->len - offset);
30240fc7 3274
889cb360
EP		 3275 if (!ptr) {
3276 wl1271_error("No SSID in IEs!");
3277 return -ENOENT;
3278 }
3279
3280 ssid_len = ptr[1];
3281 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3282 wl1271_error("SSID is too long!");
3283 return -EINVAL;
30240fc7 3284 }
e78a287a 3285
1fe9f161
EP		 3286 wlvif->ssid_len = ssid_len;
3287 memcpy(wlvif->ssid, ptr+2, ssid_len);
889cb360 3288 return 0;
30240fc7
JO		 3289}
3290
d48055d9
EP		 3291static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3292{
3293 int len;
3294 const u8 *next, *end = skb->data + skb->len;
3295 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3296 skb->len - ieoffset);
3297 if (!ie)
3298 return;
3299 len = ie[1] + 2;
3300 next = ie + len;
3301 memmove(ie, next, end - next);
3302 skb_trim(skb, skb->len - len);
3303}
3304
26b4bf2e
EP		 3305static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3306 unsigned int oui, u8 oui_type,
3307 int ieoffset)
3308{
3309 int len;
3310 const u8 *next, *end = skb->data + skb->len;
3311 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3312 skb->data + ieoffset,
3313 skb->len - ieoffset);
3314 if (!ie)
3315 return;
3316 len = ie[1] + 2;
3317 next = ie + len;
3318 memmove(ie, next, end - next);
3319 skb_trim(skb, skb->len - len);
3320}
3321
68eaaf6e 3322static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl,
1fe9f161 3323 struct ieee80211_vif *vif,
68eaaf6e
AN		 3324 u8 *probe_rsp_data,
3325 size_t probe_rsp_len,
3326 u32 rates)
3327{
1fe9f161
EP		 3328 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3329 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
68eaaf6e
AN		 3330 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3331 int ssid_ie_offset, ie_offset, templ_len;
3332 const u8 *ptr;
3333
3334 /* no need to change probe response if the SSID is set correctly */
1fe9f161 3335 if (wlvif->ssid_len > 0)
68eaaf6e
AN		 3336 return wl1271_cmd_template_set(wl,
3337 CMD_TEMPL_AP_PROBE_RESPONSE,
3338 probe_rsp_data,
3339 probe_rsp_len, 0,
3340 rates);
3341
3342 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3343 wl1271_error("probe_rsp template too big");
3344 return -EINVAL;
3345 }
3346
3347 /* start searching from IE offset */
3348 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3349
3350 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3351 probe_rsp_len - ie_offset);
3352 if (!ptr) {
3353 wl1271_error("No SSID in beacon!");
3354 return -EINVAL;
3355 }
3356
3357 ssid_ie_offset = ptr - probe_rsp_data;
3358 ptr += (ptr[1] + 2);
3359
3360 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3361
3362 /* insert SSID from bss_conf */
3363 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3364 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3365 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3366 bss_conf->ssid, bss_conf->ssid_len);
3367 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3368
3369 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3370 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3371 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3372
3373 return wl1271_cmd_template_set(wl,
3374 CMD_TEMPL_AP_PROBE_RESPONSE,
3375 probe_rsp_templ,
3376 templ_len, 0,
3377 rates);
3378}
3379
e78a287a 3380static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
0603d891 3381 struct ieee80211_vif *vif,
f5fc0f86
LC		 3382 struct ieee80211_bss_conf *bss_conf,
3383 u32 changed)
3384{
0603d891 3385 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3386 int ret = 0;
f5fc0f86 3387
e78a287a
AN		 3388 if (changed & BSS_CHANGED_ERP_SLOT) {
3389 if (bss_conf->use_short_slot)
0603d891 3390 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
e78a287a 3391 else
0603d891 3392 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
e78a287a
AN		 3393 if (ret < 0) {
3394 wl1271_warning("Set slot time failed %d", ret);
3395 goto out;
3396 }
3397 }
f5fc0f86 3398
e78a287a
AN		 3399 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3400 if (bss_conf->use_short_preamble)
0603d891 3401 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
e78a287a 3402 else
0603d891 3403 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
e78a287a 3404 }
f5fc0f86 3405
e78a287a
AN		 3406 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3407 if (bss_conf->use_cts_prot)
0603d891
EP		 3408 ret = wl1271_acx_cts_protect(wl, wlvif,
3409 CTSPROTECT_ENABLE);
e78a287a 3410 else
0603d891
EP		 3411 ret = wl1271_acx_cts_protect(wl, wlvif,
3412 CTSPROTECT_DISABLE);
e78a287a
AN		 3413 if (ret < 0) {
3414 wl1271_warning("Set ctsprotect failed %d", ret);
3415 goto out;
3416 }
3417 }
f8d9802f 3418
e78a287a
AN		 3419out:
3420 return ret;
3421}
f5fc0f86 3422
e78a287a
AN		 3423static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3424 struct ieee80211_vif *vif,
3425 struct ieee80211_bss_conf *bss_conf,
3426 u32 changed)
3427{
87fbcb0f 3428 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
536129c8 3429 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 3430 int ret = 0;
3431
3432 if ((changed & BSS_CHANGED_BEACON_INT)) {
3433 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 3434 bss_conf->beacon_int);
3435
6a899796 3436 wlvif->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 3437 }
3438
e78a287a
AN		 3439 if ((changed & BSS_CHANGED_BEACON)) {
3440 struct ieee80211_hdr *hdr;
af7fbb28 3441 u32 min_rate;
e78a287a
AN		 3442 int ieoffset = offsetof(struct ieee80211_mgmt,
3443 u.beacon.variable);
3444 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3445 u16 tmpl_id;
3446
3447 if (!beacon)
3448 goto out;
3449
3450 wl1271_debug(DEBUG_MASTER, "beacon updated");
3451
1fe9f161 3452 ret = wl1271_ssid_set(vif, beacon, ieoffset);
e78a287a
AN		 3453 if (ret < 0) {
3454 dev_kfree_skb(beacon);
3455 goto out;
3456 }
87fbcb0f 3457 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
e78a287a
AN		 3458 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3459 CMD_TEMPL_BEACON;
3460 ret = wl1271_cmd_template_set(wl, tmpl_id,
3461 beacon->data,
3462 beacon->len, 0,
af7fbb28 3463 min_rate);
e78a287a
AN		 3464 if (ret < 0) {
3465 dev_kfree_skb(beacon);
3466 goto out;
3467 }
3468
d48055d9
EP		 3469 /* remove TIM ie from probe response */
3470 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3471
26b4bf2e
EP		 3472 /*
3473 * remove p2p ie from probe response.
3474 * the fw reponds to probe requests that don't include
3475 * the p2p ie. probe requests with p2p ie will be passed,
3476 * and will be responded by the supplicant (the spec
3477 * forbids including the p2p ie when responding to probe
3478 * requests that didn't include it).
3479 */
3480 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3481 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3482
e78a287a
AN		 3483 hdr = (struct ieee80211_hdr *) beacon->data;
3484 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3485 IEEE80211_STYPE_PROBE_RESP);
68eaaf6e 3486 if (is_ap)
1fe9f161 3487 ret = wl1271_ap_set_probe_resp_tmpl(wl, vif,
68eaaf6e
AN		 3488 beacon->data,
3489 beacon->len,
af7fbb28 3490 min_rate);
68eaaf6e
AN		 3491 else
3492 ret = wl1271_cmd_template_set(wl,
3493 CMD_TEMPL_PROBE_RESPONSE,
3494 beacon->data,
3495 beacon->len, 0,
af7fbb28 3496 min_rate);
e78a287a
AN		 3497 dev_kfree_skb(beacon);
3498 if (ret < 0)
3499 goto out;
3500 }
3501
3502out:
3503 return ret;
3504}
3505
3506/* AP mode changes */
3507static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3508 struct ieee80211_vif *vif,
3509 struct ieee80211_bss_conf *bss_conf,
3510 u32 changed)
3511{
87fbcb0f 3512 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3513 int ret = 0;
e0d8bbf0 3514
e78a287a
AN		 3515 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3516 u32 rates = bss_conf->basic_rates;
5da11dcd 3517
87fbcb0f 3518 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3519 wlvif->band);
d2d66c56 3520 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
87fbcb0f 3521 wlvif->basic_rate_set);
70f47424 3522
87fbcb0f 3523 ret = wl1271_init_ap_rates(wl, wlvif);
e78a287a 3524 if (ret < 0) {
70f47424 3525 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 3526 goto out;
3527 }
c45a85b5 3528
784f694d 3529 ret = wl1271_ap_init_templates(wl, vif);
c45a85b5
AN		 3530 if (ret < 0)
3531 goto out;
e78a287a 3532 }
2f6724b2 3533
e78a287a
AN		 3534 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3535 if (ret < 0)
3536 goto out;
30240fc7 3537
e78a287a
AN		 3538 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3539 if (bss_conf->enable_beacon) {
53d40d0b 3540 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
87fbcb0f 3541 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
e78a287a
AN		 3542 if (ret < 0)
3543 goto out;
e0d8bbf0 3544
a8ab39a4 3545 ret = wl1271_ap_init_hwenc(wl, wlvif);
7f179b46
AN		 3546 if (ret < 0)
3547 goto out;
cf42039f 3548
53d40d0b 3549 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
cf42039f 3550 wl1271_debug(DEBUG_AP, "started AP");
e0d8bbf0 3551 }
e78a287a 3552 } else {
53d40d0b 3553 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
0603d891 3554 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
e78a287a
AN		 3555 if (ret < 0)
3556 goto out;
e0d8bbf0 3557
53d40d0b 3558 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
e78a287a
AN		 3559 wl1271_debug(DEBUG_AP, "stopped AP");
3560 }
3561 }
3562 }
e0d8bbf0 3563
0603d891 3564 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 3565 if (ret < 0)
3566 goto out;
0b932ab9
AN		 3567
3568 /* Handle HT information change */
3569 if ((changed & BSS_CHANGED_HT) &&
3570 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0603d891 3571 ret = wl1271_acx_set_ht_information(wl, wlvif,
0b932ab9
AN		 3572 bss_conf->ht_operation_mode);
3573 if (ret < 0) {
3574 wl1271_warning("Set ht information failed %d", ret);
3575 goto out;
3576 }
3577 }
3578
e78a287a
AN		 3579out:
3580 return;
3581}
8bf29b0e 3582
e78a287a
AN		 3583/* STA/IBSS mode changes */
3584static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3585 struct ieee80211_vif *vif,
3586 struct ieee80211_bss_conf *bss_conf,
3587 u32 changed)
3588{
87fbcb0f 3589 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3590 bool do_join = false, set_assoc = false;
536129c8 3591 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
227e81e1 3592 bool ibss_joined = false;
72c2d9e5 3593 u32 sta_rate_set = 0;
e78a287a 3594 int ret;
2d6e4e76 3595 struct ieee80211_sta *sta;
a100885d
AN		 3596 bool sta_exists = false;
3597 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 3598
3599 if (is_ibss) {
3600 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3601 changed);
3602 if (ret < 0)
3603 goto out;
e0d8bbf0
JO		 3604 }
3605
227e81e1
EP		 3606 if (changed & BSS_CHANGED_IBSS) {
3607 if (bss_conf->ibss_joined) {
eee514e3 3608 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
227e81e1
EP		 3609 ibss_joined = true;
3610 } else {
eee514e3
EP		 3611 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3612 &wlvif->flags)) {
0603d891 3613 wl1271_unjoin(wl, wlvif);
7edebf56 3614 wl12xx_cmd_role_start_dev(wl, wlvif);
1b92f15e 3615 wl12xx_roc(wl, wlvif, wlvif->dev_role_id);
227e81e1
EP		 3616 }
3617 }
3618 }
3619
3620 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
e78a287a
AN		 3621 do_join = true;
3622
3623 /* Need to update the SSID (for filtering etc) */
227e81e1 3624 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
e78a287a
AN		 3625 do_join = true;
3626
227e81e1 3627 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
5da11dcd
JO		 3628 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3629 bss_conf->enable_beacon ? "enabled" : "disabled");
3630
5da11dcd
JO		 3631 do_join = true;
3632 }
3633
e78a287a 3634 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 3635 bool enable = false;
3636 if (bss_conf->cqm_rssi_thold)
3637 enable = true;
0603d891 3638 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
00236aed
JO		 3639 bss_conf->cqm_rssi_thold,
3640 bss_conf->cqm_rssi_hyst);
3641 if (ret < 0)
3642 goto out;
04324d99 3643 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
00236aed
JO		 3644 }
3645
cdf09495
EP		 3646 if (changed & BSS_CHANGED_BSSID)
3647 if (!is_zero_ether_addr(bss_conf->bssid)) {
d2d66c56 3648 ret = wl12xx_cmd_build_null_data(wl, wlvif);
fa287b8f
EP		 3649 if (ret < 0)
3650 goto out;
30240fc7 3651
784f694d 3652 ret = wl1271_build_qos_null_data(wl, vif);
fa287b8f
EP		 3653 if (ret < 0)
3654 goto out;
30240fc7 3655
fa287b8f
EP		 3656 /* Need to update the BSSID (for filtering etc) */
3657 do_join = true;
3658 }
30240fc7 3659
0f9c8250
AN		 3660 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3661 rcu_read_lock();
3662 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3663 if (!sta)
3664 goto sta_not_found;
3665
72c2d9e5
EP		 3666 /* save the supp_rates of the ap */
3667 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3668 if (sta->ht_cap.ht_supported)
3669 sta_rate_set |=
3670 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 3671 sta_ht_cap = sta->ht_cap;
3672 sta_exists = true;
72c2d9e5 3673
0f9c8250
AN		 3674sta_not_found:
3675 rcu_read_unlock();
72c2d9e5 3676 }
72c2d9e5 3677
e78a287a 3678 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 3679 if (bss_conf->assoc) {
ebba60c6 3680 u32 rates;
2f6724b2 3681 int ieoffset;
6840e37a 3682 wlvif->aid = bss_conf->aid;
69e5434c 3683 set_assoc = true;
f5fc0f86 3684
74ec8395 3685 wlvif->ps_poll_failures = 0;
90494a90 3686
ebba60c6
JO		 3687 /*
3688 * use basic rates from AP, and determine lowest rate
3689 * to use with control frames.
3690 */
3691 rates = bss_conf->basic_rates;
87fbcb0f 3692 wlvif->basic_rate_set =
af7fbb28 3693 wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3694 wlvif->band);
d2d66c56 3695 wlvif->basic_rate =
87fbcb0f
EP		 3696 wl1271_tx_min_rate_get(wl,
3697 wlvif->basic_rate_set);
72c2d9e5 3698 if (sta_rate_set)
30d0c8fd
EP		 3699 wlvif->rate_set =
3700 wl1271_tx_enabled_rates_get(wl,
af7fbb28 3701 sta_rate_set,
1b92f15e 3702 wlvif->band);
30d0c8fd 3703 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 3704 if (ret < 0)
e78a287a 3705 goto out;
ebba60c6 3706
ae751bab
LC		 3707 /*
3708 * with wl1271, we don't need to update the
3709 * beacon_int and dtim_period, because the firmware
3710 * updates it by itself when the first beacon is
3711 * received after a join.
3712 */
6840e37a 3713 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
f5fc0f86 3714 if (ret < 0)
e78a287a 3715 goto out;
f5fc0f86 3716
c2b2d99b 3717 /*
2f6724b2 3718 * Get a template for hardware connection maintenance
c2b2d99b 3719 */
bddb29b8
EP		 3720 dev_kfree_skb(wlvif->probereq);
3721 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
83587505 3722 wlvif,
bddb29b8 3723 NULL);
2f6724b2
JO		 3724 ieoffset = offsetof(struct ieee80211_mgmt,
3725 u.probe_req.variable);
bddb29b8 3726 wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
c2b2d99b 3727
6ccbb92e 3728 /* enable the connection monitoring feature */
0603d891 3729 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
f5fc0f86 3730 if (ret < 0)
e78a287a 3731 goto out;
d94cd297
JO		 3732 } else {
3733 /* use defaults when not associated */
30df14d0 3734 bool was_assoc =
ba8447f6
EP		 3735 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
3736 &wlvif->flags);
251c177f 3737 bool was_ifup =
8181aecc
EP		 3738 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
3739 &wlvif->flags);
6840e37a 3740 wlvif->aid = 0;
6ccbb92e 3741
2f6724b2 3742 /* free probe-request template */
bddb29b8
EP		 3743 dev_kfree_skb(wlvif->probereq);
3744 wlvif->probereq = NULL;
2f6724b2 3745
8d2ef7bd 3746 /* re-enable dynamic ps - just in case */
6e8cd331 3747 ieee80211_enable_dyn_ps(vif);
8d2ef7bd 3748
ebba60c6 3749 /* revert back to minimum rates for the current band */
87fbcb0f 3750 wl1271_set_band_rate(wl, wlvif);
d2d66c56 3751 wlvif->basic_rate =
87fbcb0f
EP		 3752 wl1271_tx_min_rate_get(wl,
3753 wlvif->basic_rate_set);
30d0c8fd 3754 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 3755 if (ret < 0)
e78a287a 3756 goto out;
ebba60c6 3757
6ccbb92e 3758 /* disable connection monitor features */
0603d891 3759 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
c1899554
JO		 3760
3761 /* Disable the keep-alive feature */
0603d891 3762 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
6ccbb92e 3763 if (ret < 0)
e78a287a 3764 goto out;
b84a7d3d
JO		 3765
3766 /* restore the bssid filter and go to dummy bssid */
30df14d0 3767 if (was_assoc) {
251c177f
EP		 3768 u32 conf_flags = wl->hw->conf.flags;
3769 /*
3770 * we might have to disable roc, if there was
3771 * no IF_OPER_UP notification.
3772 */
3773 if (!was_ifup) {
0603d891 3774 ret = wl12xx_croc(wl, wlvif->role_id);
251c177f
EP		 3775 if (ret < 0)
3776 goto out;
3777 }
3778 /*
3779 * (we also need to disable roc in case of
3780 * roaming on the same channel. until we will
3781 * have a better flow...)
3782 */
7edebf56
EP		 3783 if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
3784 ret = wl12xx_croc(wl,
3785 wlvif->dev_role_id);
251c177f
EP		 3786 if (ret < 0)
3787 goto out;
3788 }
3789
0603d891 3790 wl1271_unjoin(wl, wlvif);
251c177f 3791 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
7edebf56 3792 wl12xx_cmd_role_start_dev(wl, wlvif);
1b92f15e
EP		 3793 wl12xx_roc(wl, wlvif,
3794 wlvif->dev_role_id);
251c177f 3795 }
30df14d0 3796 }
f5fc0f86 3797 }
f5fc0f86
LC		 3798 }
3799
d192d268
EP		 3800 if (changed & BSS_CHANGED_IBSS) {
3801 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3802 bss_conf->ibss_joined);
3803
3804 if (bss_conf->ibss_joined) {
3805 u32 rates = bss_conf->basic_rates;
87fbcb0f 3806 wlvif->basic_rate_set =
af7fbb28 3807 wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3808 wlvif->band);
d2d66c56 3809 wlvif->basic_rate =
87fbcb0f
EP		 3810 wl1271_tx_min_rate_get(wl,
3811 wlvif->basic_rate_set);
d192d268 3812
06b660e1 3813 /* by default, use 11b + OFDM rates */
30d0c8fd
EP		 3814 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3815 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
d192d268
EP		 3816 if (ret < 0)
3817 goto out;
3818 }
3819 }
3820
0603d891 3821 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 3822 if (ret < 0)
3823 goto out;
f5fc0f86 3824
ca52a5eb
JO		 3825 if (changed & BSS_CHANGED_ARP_FILTER) {
3826 __be32 addr = bss_conf->arp_addr_list[0];
536129c8 3827 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
ca52a5eb 3828
c5312772
EP		 3829 if (bss_conf->arp_addr_cnt == 1 &&
3830 bss_conf->arp_filter_enabled) {
3831 /*
3832 * The template should have been configured only upon
3833 * association. however, it seems that the correct ip
3834 * isn't being set (when sending), so we have to
3835 * reconfigure the template upon every ip change.
3836 */
d2d66c56 3837 ret = wl1271_cmd_build_arp_rsp(wl, wlvif, addr);
c5312772
EP		 3838 if (ret < 0) {
3839 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 3840 goto out;
c5312772
EP		 3841 }
3842
0603d891 3843 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
e5e2f24b 3844 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 3845 addr);
3846 } else
0603d891 3847 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
ca52a5eb
JO		 3848
3849 if (ret < 0)
e78a287a 3850 goto out;
ca52a5eb
JO		 3851 }
3852
8bf29b0e 3853 if (do_join) {
87fbcb0f 3854 ret = wl1271_join(wl, wlvif, set_assoc);
8bf29b0e
JO		 3855 if (ret < 0) {
3856 wl1271_warning("cmd join failed %d", ret);
e78a287a 3857 goto out;
8bf29b0e 3858 }
251c177f
EP		 3859
3860 /* ROC until connected (after EAPOL exchange) */
3861 if (!is_ibss) {
1b92f15e 3862 ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
251c177f
EP		 3863 if (ret < 0)
3864 goto out;
3865
ba8447f6 3866 wl1271_check_operstate(wl, wlvif,
251c177f
EP		 3867 ieee80211_get_operstate(vif));
3868 }
3869 /*
3870 * stop device role if started (we might already be in
3871 * STA role). TODO: make it better.
3872 */
7edebf56
EP		 3873 if (wlvif->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3874 ret = wl12xx_croc(wl, wlvif->dev_role_id);
251c177f
EP		 3875 if (ret < 0)
3876 goto out;
3877
7edebf56 3878 ret = wl12xx_cmd_role_stop_dev(wl, wlvif);
251c177f
EP		 3879 if (ret < 0)
3880 goto out;
3881 }
05dba355
EP		 3882
3883 /* If we want to go in PSM but we're not there yet */
c29bb001
EP		 3884 if (test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags) &&
3885 !test_bit(WLVIF_FLAG_PSM, &wlvif->flags)) {
05dba355
EP		 3886 enum wl1271_cmd_ps_mode mode;
3887
3888 mode = STATION_POWER_SAVE_MODE;
0603d891 3889 ret = wl1271_ps_set_mode(wl, wlvif, mode,
d2d66c56 3890 wlvif->basic_rate,
05dba355
EP		 3891 true);
3892 if (ret < 0)
3893 goto out;
3894 }
c1899554
JO		 3895 }
3896
0b932ab9 3897 /* Handle new association with HT. Do this after join. */
0f9c8250
AN		 3898 if (sta_exists) {
3899 if ((changed & BSS_CHANGED_HT) &&
3900 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0b932ab9
AN		 3901 ret = wl1271_acx_set_ht_capabilities(wl,
3902 &sta_ht_cap,
3903 true,
154da67c 3904 wlvif->sta.hlid);
0f9c8250
AN		 3905 if (ret < 0) {
3906 wl1271_warning("Set ht cap true failed %d",
3907 ret);
3908 goto out;
3909 }
3910 }
3911 /* handle new association without HT and disassociation */
3912 else if (changed & BSS_CHANGED_ASSOC) {
0b932ab9
AN		 3913 ret = wl1271_acx_set_ht_capabilities(wl,
3914 &sta_ht_cap,
3915 false,
154da67c 3916 wlvif->sta.hlid);
0f9c8250
AN		 3917 if (ret < 0) {
3918 wl1271_warning("Set ht cap false failed %d",
3919 ret);
3920 goto out;
3921 }
3922 }
3923 }
3924
0b932ab9
AN		 3925 /* Handle HT information change. Done after join. */
3926 if ((changed & BSS_CHANGED_HT) &&
0f9c8250 3927 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0603d891 3928 ret = wl1271_acx_set_ht_information(wl, wlvif,
0f9c8250
AN		 3929 bss_conf->ht_operation_mode);
3930 if (ret < 0) {
3931 wl1271_warning("Set ht information failed %d", ret);
3932 goto out;
3933 }
3934 }
3935
e78a287a
AN		 3936out:
3937 return;
3938}
3939
3940static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3941 struct ieee80211_vif *vif,
3942 struct ieee80211_bss_conf *bss_conf,
3943 u32 changed)
3944{
3945 struct wl1271 *wl = hw->priv;
536129c8
EP		 3946 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3947 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 3948 int ret;
3949
3950 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3951 (int)changed);
3952
3953 mutex_lock(&wl->mutex);
3954
3955 if (unlikely(wl->state == WL1271_STATE_OFF))
3956 goto out;
3957
10c8cd01
EP		 3958 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
3959 goto out;
3960
a620865e 3961 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3962 if (ret < 0)
3963 goto out;
3964
3965 if (is_ap)
3966 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3967 else
3968 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3969
f5fc0f86
LC		 3970 wl1271_ps_elp_sleep(wl);
3971
3972out:
3973 mutex_unlock(&wl->mutex);
3974}
3975
8a3a3c85
EP		 3976static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
3977 struct ieee80211_vif *vif, u16 queue,
c6999d83
KV		 3978 const struct ieee80211_tx_queue_params *params)
3979{
3980 struct wl1271 *wl = hw->priv;
0603d891 3981 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4695dc91 3982 u8 ps_scheme;
488fc540 3983 int ret = 0;
c6999d83
KV		 3984
3985 mutex_lock(&wl->mutex);
3986
3987 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3988
4695dc91
KV		 3989 if (params->uapsd)
3990 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3991 else
3992 ps_scheme = CONF_PS_SCHEME_LEGACY;
3993
488fc540
AN		 3994 if (wl->state == WL1271_STATE_OFF) {
3995 /*
3996 * If the state is off, the parameters will be recorded and
3997 * configured on init. This happens in AP-mode.
3998 */
3999 struct conf_tx_ac_category *conf_ac =
4000 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
4001 struct conf_tx_tid *conf_tid =
4002 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
4003
4004 conf_ac->ac = wl1271_tx_get_queue(queue);
4005 conf_ac->cw_min = (u8)params->cw_min;
4006 conf_ac->cw_max = params->cw_max;
4007 conf_ac->aifsn = params->aifs;
4008 conf_ac->tx_op_limit = params->txop << 5;
4009
4010 conf_tid->queue_id = wl1271_tx_get_queue(queue);
4011 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
4012 conf_tid->tsid = wl1271_tx_get_queue(queue);
4013 conf_tid->ps_scheme = ps_scheme;
4014 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
4015 conf_tid->apsd_conf[0] = 0;
4016 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 4017 goto out;
4018 }
488fc540 4019
c1b193eb
EP		 4020 ret = wl1271_ps_elp_wakeup(wl);
4021 if (ret < 0)
4022 goto out;
488fc540 4023
c1b193eb
EP		 4024 /*
4025 * the txop is confed in units of 32us by the mac80211,
4026 * we need us
4027 */
0603d891 4028 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4029 params->cw_min, params->cw_max,
4030 params->aifs, params->txop << 5);
4031 if (ret < 0)
4032 goto out_sleep;
4033
0603d891 4034 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4035 CONF_CHANNEL_TYPE_EDCF,
4036 wl1271_tx_get_queue(queue),
4037 ps_scheme, CONF_ACK_POLICY_LEGACY,
4038 0, 0);
c82c1dde
KV		 4039
4040out_sleep:
c1b193eb 4041 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 4042
4043out:
4044 mutex_unlock(&wl->mutex);
4045
4046 return ret;
4047}
4048
37a41b4a
EP		 4049static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4050 struct ieee80211_vif *vif)
bbbb538e
JO		 4051{
4052
4053 struct wl1271 *wl = hw->priv;
4054 u64 mactime = ULLONG_MAX;
4055 int ret;
4056
4057 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4058
4059 mutex_lock(&wl->mutex);
4060
f8d9802f
JO		 4061 if (unlikely(wl->state == WL1271_STATE_OFF))
4062 goto out;
4063
a620865e 4064 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 4065 if (ret < 0)
4066 goto out;
4067
4068 ret = wl1271_acx_tsf_info(wl, &mactime);
4069 if (ret < 0)
4070 goto out_sleep;
4071
4072out_sleep:
4073 wl1271_ps_elp_sleep(wl);
4074
4075out:
4076 mutex_unlock(&wl->mutex);
4077 return mactime;
4078}
f5fc0f86 4079
ece550d0
JL		 4080static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4081 struct survey_info *survey)
4082{
4083 struct wl1271 *wl = hw->priv;
4084 struct ieee80211_conf *conf = &hw->conf;
b739a42c 4085
ece550d0
JL		 4086 if (idx != 0)
4087 return -ENOENT;
b739a42c 4088
ece550d0
JL		 4089 survey->channel = conf->channel;
4090 survey->filled = SURVEY_INFO_NOISE_DBM;
4091 survey->noise = wl->noise;
b739a42c 4092
ece550d0
JL		 4093 return 0;
4094}
4095
409622ec 4096static int wl1271_allocate_sta(struct wl1271 *wl,
c7ffb902
EP		 4097 struct wl12xx_vif *wlvif,
4098 struct ieee80211_sta *sta)
f84f7d78
AN		 4099{
4100 struct wl1271_station *wl_sta;
c7ffb902 4101 int ret;
f84f7d78 4102
c7ffb902
EP		 4103
4104 if (wl->active_sta_count >= AP_MAX_STATIONS) {
f84f7d78
AN		 4105 wl1271_warning("could not allocate HLID - too much stations");
4106 return -EBUSY;
4107 }
4108
4109 wl_sta = (struct wl1271_station *)sta->drv_priv;
c7ffb902
EP		 4110 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4111 if (ret < 0) {
4112 wl1271_warning("could not allocate HLID - too many links");
4113 return -EBUSY;
4114 }
4115
4116 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
b622d992 4117 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
da03209e 4118 wl->active_sta_count++;
f84f7d78
AN		 4119 return 0;
4120}
4121
c7ffb902 4122void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
f84f7d78 4123{
c7ffb902 4124 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
f1acea9a
AN		 4125 return;
4126
c7ffb902 4127 clear_bit(hlid, wlvif->ap.sta_hlid_map);
b622d992 4128 memset(wl->links[hlid].addr, 0, ETH_ALEN);
0f9c8250 4129 wl->links[hlid].ba_bitmap = 0;
a8c0ddb5 4130 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 4131 __clear_bit(hlid, &wl->ap_ps_map);
4132 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
c7ffb902 4133 wl12xx_free_link(wl, wlvif, &hlid);
da03209e 4134 wl->active_sta_count--;
f84f7d78
AN		 4135}
4136
4137static int wl1271_op_sta_add(struct ieee80211_hw *hw,
4138 struct ieee80211_vif *vif,
4139 struct ieee80211_sta *sta)
4140{
4141 struct wl1271 *wl = hw->priv;
536129c8 4142 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
c7ffb902 4143 struct wl1271_station *wl_sta;
f84f7d78
AN		 4144 int ret = 0;
4145 u8 hlid;
4146
4147 mutex_lock(&wl->mutex);
4148
4149 if (unlikely(wl->state == WL1271_STATE_OFF))
4150 goto out;
4151
536129c8 4152 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
f84f7d78
AN		 4153 goto out;
4154
4155 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4156
c7ffb902 4157 ret = wl1271_allocate_sta(wl, wlvif, sta);
f84f7d78
AN		 4158 if (ret < 0)
4159 goto out;
4160
c7ffb902
EP		 4161 wl_sta = (struct wl1271_station *)sta->drv_priv;
4162 hlid = wl_sta->hlid;
4163
a620865e 4164 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 4165 if (ret < 0)
409622ec 4166 goto out_free_sta;
f84f7d78 4167
1b92f15e 4168 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
f84f7d78
AN		 4169 if (ret < 0)
4170 goto out_sleep;
4171
b67476ef
EP		 4172 ret = wl12xx_cmd_set_peer_state(wl, hlid);
4173 if (ret < 0)
4174 goto out_sleep;
4175
0b932ab9
AN		 4176 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
4177 if (ret < 0)
4178 goto out_sleep;
4179
f84f7d78
AN		 4180out_sleep:
4181 wl1271_ps_elp_sleep(wl);
4182
409622ec
AN		 4183out_free_sta:
4184 if (ret < 0)
c7ffb902 4185 wl1271_free_sta(wl, wlvif, hlid);
409622ec 4186
f84f7d78
AN		 4187out:
4188 mutex_unlock(&wl->mutex);
4189 return ret;
4190}
4191
4192static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
4193 struct ieee80211_vif *vif,
4194 struct ieee80211_sta *sta)
4195{
4196 struct wl1271 *wl = hw->priv;
536129c8 4197 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
f84f7d78
AN		 4198 struct wl1271_station *wl_sta;
4199 int ret = 0, id;
4200
4201 mutex_lock(&wl->mutex);
4202
4203 if (unlikely(wl->state == WL1271_STATE_OFF))
4204 goto out;
4205
536129c8 4206 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
f84f7d78
AN		 4207 goto out;
4208
4209 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4210
4211 wl_sta = (struct wl1271_station *)sta->drv_priv;
c7ffb902
EP		 4212 id = wl_sta->hlid;
4213 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
f84f7d78
AN		 4214 goto out;
4215
a620865e 4216 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 4217 if (ret < 0)
4218 goto out;
4219
c690ec81 4220 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
f84f7d78
AN		 4221 if (ret < 0)
4222 goto out_sleep;
4223
c7ffb902 4224 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
f84f7d78
AN		 4225
4226out_sleep:
4227 wl1271_ps_elp_sleep(wl);
4228
4229out:
4230 mutex_unlock(&wl->mutex);
4231 return ret;
4232}
4233
4623ec7d
LC		 4234static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4235 struct ieee80211_vif *vif,
4236 enum ieee80211_ampdu_mlme_action action,
4237 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4238 u8 buf_size)
bbba3e68
LS		 4239{
4240 struct wl1271 *wl = hw->priv;
536129c8 4241 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
bbba3e68 4242 int ret;
0f9c8250
AN		 4243 u8 hlid, *ba_bitmap;
4244
4245 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4246 tid);
4247
4248 /* sanity check - the fields in FW are only 8bits wide */
4249 if (WARN_ON(tid > 0xFF))
4250 return -ENOTSUPP;
bbba3e68
LS		 4251
4252 mutex_lock(&wl->mutex);
4253
4254 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4255 ret = -EAGAIN;
4256 goto out;
4257 }
4258
536129c8 4259 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
154da67c 4260 hlid = wlvif->sta.hlid;
d0802abd 4261 ba_bitmap = &wlvif->sta.ba_rx_bitmap;
536129c8 4262 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
0f9c8250
AN		 4263 struct wl1271_station *wl_sta;
4264
4265 wl_sta = (struct wl1271_station *)sta->drv_priv;
4266 hlid = wl_sta->hlid;
4267 ba_bitmap = &wl->links[hlid].ba_bitmap;
4268 } else {
4269 ret = -EINVAL;
4270 goto out;
4271 }
4272
a620865e 4273 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 4274 if (ret < 0)
4275 goto out;
4276
70559a06
SL		 4277 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4278 tid, action);
4279
bbba3e68
LS		 4280 switch (action) {
4281 case IEEE80211_AMPDU_RX_START:
d0802abd 4282 if (!wlvif->ba_support || !wlvif->ba_allowed) {
bbba3e68 4283 ret = -ENOTSUPP;
0f9c8250
AN		 4284 break;
4285 }
4286
4287 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4288 ret = -EBUSY;
4289 wl1271_error("exceeded max RX BA sessions");
4290 break;
4291 }
4292
4293 if (*ba_bitmap & BIT(tid)) {
4294 ret = -EINVAL;
4295 wl1271_error("cannot enable RX BA session on active "
4296 "tid: %d", tid);
4297 break;
4298 }
4299
4300 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4301 hlid);
4302 if (!ret) {
4303 *ba_bitmap |= BIT(tid);
4304 wl->ba_rx_session_count++;
bbba3e68
LS		 4305 }
4306 break;
4307
4308 case IEEE80211_AMPDU_RX_STOP:
0f9c8250
AN		 4309 if (!(*ba_bitmap & BIT(tid))) {
4310 ret = -EINVAL;
4311 wl1271_error("no active RX BA session on tid: %d",
4312 tid);
4313 break;
4314 }
4315
4316 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4317 hlid);
4318 if (!ret) {
4319 *ba_bitmap &= ~BIT(tid);
4320 wl->ba_rx_session_count--;
4321 }
bbba3e68
LS		 4322 break;
4323
4324 /*
4325 * The BA initiator session management in FW independently.
4326 * Falling break here on purpose for all TX APDU commands.
4327 */
4328 case IEEE80211_AMPDU_TX_START:
4329 case IEEE80211_AMPDU_TX_STOP:
4330 case IEEE80211_AMPDU_TX_OPERATIONAL:
4331 ret = -EINVAL;
4332 break;
4333
4334 default:
4335 wl1271_error("Incorrect ampdu action id=%x\n", action);
4336 ret = -EINVAL;
4337 }
4338
4339 wl1271_ps_elp_sleep(wl);
4340
4341out:
4342 mutex_unlock(&wl->mutex);
4343
4344 return ret;
4345}
4346
af7fbb28
EP		 4347static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4348 struct ieee80211_vif *vif,
4349 const struct cfg80211_bitrate_mask *mask)
4350{
83587505 4351 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
af7fbb28
EP		 4352 struct wl1271 *wl = hw->priv;
4353 int i;
4354
4355 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4356 mask->control[NL80211_BAND_2GHZ].legacy,
4357 mask->control[NL80211_BAND_5GHZ].legacy);
4358
4359 mutex_lock(&wl->mutex);
4360
4361 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
83587505 4362 wlvif->bitrate_masks[i] =
af7fbb28
EP		 4363 wl1271_tx_enabled_rates_get(wl,
4364 mask->control[i].legacy,
4365 i);
4366 mutex_unlock(&wl->mutex);
4367
4368 return 0;
4369}
4370
6d158ff3
SL		 4371static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4372 struct ieee80211_channel_switch *ch_switch)
4373{
4374 struct wl1271 *wl = hw->priv;
52630c5d 4375 struct wl12xx_vif *wlvif;
6d158ff3
SL		 4376 int ret;
4377
4378 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4379
4380 mutex_lock(&wl->mutex);
4381
4382 if (unlikely(wl->state == WL1271_STATE_OFF)) {
6e8cd331
EP		 4383 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4384 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4385 ieee80211_chswitch_done(vif, false);
4386 }
4387 goto out;
6d158ff3
SL		 4388 }
4389
4390 ret = wl1271_ps_elp_wakeup(wl);
4391 if (ret < 0)
4392 goto out;
4393
52630c5d
EP		 4394 /* TODO: change mac80211 to pass vif as param */
4395 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4396 ret = wl12xx_cmd_channel_switch(wl, ch_switch);
6d158ff3 4397
52630c5d
EP		 4398 if (!ret)
4399 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4400 }
6d158ff3
SL		 4401
4402 wl1271_ps_elp_sleep(wl);
4403
4404out:
4405 mutex_unlock(&wl->mutex);
4406}
4407
33437893
AN		 4408static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4409{
4410 struct wl1271 *wl = hw->priv;
4411 bool ret = false;
4412
4413 mutex_lock(&wl->mutex);
4414
4415 if (unlikely(wl->state == WL1271_STATE_OFF))
4416 goto out;
4417
4418 /* packets are considered pending if in the TX queue or the FW */
f1a46384 4419 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 4420out:
4421 mutex_unlock(&wl->mutex);
4422
4423 return ret;
4424}
4425
f5fc0f86
LC		 4426/* can't be const, mac80211 writes to this */
4427static struct ieee80211_rate wl1271_rates[] = {
4428 { .bitrate = 10,
2b60100b
JO		 4429 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4430 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 4431 { .bitrate = 20,
2b60100b
JO		 4432 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4433 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 4434 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4435 { .bitrate = 55,
2b60100b
JO		 4436 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4437 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 4438 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4439 { .bitrate = 110,
2b60100b
JO		 4440 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4441 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 4442 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4443 { .bitrate = 60,
2b60100b
JO		 4444 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4445 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 4446 { .bitrate = 90,
2b60100b
JO		 4447 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4448 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 4449 { .bitrate = 120,
2b60100b
JO		 4450 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4451 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 4452 { .bitrate = 180,
2b60100b
JO		 4453 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4454 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 4455 { .bitrate = 240,
2b60100b
JO		 4456 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4457 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 4458 { .bitrate = 360,
2b60100b
JO		 4459 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4460 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 4461 { .bitrate = 480,
2b60100b
JO		 4462 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4463 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 4464 { .bitrate = 540,
2b60100b
JO		 4465 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4466 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 4467};
4468
fa97f46b 4469/* can't be const, mac80211 writes to this */
f5fc0f86 4470static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 4471 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 4472 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 4473 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4474 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4475 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 4476 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 4477 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4478 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4479 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 4480 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 4481 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4482 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4483 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 4484 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 4485};
4486
f876bb9a 4487/* mapping to indexes for wl1271_rates */
a0ea9493 4488static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 4489 /* MCS rates are used only with 11n */
18357850
SL		 4490 7, /* CONF_HW_RXTX_RATE_MCS7 */
4491 6, /* CONF_HW_RXTX_RATE_MCS6 */
4492 5, /* CONF_HW_RXTX_RATE_MCS5 */
4493 4, /* CONF_HW_RXTX_RATE_MCS4 */
4494 3, /* CONF_HW_RXTX_RATE_MCS3 */
4495 2, /* CONF_HW_RXTX_RATE_MCS2 */
4496 1, /* CONF_HW_RXTX_RATE_MCS1 */
4497 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4498
4499 11, /* CONF_HW_RXTX_RATE_54 */
4500 10, /* CONF_HW_RXTX_RATE_48 */
4501 9, /* CONF_HW_RXTX_RATE_36 */
4502 8, /* CONF_HW_RXTX_RATE_24 */
4503
4504 /* TI-specific rate */
4505 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4506
4507 7, /* CONF_HW_RXTX_RATE_18 */
4508 6, /* CONF_HW_RXTX_RATE_12 */
4509 3, /* CONF_HW_RXTX_RATE_11 */
4510 5, /* CONF_HW_RXTX_RATE_9 */
4511 4, /* CONF_HW_RXTX_RATE_6 */
4512 2, /* CONF_HW_RXTX_RATE_5_5 */
4513 1, /* CONF_HW_RXTX_RATE_2 */
4514 0 /* CONF_HW_RXTX_RATE_1 */
4515};
4516
e8b03a2b
SL		 4517/* 11n STA capabilities */
4518#define HW_RX_HIGHEST_RATE 72
4519
00d20100 4520#define WL12XX_HT_CAP { \
871d0c3b
SL		 4521 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4522 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 4523 .ht_supported = true, \
4524 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4525 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4526 .mcs = { \
4527 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4528 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4529 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4530 }, \
4531}
4532
f5fc0f86
LC		 4533/* can't be const, mac80211 writes to this */
4534static struct ieee80211_supported_band wl1271_band_2ghz = {
4535 .channels = wl1271_channels,
4536 .n_channels = ARRAY_SIZE(wl1271_channels),
4537 .bitrates = wl1271_rates,
4538 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 4539 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 4540};
4541
1ebec3d7
TP		 4542/* 5 GHz data rates for WL1273 */
4543static struct ieee80211_rate wl1271_rates_5ghz[] = {
4544 { .bitrate = 60,
4545 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4546 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4547 { .bitrate = 90,
4548 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4549 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4550 { .bitrate = 120,
4551 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4552 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4553 { .bitrate = 180,
4554 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4555 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4556 { .bitrate = 240,
4557 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4558 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4559 { .bitrate = 360,
4560 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4561 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4562 { .bitrate = 480,
4563 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4564 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4565 { .bitrate = 540,
4566 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4567 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4568};
4569
fa97f46b 4570/* 5 GHz band channels for WL1273 */
1ebec3d7 4571static struct ieee80211_channel wl1271_channels_5ghz[] = {
6cfa5cff
AN		 4572 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4573 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4574 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4575 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4576 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4577 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4578 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4579 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4580 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4581 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4582 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4583 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4584 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4585 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4586 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4587 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4588 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4589 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4590 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4591 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4592 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4593 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4594 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4595 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4596 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4597 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4598 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4599 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4600 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4601 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4602 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4603 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4604 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4605 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
1ebec3d7
TP		 4606};
4607
f876bb9a 4608/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 4609static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 4610 /* MCS rates are used only with 11n */
18357850
SL		 4611 7, /* CONF_HW_RXTX_RATE_MCS7 */
4612 6, /* CONF_HW_RXTX_RATE_MCS6 */
4613 5, /* CONF_HW_RXTX_RATE_MCS5 */
4614 4, /* CONF_HW_RXTX_RATE_MCS4 */
4615 3, /* CONF_HW_RXTX_RATE_MCS3 */
4616 2, /* CONF_HW_RXTX_RATE_MCS2 */
4617 1, /* CONF_HW_RXTX_RATE_MCS1 */
4618 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4619
4620 7, /* CONF_HW_RXTX_RATE_54 */
4621 6, /* CONF_HW_RXTX_RATE_48 */
4622 5, /* CONF_HW_RXTX_RATE_36 */
4623 4, /* CONF_HW_RXTX_RATE_24 */
4624
4625 /* TI-specific rate */
4626 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4627
4628 3, /* CONF_HW_RXTX_RATE_18 */
4629 2, /* CONF_HW_RXTX_RATE_12 */
4630 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4631 1, /* CONF_HW_RXTX_RATE_9 */
4632 0, /* CONF_HW_RXTX_RATE_6 */
4633 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4634 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4635 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4636};
1ebec3d7
TP		 4637
4638static struct ieee80211_supported_band wl1271_band_5ghz = {
4639 .channels = wl1271_channels_5ghz,
4640 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4641 .bitrates = wl1271_rates_5ghz,
4642 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 4643 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 4644};
4645
a0ea9493 4646static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 4647 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4648 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4649};
4650
f5fc0f86
LC		 4651static const struct ieee80211_ops wl1271_ops = {
4652 .start = wl1271_op_start,
4653 .stop = wl1271_op_stop,
4654 .add_interface = wl1271_op_add_interface,
4655 .remove_interface = wl1271_op_remove_interface,
f634a4e7 4656#ifdef CONFIG_PM
402e4861
EP		 4657 .suspend = wl1271_op_suspend,
4658 .resume = wl1271_op_resume,
f634a4e7 4659#endif
f5fc0f86 4660 .config = wl1271_op_config,
c87dec9f 4661 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 4662 .configure_filter = wl1271_op_configure_filter,
4663 .tx = wl1271_op_tx,
4664 .set_key = wl1271_op_set_key,
4665 .hw_scan = wl1271_op_hw_scan,
73ecce31 4666 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 4667 .sched_scan_start = wl1271_op_sched_scan_start,
4668 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 4669 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 4670 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 4671 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 4672 .conf_tx = wl1271_op_conf_tx,
bbbb538e 4673 .get_tsf = wl1271_op_get_tsf,
ece550d0 4674 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 4675 .sta_add = wl1271_op_sta_add,
4676 .sta_remove = wl1271_op_sta_remove,
bbba3e68 4677 .ampdu_action = wl1271_op_ampdu_action,
33437893 4678 .tx_frames_pending = wl1271_tx_frames_pending,
af7fbb28 4679 .set_bitrate_mask = wl12xx_set_bitrate_mask,
6d158ff3 4680 .channel_switch = wl12xx_op_channel_switch,
c8c90873 4681 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 4682};
4683
f876bb9a 4684
6a2de93b 4685u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 4686{
4687 u8 idx;
4688
6a2de93b 4689 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 4690
4691 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4692 wl1271_error("Illegal RX rate from HW: %d", rate);
4693 return 0;
4694 }
4695
6a2de93b 4696 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 4697 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4698 wl1271_error("Unsupported RX rate from HW: %d", rate);
4699 return 0;
4700 }
4701
4702 return idx;
4703}
4704
7fc3a864
JO		 4705static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4706 struct device_attribute *attr,
4707 char *buf)
4708{
4709 struct wl1271 *wl = dev_get_drvdata(dev);
4710 ssize_t len;
4711
2f63b011 4712 len = PAGE_SIZE;
7fc3a864
JO		 4713
4714 mutex_lock(&wl->mutex);
4715 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4716 wl->sg_enabled);
4717 mutex_unlock(&wl->mutex);
4718
4719 return len;
4720
4721}
4722
4723static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4724 struct device_attribute *attr,
4725 const char *buf, size_t count)
4726{
4727 struct wl1271 *wl = dev_get_drvdata(dev);
4728 unsigned long res;
4729 int ret;
4730
6277ed65 4731 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 4732 if (ret < 0) {
4733 wl1271_warning("incorrect value written to bt_coex_mode");
4734 return count;
4735 }
4736
4737 mutex_lock(&wl->mutex);
4738
4739 res = !!res;
4740
4741 if (res == wl->sg_enabled)
4742 goto out;
4743
4744 wl->sg_enabled = res;
4745
4746 if (wl->state == WL1271_STATE_OFF)
4747 goto out;
4748
a620865e 4749 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 4750 if (ret < 0)
4751 goto out;
4752
4753 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4754 wl1271_ps_elp_sleep(wl);
4755
4756 out:
4757 mutex_unlock(&wl->mutex);
4758 return count;
4759}
4760
4761static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4762 wl1271_sysfs_show_bt_coex_state,
4763 wl1271_sysfs_store_bt_coex_state);
4764
d717fd61
JO		 4765static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4766 struct device_attribute *attr,
4767 char *buf)
4768{
4769 struct wl1271 *wl = dev_get_drvdata(dev);
4770 ssize_t len;
4771
2f63b011 4772 len = PAGE_SIZE;
d717fd61
JO		 4773
4774 mutex_lock(&wl->mutex);
4775 if (wl->hw_pg_ver >= 0)
4776 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4777 else
4778 len = snprintf(buf, len, "n/a\n");
4779 mutex_unlock(&wl->mutex);
4780
4781 return len;
4782}
4783
6f07b72a 4784static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
d717fd61
JO		 4785 wl1271_sysfs_show_hw_pg_ver, NULL);
4786
95dac04f
IY		 4787static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4788 struct bin_attribute *bin_attr,
4789 char *buffer, loff_t pos, size_t count)
4790{
4791 struct device *dev = container_of(kobj, struct device, kobj);
4792 struct wl1271 *wl = dev_get_drvdata(dev);
4793 ssize_t len;
4794 int ret;
4795
4796 ret = mutex_lock_interruptible(&wl->mutex);
4797 if (ret < 0)
4798 return -ERESTARTSYS;
4799
4800 /* Let only one thread read the log at a time, blocking others */
4801 while (wl->fwlog_size == 0) {
4802 DEFINE_WAIT(wait);
4803
4804 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4805 &wait,
4806 TASK_INTERRUPTIBLE);
4807
4808 if (wl->fwlog_size != 0) {
4809 finish_wait(&wl->fwlog_waitq, &wait);
4810 break;
4811 }
4812
4813 mutex_unlock(&wl->mutex);
4814
4815 schedule();
4816 finish_wait(&wl->fwlog_waitq, &wait);
4817
4818 if (signal_pending(current))
4819 return -ERESTARTSYS;
4820
4821 ret = mutex_lock_interruptible(&wl->mutex);
4822 if (ret < 0)
4823 return -ERESTARTSYS;
4824 }
4825
4826 /* Check if the fwlog is still valid */
4827 if (wl->fwlog_size < 0) {
4828 mutex_unlock(&wl->mutex);
4829 return 0;
4830 }
4831
4832 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4833 len = min(count, (size_t)wl->fwlog_size);
4834 wl->fwlog_size -= len;
4835 memcpy(buffer, wl->fwlog, len);
4836
4837 /* Make room for new messages */
4838 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4839
4840 mutex_unlock(&wl->mutex);
4841
4842 return len;
4843}
4844
4845static struct bin_attribute fwlog_attr = {
4846 .attr = {.name = "fwlog", .mode = S_IRUSR},
4847 .read = wl1271_sysfs_read_fwlog,
4848};
4849
2d5e82b8 4850int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 4851{
4852 int ret;
4853
4854 if (wl->mac80211_registered)
4855 return 0;
4856
31d26ec6
AN		 4857 ret = wl1271_fetch_nvs(wl);
4858 if (ret == 0) {
bc765bf3
SL		 4859 /* NOTE: The wl->nvs->nvs element must be first, in
4860 * order to simplify the casting, we assume it is at
4861 * the beginning of the wl->nvs structure.
4862 */
4863 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 4864
4865 wl->mac_addr[0] = nvs_ptr[11];
4866 wl->mac_addr[1] = nvs_ptr[10];
4867 wl->mac_addr[2] = nvs_ptr[6];
4868 wl->mac_addr[3] = nvs_ptr[5];
4869 wl->mac_addr[4] = nvs_ptr[4];
4870 wl->mac_addr[5] = nvs_ptr[3];
4871 }
4872
f5fc0f86
LC		 4873 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4874
4875 ret = ieee80211_register_hw(wl->hw);
4876 if (ret < 0) {
4877 wl1271_error("unable to register mac80211 hw: %d", ret);
4878 return ret;
4879 }
4880
4881 wl->mac80211_registered = true;
4882
d60080ae
EP		 4883 wl1271_debugfs_init(wl);
4884
c2c192ac
JO		 4885 register_netdevice_notifier(&wl1271_dev_notifier);
4886
f5fc0f86
LC		 4887 wl1271_notice("loaded");
4888
4889 return 0;
4890}
50b3eb4b 4891EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 4892
3b56dd6a
TP		 4893void wl1271_unregister_hw(struct wl1271 *wl)
4894{
4ae3fa87
JO		 4895 if (wl->state == WL1271_STATE_PLT)
4896 __wl1271_plt_stop(wl);
4897
c2c192ac 4898 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 4899 ieee80211_unregister_hw(wl->hw);
4900 wl->mac80211_registered = false;
4901
4902}
4903EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4904
2d5e82b8 4905int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 4906{
7a55724e
JO		 4907 static const u32 cipher_suites[] = {
4908 WLAN_CIPHER_SUITE_WEP40,
4909 WLAN_CIPHER_SUITE_WEP104,
4910 WLAN_CIPHER_SUITE_TKIP,
4911 WLAN_CIPHER_SUITE_CCMP,
4912 WL1271_CIPHER_SUITE_GEM,
4913 };
4914
1e2b7976
JO		 4915 /* The tx descriptor buffer and the TKIP space. */
4916 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4917 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 4918
4919 /* unit us */
4920 /* FIXME: find a proper value */
4921 wl->hw->channel_change_time = 10000;
50c500ad 4922 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 4923
4924 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 4925 IEEE80211_HW_BEACON_FILTER |
0a34332f 4926 IEEE80211_HW_SUPPORTS_PS |
4695dc91 4927 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 4928 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 4929 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 4930 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 4931 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 4932 IEEE80211_HW_SPECTRUM_MGMT |
93f8c8e0
AN		 4933 IEEE80211_HW_AP_LINK_PS |
4934 IEEE80211_HW_AMPDU_AGGREGATION |
4935 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
f5fc0f86 4936
7a55724e
JO		 4937 wl->hw->wiphy->cipher_suites = cipher_suites;
4938 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4939
e0d8bbf0 4940 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
045c745f
EP		 4941 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
4942 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
f5fc0f86 4943 wl->hw->wiphy->max_scan_ssids = 1;
221737d2
LC		 4944 wl->hw->wiphy->max_sched_scan_ssids = 16;
4945 wl->hw->wiphy->max_match_sets = 16;
ea559b46
GE		 4946 /*
4947 * Maximum length of elements in scanning probe request templates
4948 * should be the maximum length possible for a template, without
4949 * the IEEE80211 header of the template
4950 */
154037d1 4951 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
ea559b46 4952 sizeof(struct ieee80211_header);
a8aaaf53 4953
c9e79a47
LC		 4954 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4955 sizeof(struct ieee80211_header);
4956
1ec23f7f
EP		 4957 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4958
4a31c11c
LC		 4959 /* make sure all our channels fit in the scanned_ch bitmask */
4960 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4961 ARRAY_SIZE(wl1271_channels_5ghz) >
4962 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 4963 /*
4964 * We keep local copies of the band structs because we need to
4965 * modify them on a per-device basis.
4966 */
4967 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4968 sizeof(wl1271_band_2ghz));
4969 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4970 sizeof(wl1271_band_5ghz));
4971
4972 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4973 &wl->bands[IEEE80211_BAND_2GHZ];
4974 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4975 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 4976
12bd8949 4977 wl->hw->queues = 4;
31627dc5 4978 wl->hw->max_rates = 1;
12bd8949 4979
b7417d93
JO		 4980 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4981
8197b711 4982 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 4983
f84f7d78 4984 wl->hw->sta_data_size = sizeof(struct wl1271_station);
87fbcb0f 4985 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
f84f7d78 4986
4c9cfa78
LC		 4987 wl->hw->max_rx_aggregation_subframes = 8;
4988
f5fc0f86
LC		 4989 return 0;
4990}
50b3eb4b 4991EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 4992
f5fc0f86 4993#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 4994
2d5e82b8 4995struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 4996{
f5fc0f86 4997 struct ieee80211_hw *hw;
3b56dd6a 4998 struct platform_device *plat_dev = NULL;
f5fc0f86 4999 struct wl1271 *wl;
a8c0ddb5 5000 int i, j, ret;
1f37cbc9 5001 unsigned int order;
f5fc0f86 5002
c7ffb902 5003 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
f80c2d12 5004
f5fc0f86
LC		 5005 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
5006 if (!hw) {
5007 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 5008 ret = -ENOMEM;
3b56dd6a
TP		 5009 goto err_hw_alloc;
5010 }
5011
929ebd30 5012 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 5013 if (!plat_dev) {
5014 wl1271_error("could not allocate platform_device");
5015 ret = -ENOMEM;
5016 goto err_plat_alloc;
f5fc0f86
LC		 5017 }
5018
5019 wl = hw->priv;
5020 memset(wl, 0, sizeof(*wl));
5021
01c09162 5022 INIT_LIST_HEAD(&wl->list);
87627214 5023 INIT_LIST_HEAD(&wl->wlvif_list);
01c09162 5024
f5fc0f86 5025 wl->hw = hw;
3b56dd6a 5026 wl->plat_dev = plat_dev;
f5fc0f86 5027
a8c0ddb5 5028 for (i = 0; i < NUM_TX_QUEUES; i++)
c7ffb902 5029 for (j = 0; j < WL12XX_MAX_LINKS; j++)
a8c0ddb5
AN		 5030 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5031
a620865e
IY		 5032 skb_queue_head_init(&wl->deferred_rx_queue);
5033 skb_queue_head_init(&wl->deferred_tx_queue);
5034
37b70a81 5035 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
a620865e 5036 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 5037 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5038 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5039 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
77ddaa10 5040
92ef8960
EP		 5041 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5042 if (!wl->freezable_wq) {
5043 ret = -ENOMEM;
5044 goto err_hw;
5045 }
5046
f5fc0f86 5047 wl->channel = WL1271_DEFAULT_CHANNEL;
f5fc0f86 5048 wl->rx_counter = 0;
f5fc0f86 5049 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
8a5a37a6 5050 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 5051 wl->vif = NULL;
830fb67b 5052 wl->flags = 0;
7fc3a864 5053 wl->sg_enabled = true;
d717fd61 5054 wl->hw_pg_ver = -1;
b622d992
AN		 5055 wl->ap_ps_map = 0;
5056 wl->ap_fw_ps_map = 0;
606ea9fa 5057 wl->quirks = 0;
341b7cde 5058 wl->platform_quirks = 0;
33c2c06c 5059 wl->sched_scanning = false;
e9eb8cbe 5060 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
f4df1bd5 5061 wl->system_hlid = WL12XX_SYSTEM_HLID;
da03209e 5062 wl->active_sta_count = 0;
95dac04f
IY		 5063 wl->fwlog_size = 0;
5064 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 5065
f4df1bd5
EP		 5066 /* The system link is always allocated */
5067 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5068
25eeb9e3 5069 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 5070 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 5071 wl->tx_frames[i] = NULL;
5072
5073 spin_lock_init(&wl->wl_lock);
5074
f5fc0f86
LC		 5075 wl->state = WL1271_STATE_OFF;
5076 mutex_init(&wl->mutex);
5077
c332a4b8
TP		 5078 /* Apply default driver configuration. */
5079 wl1271_conf_init(wl);
5080
1f37cbc9
IY		 5081 order = get_order(WL1271_AGGR_BUFFER_SIZE);
5082 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5083 if (!wl->aggr_buf) {
5084 ret = -ENOMEM;
92ef8960 5085 goto err_wq;
1f37cbc9
IY		 5086 }
5087
990f5de7
IY		 5088 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5089 if (!wl->dummy_packet) {
5090 ret = -ENOMEM;
5091 goto err_aggr;
5092 }
5093
95dac04f
IY		 5094 /* Allocate one page for the FW log */
5095 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5096 if (!wl->fwlog) {
5097 ret = -ENOMEM;
5098 goto err_dummy_packet;
5099 }
5100
a1dd8187 5101 /* Register platform device */
3b56dd6a 5102 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 5103 if (ret) {
5104 wl1271_error("couldn't register platform device");
95dac04f 5105 goto err_fwlog;
a1dd8187 5106 }
3b56dd6a 5107 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 5108
7fc3a864 5109 /* Create sysfs file to control bt coex state */
3b56dd6a 5110 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 5111 if (ret < 0) {
5112 wl1271_error("failed to create sysfs file bt_coex_state");
5113 goto err_platform;
5114 }
a1dd8187 5115
d717fd61
JO		 5116 /* Create sysfs file to get HW PG version */
5117 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
5118 if (ret < 0) {
5119 wl1271_error("failed to create sysfs file hw_pg_ver");
5120 goto err_bt_coex_state;
5121 }
5122
95dac04f
IY		 5123 /* Create sysfs file for the FW log */
5124 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
5125 if (ret < 0) {
5126 wl1271_error("failed to create sysfs file fwlog");
5127 goto err_hw_pg_ver;
5128 }
5129
c332a4b8 5130 return hw;
a1dd8187 5131
95dac04f
IY		 5132err_hw_pg_ver:
5133 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
5134
d717fd61
JO		 5135err_bt_coex_state:
5136 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
5137
7fc3a864 5138err_platform:
3b56dd6a 5139 platform_device_unregister(wl->plat_dev);
7fc3a864 5140
95dac04f
IY		 5141err_fwlog:
5142 free_page((unsigned long)wl->fwlog);
5143
990f5de7
IY		 5144err_dummy_packet:
5145 dev_kfree_skb(wl->dummy_packet);
5146
1f37cbc9
IY		 5147err_aggr:
5148 free_pages((unsigned long)wl->aggr_buf, order);
5149
92ef8960
EP		 5150err_wq:
5151 destroy_workqueue(wl->freezable_wq);
5152
a1dd8187 5153err_hw:
3b56dd6a
TP		 5154 wl1271_debugfs_exit(wl);
5155 kfree(plat_dev);
5156
5157err_plat_alloc:
5158 ieee80211_free_hw(hw);
5159
5160err_hw_alloc:
a1dd8187 5161
a1dd8187 5162 return ERR_PTR(ret);
c332a4b8 5163}
50b3eb4b 5164EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 5165
5166int wl1271_free_hw(struct wl1271 *wl)
5167{
95dac04f
IY		 5168 /* Unblock any fwlog readers */
5169 mutex_lock(&wl->mutex);
5170 wl->fwlog_size = -1;
5171 wake_up_interruptible_all(&wl->fwlog_waitq);
5172 mutex_unlock(&wl->mutex);
5173
5174 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
6f07b72a
GK		 5175
5176 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
5177
5178 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3b56dd6a 5179 platform_device_unregister(wl->plat_dev);
95dac04f 5180 free_page((unsigned long)wl->fwlog);
990f5de7 5181 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 5182 free_pages((unsigned long)wl->aggr_buf,
5183 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 5184 kfree(wl->plat_dev);
c332a4b8
TP		 5185
5186 wl1271_debugfs_exit(wl);
5187
c332a4b8
TP		 5188 vfree(wl->fw);
5189 wl->fw = NULL;
5190 kfree(wl->nvs);
5191 wl->nvs = NULL;
5192
5193 kfree(wl->fw_status);
5194 kfree(wl->tx_res_if);
92ef8960 5195 destroy_workqueue(wl->freezable_wq);
c332a4b8
TP		 5196
5197 ieee80211_free_hw(wl->hw);
5198
5199 return 0;
5200}
50b3eb4b
TP		 5201EXPORT_SYMBOL_GPL(wl1271_free_hw);
5202
491bbd6b 5203u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 5204EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 5205module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 5206MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
5207
95dac04f
IY		 5208module_param_named(fwlog, fwlog_param, charp, 0);
5209MODULE_PARM_DESC(keymap,
5210 "FW logger options: continuous, ondemand, dbgpins or disable");
5211
2a5bff09
EP		 5212module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
5213MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
5214
50b3eb4b 5215MODULE_LICENSE("GPL");
b1a48cab 5216MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 5217MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.728477 seconds and 5 git commands to generate.