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