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