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