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