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