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