projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: AP mode - clean BA and queue state in tx_reset
[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:
1828 return WL1271_ROLE_AP;
1829
1830 case BSS_TYPE_STA_BSS:
1831 return WL1271_ROLE_STA;
1832
227e81e1
EP		 1833 case BSS_TYPE_IBSS:
1834 return WL1271_ROLE_IBSS;
1835
b78b47eb
EP		 1836 default:
1837 wl1271_error("invalid bss_type: %d", wl->bss_type);
1838 }
1839 return WL12XX_INVALID_ROLE_TYPE;
1840}
1841
1b72aecd
JO		 1842static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1843 struct ieee80211_vif *vif)
f5fc0f86
LC		 1844{
1845 struct wl1271 *wl = hw->priv;
ac01e948 1846 struct wiphy *wiphy = hw->wiphy;
9ccd9217 1847 int retries = WL1271_BOOT_RETRIES;
f5fc0f86 1848 int ret = 0;
b78b47eb 1849 u8 role_type;
71125abd 1850 bool booted = false;
f5fc0f86 1851
1b72aecd
JO		 1852 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1853 vif->type, vif->addr);
f5fc0f86
LC		 1854
1855 mutex_lock(&wl->mutex);
1b72aecd 1856 if (wl->vif) {
71125abd
EP		 1857 wl1271_debug(DEBUG_MAC80211,
1858 "multiple vifs are not supported yet");
1b72aecd
JO		 1859 ret = -EBUSY;
1860 goto out;
1861 }
1862
13026dec
JO		 1863 /*
1864 * in some very corner case HW recovery scenarios its possible to
1865 * get here before __wl1271_op_remove_interface is complete, so
1866 * opt out if that is the case.
1867 */
1868 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1869 ret = -EBUSY;
1870 goto out;
1871 }
1872
1b72aecd
JO		 1873 switch (vif->type) {
1874 case NL80211_IFTYPE_STATION:
1875 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 1876 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 1877 break;
1878 case NL80211_IFTYPE_ADHOC:
1879 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 1880 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd 1881 break;
038d925b
AN		 1882 case NL80211_IFTYPE_AP:
1883 wl->bss_type = BSS_TYPE_AP_BSS;
1884 break;
1b72aecd
JO		 1885 default:
1886 ret = -EOPNOTSUPP;
1887 goto out;
1888 }
1889
b78b47eb
EP		 1890 role_type = wl12xx_get_role_type(wl);
1891 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
1892 ret = -EINVAL;
1893 goto out;
1894 }
1b72aecd 1895 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 1896
1897 if (wl->state != WL1271_STATE_OFF) {
1898 wl1271_error("cannot start because not in off state: %d",
1899 wl->state);
1900 ret = -EBUSY;
1901 goto out;
1902 }
1903
9ccd9217
JO		 1904 while (retries) {
1905 retries--;
1906 ret = wl1271_chip_wakeup(wl);
1907 if (ret < 0)
1908 goto power_off;
f5fc0f86 1909
9ccd9217
JO		 1910 ret = wl1271_boot(wl);
1911 if (ret < 0)
1912 goto power_off;
f5fc0f86 1913
227e81e1
EP		 1914 if (wl->bss_type == BSS_TYPE_STA_BSS ||
1915 wl->bss_type == BSS_TYPE_IBSS) {
04e8079c
EP		 1916 /*
1917 * The device role is a special role used for
1918 * rx and tx frames prior to association (as
1919 * the STA role can get packets only from
1920 * its associated bssid)
1921 */
1922 ret = wl12xx_cmd_role_enable(wl,
1923 WL1271_ROLE_DEVICE,
1924 &wl->dev_role_id);
1925 if (ret < 0)
1926 goto irq_disable;
1927 }
1928
b78b47eb
EP		 1929 ret = wl12xx_cmd_role_enable(wl, role_type, &wl->role_id);
1930 if (ret < 0)
1931 goto irq_disable;
1932
9ccd9217
JO		 1933 ret = wl1271_hw_init(wl);
1934 if (ret < 0)
1935 goto irq_disable;
f5fc0f86 1936
71125abd
EP		 1937 booted = true;
1938 break;
eb5b28d0 1939
9ccd9217 1940irq_disable:
9ccd9217
JO		 1941 mutex_unlock(&wl->mutex);
1942 /* Unlocking the mutex in the middle of handling is
1943 inherently unsafe. In this case we deem it safe to do,
1944 because we need to let any possibly pending IRQ out of
1945 the system (and while we are WL1271_STATE_OFF the IRQ
1946 work function will not do anything.) Also, any other
1947 possible concurrent operations will fail due to the
1948 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 1949 wl1271_disable_interrupts(wl);
1950 wl1271_flush_deferred_work(wl);
1951 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 1952 mutex_lock(&wl->mutex);
1953power_off:
1954 wl1271_power_off(wl);
1955 }
eb5b28d0 1956
71125abd
EP		 1957 if (!booted) {
1958 wl1271_error("firmware boot failed despite %d retries",
1959 WL1271_BOOT_RETRIES);
1960 goto out;
1961 }
1962
1963 wl->vif = vif;
1964 wl->state = WL1271_STATE_ON;
13026dec 1965 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
4b7fac77 1966 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 1967
1968 /* update hw/fw version info in wiphy struct */
1969 wiphy->hw_version = wl->chip.id;
4b7fac77 1970 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 1971 sizeof(wiphy->fw_version));
1972
fb6a6819
LC		 1973 /*
1974 * Now we know if 11a is supported (info from the NVS), so disable
1975 * 11a channels if not supported
1976 */
1977 if (!wl->enable_11a)
1978 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1979
1980 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1981 wl->enable_11a ? "" : "not ");
1982
eb5b28d0 1983out:
f5fc0f86
LC		 1984 mutex_unlock(&wl->mutex);
1985
f9f774c1 1986 mutex_lock(&wl_list_mutex);
eb887dfd 1987 if (!ret)
01c09162 1988 list_add(&wl->list, &wl_list);
f9f774c1 1989 mutex_unlock(&wl_list_mutex);
01c09162 1990
f5fc0f86
LC		 1991 return ret;
1992}
1993
7dece1c8
AN		 1994static void __wl1271_op_remove_interface(struct wl1271 *wl,
1995 bool reset_tx_queues)
f5fc0f86 1996{
bf54e301 1997 int ret, i;
f5fc0f86 1998
1b72aecd 1999 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 2000
13026dec
JO		 2001 /* because of hardware recovery, we may get here twice */
2002 if (wl->state != WL1271_STATE_ON)
2003 return;
2004
1b72aecd 2005 wl1271_info("down");
f5fc0f86 2006
f9f774c1 2007 mutex_lock(&wl_list_mutex);
01c09162 2008 list_del(&wl->list);
f9f774c1 2009 mutex_unlock(&wl_list_mutex);
01c09162 2010
8d2ef7bd 2011 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 2012 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 2013 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2014
08688d6b 2015 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b 2016 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 2017 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
b739a42c 2018 wl->scan.req = NULL;
76a029fb 2019 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 2020 }
2021
b78b47eb
EP		 2022 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2023 /* disable active roles */
2024 ret = wl1271_ps_elp_wakeup(wl);
2025 if (ret < 0)
2026 goto deinit;
2027
04e8079c
EP		 2028 if (wl->bss_type == BSS_TYPE_STA_BSS) {
2029 ret = wl12xx_cmd_role_disable(wl, &wl->dev_role_id);
2030 if (ret < 0)
2031 goto deinit;
2032 }
2033
b78b47eb
EP		 2034 ret = wl12xx_cmd_role_disable(wl, &wl->role_id);
2035 if (ret < 0)
2036 goto deinit;
2037
2038 wl1271_ps_elp_sleep(wl);
2039 }
2040deinit:
e51ae9be 2041 /* clear all hlids (except system_hlid) */
b78b47eb 2042 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
04e8079c 2043 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
e51ae9be
AN		 2044 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
2045 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
b78b47eb 2046
13026dec
JO		 2047 /*
2048 * this must be before the cancel_work calls below, so that the work
2049 * functions don't perform further work.
2050 */
f5fc0f86
LC		 2051 wl->state = WL1271_STATE_OFF;
2052
f5fc0f86
LC		 2053 mutex_unlock(&wl->mutex);
2054
a620865e
IY		 2055 wl1271_disable_interrupts(wl);
2056 wl1271_flush_deferred_work(wl);
78abd320 2057 cancel_delayed_work_sync(&wl->scan_complete_work);
a620865e 2058 cancel_work_sync(&wl->netstack_work);
f5fc0f86 2059 cancel_work_sync(&wl->tx_work);
77ddaa10
EP		 2060 del_timer_sync(&wl->rx_streaming_timer);
2061 cancel_work_sync(&wl->rx_streaming_enable_work);
2062 cancel_work_sync(&wl->rx_streaming_disable_work);
90494a90 2063 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 2064 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 2065
2066 mutex_lock(&wl->mutex);
2067
2068 /* let's notify MAC80211 about the remaining pending TX frames */
7dece1c8 2069 wl1271_tx_reset(wl, reset_tx_queues);
f5fc0f86
LC		 2070 wl1271_power_off(wl);
2071
2072 memset(wl->bssid, 0, ETH_ALEN);
3b40c040 2073 memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
f5fc0f86 2074 wl->ssid_len = 0;
f5fc0f86 2075 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 2076 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 2077 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 2078
2079 wl->rx_counter = 0;
19ad0715 2080 wl->psm_entry_retry = 0;
f5fc0f86
LC		 2081 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2082 wl->tx_blocks_available = 0;
7bb5d6ce 2083 wl->tx_allocated_blocks = 0;
f5fc0f86
LC		 2084 wl->tx_results_count = 0;
2085 wl->tx_packets_count = 0;
2086 wl->time_offset = 0;
2087 wl->session_counter = 0;
830fb67b 2088 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1b72aecd 2089 wl->vif = NULL;
e9eb8cbe 2090 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
7f179b46 2091 wl1271_free_ap_keys(wl);
f84f7d78 2092 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
b622d992
AN		 2093 wl->ap_fw_ps_map = 0;
2094 wl->ap_ps_map = 0;
33c2c06c 2095 wl->sched_scanning = false;
7f097988 2096 wl->role_id = WL12XX_INVALID_ROLE_ID;
04e8079c 2097 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
c690ec81
EP		 2098 memset(wl->roles_map, 0, sizeof(wl->roles_map));
2099 memset(wl->links_map, 0, sizeof(wl->links_map));
251c177f 2100 memset(wl->roc_map, 0, sizeof(wl->roc_map));
da03209e 2101 wl->active_sta_count = 0;
d6e19d13 2102
f4df1bd5
EP		 2103 /* The system link is always allocated */
2104 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2105
13026dec
JO		 2106 /*
2107 * this is performed after the cancel_work calls and the associated
2108 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2109 * get executed before all these vars have been reset.
2110 */
2111 wl->flags = 0;
2112
4d56ad9c 2113 wl->tx_blocks_freed = 0;
f5fc0f86 2114
742246f8 2115 for (i = 0; i < NUM_TX_QUEUES; i++) {
bf54e301 2116 wl->tx_pkts_freed[i] = 0;
742246f8
AN		 2117 wl->tx_allocated_pkts[i] = 0;
2118 }
bf54e301 2119
f5fc0f86 2120 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 2121
2122 kfree(wl->fw_status);
2123 wl->fw_status = NULL;
2124 kfree(wl->tx_res_if);
2125 wl->tx_res_if = NULL;
2126 kfree(wl->target_mem_map);
2127 wl->target_mem_map = NULL;
52a2a375 2128}
bd9dc49c 2129
52a2a375
JO		 2130static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2131 struct ieee80211_vif *vif)
2132{
2133 struct wl1271 *wl = hw->priv;
2134
2135 mutex_lock(&wl->mutex);
67353299
JO		 2136 /*
2137 * wl->vif can be null here if someone shuts down the interface
2138 * just when hardware recovery has been started.
2139 */
2140 if (wl->vif) {
2141 WARN_ON(wl->vif != vif);
7dece1c8 2142 __wl1271_op_remove_interface(wl, true);
67353299 2143 }
52b0e7a6 2144
67353299 2145 mutex_unlock(&wl->mutex);
52b0e7a6 2146 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 2147}
2148
69e5434c 2149static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 2150{
2151 int ret;
227e81e1 2152 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
82429d32 2153
69e5434c
JO		 2154 /*
2155 * One of the side effects of the JOIN command is that is clears
2156 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2157 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2158 * Currently the only valid scenario for JOIN during association
2159 * is on roaming, in which case we will also be given new keys.
2160 * Keep the below message for now, unless it starts bothering
2161 * users who really like to roam a lot :)
69e5434c
JO		 2162 */
2163 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2164 wl1271_info("JOIN while associated.");
2165
2166 if (set_assoc)
2167 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2168
227e81e1
EP		 2169 if (is_ibss)
2170 ret = wl12xx_cmd_role_start_ibss(wl);
2171 else
2172 ret = wl12xx_cmd_role_start_sta(wl);
82429d32
JO		 2173 if (ret < 0)
2174 goto out;
2175
82429d32
JO		 2176 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2177 goto out;
2178
2179 /*
2180 * The join command disable the keep-alive mode, shut down its process,
2181 * and also clear the template config, so we need to reset it all after
2182 * the join. The acx_aid starts the keep-alive process, and the order
2183 * of the commands below is relevant.
2184 */
2185 ret = wl1271_acx_keep_alive_mode(wl, true);
2186 if (ret < 0)
2187 goto out;
2188
2189 ret = wl1271_acx_aid(wl, wl->aid);
2190 if (ret < 0)
2191 goto out;
2192
2193 ret = wl1271_cmd_build_klv_null_data(wl);
2194 if (ret < 0)
2195 goto out;
2196
2197 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2198 ACX_KEEP_ALIVE_TPL_VALID);
2199 if (ret < 0)
2200 goto out;
2201
2202out:
2203 return ret;
2204}
2205
2206static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 2207{
2208 int ret;
2209
2210 /* to stop listening to a channel, we disconnect */
c690ec81 2211 ret = wl12xx_cmd_role_stop_sta(wl);
c7f43e45
LC		 2212 if (ret < 0)
2213 goto out;
2214
c7f43e45 2215 memset(wl->bssid, 0, ETH_ALEN);
14b228a0 2216
b992c682
OK		 2217 /* reset TX security counters on a clean disconnect */
2218 wl->tx_security_last_seq_lsb = 0;
2219 wl->tx_security_seq = 0;
2220
c7f43e45
LC		 2221out:
2222 return ret;
2223}
2224
ebba60c6
JO		 2225static void wl1271_set_band_rate(struct wl1271 *wl)
2226{
53835a2d 2227 if (wl->band == IEEE80211_BAND_2GHZ) {
ebba60c6 2228 wl->basic_rate_set = wl->conf.tx.basic_rate;
53835a2d
EP		 2229 wl->rate_set = wl->conf.tx.basic_rate;
2230 } else {
ebba60c6 2231 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
53835a2d
EP		 2232 wl->rate_set = wl->conf.tx.basic_rate_5;
2233 }
2234
ebba60c6
JO		 2235}
2236
251c177f
EP		 2237static bool wl12xx_is_roc(struct wl1271 *wl)
2238{
2239 u8 role_id;
2240
2241 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2242 if (role_id >= WL12XX_MAX_ROLES)
2243 return false;
2244
2245 return true;
2246}
2247
bee0ffec 2248static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 2249{
2250 int ret;
2251
2252 if (idle) {
251c177f
EP		 2253 /* no need to croc if we weren't busy (e.g. during boot) */
2254 if (wl12xx_is_roc(wl)) {
2255 ret = wl12xx_croc(wl, wl->dev_role_id);
2256 if (ret < 0)
2257 goto out;
2258
2259 ret = wl12xx_cmd_role_stop_dev(wl);
0d58cbff
JO		 2260 if (ret < 0)
2261 goto out;
2262 }
e0fe371b 2263 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 2264 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 2265 if (ret < 0)
2266 goto out;
2267 ret = wl1271_acx_keep_alive_config(
2268 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2269 ACX_KEEP_ALIVE_TPL_INVALID);
2270 if (ret < 0)
2271 goto out;
2272 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2273 } else {
33c2c06c
LC		 2274 /* The current firmware only supports sched_scan in idle */
2275 if (wl->sched_scanning) {
2276 wl1271_scan_sched_scan_stop(wl);
2277 ieee80211_sched_scan_stopped(wl->hw);
2278 }
2279
251c177f
EP		 2280 ret = wl12xx_cmd_role_start_dev(wl);
2281 if (ret < 0)
2282 goto out;
2283
2284 ret = wl12xx_roc(wl, wl->dev_role_id);
0d58cbff
JO		 2285 if (ret < 0)
2286 goto out;
2287 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2288 }
2289
2290out:
2291 return ret;
2292}
2293
f5fc0f86
LC		 2294static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2295{
2296 struct wl1271 *wl = hw->priv;
2297 struct ieee80211_conf *conf = &hw->conf;
2298 int channel, ret = 0;
bee0ffec 2299 bool is_ap;
f5fc0f86
LC		 2300
2301 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2302
bee0ffec
AN		 2303 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2304 " changed 0x%x",
f5fc0f86
LC		 2305 channel,
2306 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 2307 conf->power_level,
bee0ffec
AN		 2308 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2309 changed);
f5fc0f86 2310
781608c4
JO		 2311 /*
2312 * mac80211 will go to idle nearly immediately after transmitting some
2313 * frames, such as the deauth. To make sure those frames reach the air,
2314 * wait here until the TX queue is fully flushed.
2315 */
2316 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2317 (conf->flags & IEEE80211_CONF_IDLE))
2318 wl1271_tx_flush(wl);
2319
f5fc0f86
LC		 2320 mutex_lock(&wl->mutex);
2321
f8d9802f 2322 if (unlikely(wl->state == WL1271_STATE_OFF)) {
17e672d6
AN		 2323 /* we support configuring the channel and band while off */
2324 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2325 wl->band = conf->channel->band;
2326 wl->channel = channel;
2327 }
2328
097f8821
AN		 2329 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2330 wl->power_level = conf->power_level;
2331
2c10bb9c 2332 goto out;
f8d9802f 2333 }
8a5a37a6 2334
bee0ffec
AN		 2335 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2336
a620865e 2337 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2338 if (ret < 0)
2339 goto out;
2340
ebba60c6 2341 /* if the channel changes while joined, join again */
69e5434c
JO		 2342 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2343 ((wl->band != conf->channel->band) ||
2344 (wl->channel != channel))) {
ebba60c6
JO		 2345 wl->band = conf->channel->band;
2346 wl->channel = channel;
2347
bee0ffec
AN		 2348 if (!is_ap) {
2349 /*
2350 * FIXME: the mac80211 should really provide a fixed
2351 * rate to use here. for now, just use the smallest
2352 * possible rate for the band as a fixed rate for
2353 * association frames and other control messages.
2354 */
2355 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2356 wl1271_set_band_rate(wl);
2357
2358 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2359 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2360 if (ret < 0)
bee0ffec 2361 wl1271_warning("rate policy for channel "
ebba60c6 2362 "failed %d", ret);
bee0ffec 2363
251c177f
EP		 2364 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2365 if (wl12xx_is_roc(wl)) {
2366 /* roaming */
2367 ret = wl12xx_croc(wl, wl->dev_role_id);
2368 if (ret < 0)
2369 goto out_sleep;
2370 }
bee0ffec
AN		 2371 ret = wl1271_join(wl, false);
2372 if (ret < 0)
2373 wl1271_warning("cmd join on channel "
2374 "failed %d", ret);
251c177f
EP		 2375 } else {
2376 /*
2377 * change the ROC channel. do it only if we are
2378 * not idle. otherwise, CROC will be called
2379 * anyway.
2380 */
2381 if (wl12xx_is_roc(wl) &&
2382 !(conf->flags & IEEE80211_CONF_IDLE)) {
2383 ret = wl12xx_croc(wl, wl->dev_role_id);
2384 if (ret < 0)
2385 goto out_sleep;
2386
2387 ret = wl12xx_roc(wl, wl->dev_role_id);
2388 if (ret < 0)
2389 wl1271_warning("roc failed %d",
2390 ret);
2391 }
bee0ffec 2392 }
ebba60c6
JO		 2393 }
2394 }
2395
bee0ffec
AN		 2396 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2397 ret = wl1271_sta_handle_idle(wl,
2398 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 2399 if (ret < 0)
2400 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 2401 }
2402
90494a90
JO		 2403 /*
2404 * if mac80211 changes the PSM mode, make sure the mode is not
2405 * incorrectly changed after the pspoll failure active window.
2406 */
2407 if (changed & IEEE80211_CONF_CHANGE_PS)
2408 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2409
71449f8d
JO		 2410 if (conf->flags & IEEE80211_CONF_PS &&
2411 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2412 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 2413
2414 /*
2415 * We enter PSM only if we're already associated.
2416 * If we're not, we'll enter it when joining an SSID,
2417 * through the bss_info_changed() hook.
2418 */
830fb67b 2419 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 2420 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 2421 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 2422 wl->basic_rate, true);
af5e084b 2423 }
f5fc0f86 2424 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 2425 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 2426 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 2427
71449f8d 2428 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 2429
71449f8d 2430 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 2431 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 2432 wl->basic_rate, true);
f5fc0f86
LC		 2433 }
2434
2435 if (conf->power_level != wl->power_level) {
2436 ret = wl1271_acx_tx_power(wl, conf->power_level);
2437 if (ret < 0)
c6317a54 2438 goto out_sleep;
f5fc0f86
LC		 2439
2440 wl->power_level = conf->power_level;
2441 }
2442
2443out_sleep:
2444 wl1271_ps_elp_sleep(wl);
2445
2446out:
2447 mutex_unlock(&wl->mutex);
2448
2449 return ret;
2450}
2451
b54853f1
JO		 2452struct wl1271_filter_params {
2453 bool enabled;
2454 int mc_list_length;
2455 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2456};
2457
22bedad3
JP		 2458static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2459 struct netdev_hw_addr_list *mc_list)
c87dec9f 2460{
c87dec9f 2461 struct wl1271_filter_params *fp;
22bedad3 2462 struct netdev_hw_addr *ha;
2c10bb9c 2463 struct wl1271 *wl = hw->priv;
c87dec9f 2464
2c10bb9c
SD		 2465 if (unlikely(wl->state == WL1271_STATE_OFF))
2466 return 0;
c87dec9f 2467
74441130 2468 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 2469 if (!fp) {
2470 wl1271_error("Out of memory setting filters.");
2471 return 0;
2472 }
2473
2474 /* update multicast filtering parameters */
c87dec9f 2475 fp->mc_list_length = 0;
22bedad3
JP		 2476 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2477 fp->enabled = false;
2478 } else {
2479 fp->enabled = true;
2480 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 2481 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 2482 ha->addr, ETH_ALEN);
c87dec9f 2483 fp->mc_list_length++;
22bedad3 2484 }
c87dec9f
JO		 2485 }
2486
b54853f1 2487 return (u64)(unsigned long)fp;
c87dec9f 2488}
f5fc0f86 2489
b54853f1
JO		 2490#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2491 FIF_ALLMULTI | \
2492 FIF_FCSFAIL | \
2493 FIF_BCN_PRBRESP_PROMISC | \
2494 FIF_CONTROL | \
2495 FIF_OTHER_BSS)
2496
f5fc0f86
LC		 2497static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2498 unsigned int changed,
c87dec9f 2499 unsigned int *total, u64 multicast)
f5fc0f86 2500{
b54853f1 2501 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2502 struct wl1271 *wl = hw->priv;
b54853f1 2503 int ret;
f5fc0f86 2504
7d057869
AN		 2505 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2506 " total %x", changed, *total);
f5fc0f86 2507
b54853f1
JO		 2508 mutex_lock(&wl->mutex);
2509
2c10bb9c
SD		 2510 *total &= WL1271_SUPPORTED_FILTERS;
2511 changed &= WL1271_SUPPORTED_FILTERS;
2512
2513 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2514 goto out;
2515
a620865e 2516 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2517 if (ret < 0)
2518 goto out;
2519
7d057869
AN		 2520 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2521 if (*total & FIF_ALLMULTI)
2522 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2523 else if (fp)
2524 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2525 fp->mc_list,
2526 fp->mc_list_length);
2527 if (ret < 0)
2528 goto out_sleep;
2529 }
f5fc0f86 2530
08c1d1c7
EP		 2531 /*
2532 * the fw doesn't provide an api to configure the filters. instead,
2533 * the filters configuration is based on the active roles / ROC
2534 * state.
2535 */
b54853f1
JO		 2536
2537out_sleep:
2538 wl1271_ps_elp_sleep(wl);
2539
2540out:
2541 mutex_unlock(&wl->mutex);
14b228a0 2542 kfree(fp);
f5fc0f86
LC		 2543}
2544
7f179b46
AN		 2545static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2546 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2547 u16 tx_seq_16)
2548{
2549 struct wl1271_ap_key *ap_key;
2550 int i;
2551
2552 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2553
2554 if (key_size > MAX_KEY_SIZE)
2555 return -EINVAL;
2556
2557 /*
2558 * Find next free entry in ap_keys. Also check we are not replacing
2559 * an existing key.
2560 */
2561 for (i = 0; i < MAX_NUM_KEYS; i++) {
2562 if (wl->recorded_ap_keys[i] == NULL)
2563 break;
2564
2565 if (wl->recorded_ap_keys[i]->id == id) {
2566 wl1271_warning("trying to record key replacement");
2567 return -EINVAL;
2568 }
2569 }
2570
2571 if (i == MAX_NUM_KEYS)
2572 return -EBUSY;
2573
2574 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2575 if (!ap_key)
2576 return -ENOMEM;
2577
2578 ap_key->id = id;
2579 ap_key->key_type = key_type;
2580 ap_key->key_size = key_size;
2581 memcpy(ap_key->key, key, key_size);
2582 ap_key->hlid = hlid;
2583 ap_key->tx_seq_32 = tx_seq_32;
2584 ap_key->tx_seq_16 = tx_seq_16;
2585
2586 wl->recorded_ap_keys[i] = ap_key;
2587 return 0;
2588}
2589
2590static void wl1271_free_ap_keys(struct wl1271 *wl)
2591{
2592 int i;
2593
2594 for (i = 0; i < MAX_NUM_KEYS; i++) {
2595 kfree(wl->recorded_ap_keys[i]);
2596 wl->recorded_ap_keys[i] = NULL;
2597 }
2598}
2599
2600static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2601{
2602 int i, ret = 0;
2603 struct wl1271_ap_key *key;
2604 bool wep_key_added = false;
2605
2606 for (i = 0; i < MAX_NUM_KEYS; i++) {
7f97b487 2607 u8 hlid;
7f179b46
AN		 2608 if (wl->recorded_ap_keys[i] == NULL)
2609 break;
2610
2611 key = wl->recorded_ap_keys[i];
7f97b487
EP		 2612 hlid = key->hlid;
2613 if (hlid == WL12XX_INVALID_LINK_ID)
2614 hlid = wl->ap_bcast_hlid;
2615
7f179b46
AN		 2616 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2617 key->id, key->key_type,
2618 key->key_size, key->key,
7f97b487 2619 hlid, key->tx_seq_32,
7f179b46
AN		 2620 key->tx_seq_16);
2621 if (ret < 0)
2622 goto out;
2623
2624 if (key->key_type == KEY_WEP)
2625 wep_key_added = true;
2626 }
2627
2628 if (wep_key_added) {
c690ec81 2629 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
e51ae9be 2630 wl->ap_bcast_hlid);
7f179b46
AN		 2631 if (ret < 0)
2632 goto out;
2633 }
2634
2635out:
2636 wl1271_free_ap_keys(wl);
2637 return ret;
2638}
2639
2640static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2641 u8 key_size, const u8 *key, u32 tx_seq_32,
2642 u16 tx_seq_16, struct ieee80211_sta *sta)
2643{
2644 int ret;
2645 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2646
2647 if (is_ap) {
2648 struct wl1271_station *wl_sta;
2649 u8 hlid;
2650
2651 if (sta) {
2652 wl_sta = (struct wl1271_station *)sta->drv_priv;
2653 hlid = wl_sta->hlid;
2654 } else {
e51ae9be 2655 hlid = wl->ap_bcast_hlid;
7f179b46
AN		 2656 }
2657
2658 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2659 /*
2660 * We do not support removing keys after AP shutdown.
2661 * Pretend we do to make mac80211 happy.
2662 */
2663 if (action != KEY_ADD_OR_REPLACE)
2664 return 0;
2665
2666 ret = wl1271_record_ap_key(wl, id,
2667 key_type, key_size,
2668 key, hlid, tx_seq_32,
2669 tx_seq_16);
2670 } else {
2671 ret = wl1271_cmd_set_ap_key(wl, action,
2672 id, key_type, key_size,
2673 key, hlid, tx_seq_32,
2674 tx_seq_16);
2675 }
2676
2677 if (ret < 0)
2678 return ret;
2679 } else {
2680 const u8 *addr;
2681 static const u8 bcast_addr[ETH_ALEN] = {
2682 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2683 };
2684
e9eb8cbe
GE		 2685 /*
2686 * A STA set to GEM cipher requires 2 tx spare blocks.
2687 * Return to default value when GEM cipher key is removed
2688 */
2689 if (key_type == KEY_GEM) {
2690 if (action == KEY_ADD_OR_REPLACE)
2691 wl->tx_spare_blocks = 2;
2692 else if (action == KEY_REMOVE)
2693 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
2694 }
2695
7f179b46
AN		 2696 addr = sta ? sta->addr : bcast_addr;
2697
2698 if (is_zero_ether_addr(addr)) {
2699 /* We dont support TX only encryption */
2700 return -EOPNOTSUPP;
2701 }
2702
2703 /* The wl1271 does not allow to remove unicast keys - they
2704 will be cleared automatically on next CMD_JOIN. Ignore the
2705 request silently, as we dont want the mac80211 to emit
2706 an error message. */
2707 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2708 return 0;
2709
010d3d30
EP		 2710 /* don't remove key if hlid was already deleted */
2711 if (action == KEY_REMOVE &&
2712 wl->sta_hlid == WL12XX_INVALID_LINK_ID)
2713 return 0;
2714
7f179b46
AN		 2715 ret = wl1271_cmd_set_sta_key(wl, action,
2716 id, key_type, key_size,
2717 key, addr, tx_seq_32,
2718 tx_seq_16);
2719 if (ret < 0)
2720 return ret;
2721
2722 /* the default WEP key needs to be configured at least once */
2723 if (key_type == KEY_WEP) {
c690ec81
EP		 2724 ret = wl12xx_cmd_set_default_wep_key(wl,
2725 wl->default_key,
2726 wl->sta_hlid);
7f179b46
AN		 2727 if (ret < 0)
2728 return ret;
2729 }
2730 }
2731
2732 return 0;
2733}
2734
f5fc0f86
LC		 2735static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2736 struct ieee80211_vif *vif,
2737 struct ieee80211_sta *sta,
2738 struct ieee80211_key_conf *key_conf)
2739{
2740 struct wl1271 *wl = hw->priv;
f5fc0f86 2741 int ret;
ac4e4ce5
JO		 2742 u32 tx_seq_32 = 0;
2743 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2744 u8 key_type;
2745
f5fc0f86
LC		 2746 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2747
7f179b46 2748 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2749 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2750 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2751 key_conf->keylen, key_conf->flags);
2752 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2753
f5fc0f86
LC		 2754 mutex_lock(&wl->mutex);
2755
f8d9802f
JO		 2756 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2757 ret = -EAGAIN;
2758 goto out_unlock;
2759 }
2760
a620865e 2761 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2762 if (ret < 0)
2763 goto out_unlock;
2764
97359d12
JB		 2765 switch (key_conf->cipher) {
2766 case WLAN_CIPHER_SUITE_WEP40:
2767 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2768 key_type = KEY_WEP;
2769
2770 key_conf->hw_key_idx = key_conf->keyidx;
2771 break;
97359d12 2772 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2773 key_type = KEY_TKIP;
2774
2775 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 2776 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2777 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2778 break;
97359d12 2779 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 2780 key_type = KEY_AES;
2781
2782 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 2783 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2784 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2785 break;
7a55724e
JO		 2786 case WL1271_CIPHER_SUITE_GEM:
2787 key_type = KEY_GEM;
2788 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2789 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2790 break;
f5fc0f86 2791 default:
97359d12 2792 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 2793
2794 ret = -EOPNOTSUPP;
2795 goto out_sleep;
2796 }
2797
2798 switch (cmd) {
2799 case SET_KEY:
7f179b46
AN		 2800 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2801 key_conf->keyidx, key_type,
2802 key_conf->keylen, key_conf->key,
2803 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 2804 if (ret < 0) {
2805 wl1271_error("Could not add or replace key");
2806 goto out_sleep;
2807 }
2808 break;
2809
2810 case DISABLE_KEY:
7f179b46
AN		 2811 ret = wl1271_set_key(wl, KEY_REMOVE,
2812 key_conf->keyidx, key_type,
2813 key_conf->keylen, key_conf->key,
2814 0, 0, sta);
f5fc0f86
LC		 2815 if (ret < 0) {
2816 wl1271_error("Could not remove key");
2817 goto out_sleep;
2818 }
2819 break;
2820
2821 default:
2822 wl1271_error("Unsupported key cmd 0x%x", cmd);
2823 ret = -EOPNOTSUPP;
f5fc0f86
LC		 2824 break;
2825 }
2826
2827out_sleep:
2828 wl1271_ps_elp_sleep(wl);
2829
2830out_unlock:
2831 mutex_unlock(&wl->mutex);
2832
f5fc0f86
LC		 2833 return ret;
2834}
2835
2836static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 2837 struct ieee80211_vif *vif,
f5fc0f86
LC		 2838 struct cfg80211_scan_request *req)
2839{
2840 struct wl1271 *wl = hw->priv;
2841 int ret;
2842 u8 *ssid = NULL;
abb0b3bf 2843 size_t len = 0;
f5fc0f86
LC		 2844
2845 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2846
2847 if (req->n_ssids) {
2848 ssid = req->ssids[0].ssid;
abb0b3bf 2849 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 2850 }
2851
2852 mutex_lock(&wl->mutex);
2853
b739a42c
JO		 2854 if (wl->state == WL1271_STATE_OFF) {
2855 /*
2856 * We cannot return -EBUSY here because cfg80211 will expect
2857 * a call to ieee80211_scan_completed if we do - in this case
2858 * there won't be any call.
2859 */
2860 ret = -EAGAIN;
2861 goto out;
2862 }
2863
a620865e 2864 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2865 if (ret < 0)
2866 goto out;
2867
251c177f
EP		 2868 /* cancel ROC before scanning */
2869 if (wl12xx_is_roc(wl)) {
2870 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2871 /* don't allow scanning right now */
2872 ret = -EBUSY;
2873 goto out_sleep;
2874 }
2875 wl12xx_croc(wl, wl->dev_role_id);
2876 wl12xx_cmd_role_stop_dev(wl);
2877 }
f5fc0f86 2878
251c177f
EP		 2879 ret = wl1271_scan(hw->priv, ssid, len, req);
2880out_sleep:
f5fc0f86 2881 wl1271_ps_elp_sleep(wl);
f5fc0f86
LC		 2882out:
2883 mutex_unlock(&wl->mutex);
2884
2885 return ret;
2886}
2887
73ecce31
EP		 2888static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2889 struct ieee80211_vif *vif)
2890{
2891 struct wl1271 *wl = hw->priv;
2892 int ret;
2893
2894 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2895
2896 mutex_lock(&wl->mutex);
2897
2898 if (wl->state == WL1271_STATE_OFF)
2899 goto out;
2900
2901 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2902 goto out;
2903
2904 ret = wl1271_ps_elp_wakeup(wl);
2905 if (ret < 0)
2906 goto out;
2907
2908 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2909 ret = wl1271_scan_stop(wl);
2910 if (ret < 0)
2911 goto out_sleep;
2912 }
2913 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2914 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2915 wl->scan.req = NULL;
2916 ieee80211_scan_completed(wl->hw, true);
2917
2918out_sleep:
2919 wl1271_ps_elp_sleep(wl);
2920out:
2921 mutex_unlock(&wl->mutex);
2922
2923 cancel_delayed_work_sync(&wl->scan_complete_work);
2924}
2925
33c2c06c
LC		 2926static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2927 struct ieee80211_vif *vif,
2928 struct cfg80211_sched_scan_request *req,
2929 struct ieee80211_sched_scan_ies *ies)
2930{
2931 struct wl1271 *wl = hw->priv;
2932 int ret;
2933
2934 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2935
2936 mutex_lock(&wl->mutex);
2937
2938 ret = wl1271_ps_elp_wakeup(wl);
2939 if (ret < 0)
2940 goto out;
2941
2942 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2943 if (ret < 0)
2944 goto out_sleep;
2945
2946 ret = wl1271_scan_sched_scan_start(wl);
2947 if (ret < 0)
2948 goto out_sleep;
2949
2950 wl->sched_scanning = true;
2951
2952out_sleep:
2953 wl1271_ps_elp_sleep(wl);
2954out:
2955 mutex_unlock(&wl->mutex);
2956 return ret;
2957}
2958
2959static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2960 struct ieee80211_vif *vif)
2961{
2962 struct wl1271 *wl = hw->priv;
2963 int ret;
2964
2965 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2966
2967 mutex_lock(&wl->mutex);
2968
2969 ret = wl1271_ps_elp_wakeup(wl);
2970 if (ret < 0)
2971 goto out;
2972
2973 wl1271_scan_sched_scan_stop(wl);
2974
2975 wl1271_ps_elp_sleep(wl);
2976out:
2977 mutex_unlock(&wl->mutex);
2978}
2979
68d069c4
AN		 2980static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2981{
2982 struct wl1271 *wl = hw->priv;
2983 int ret = 0;
2984
2985 mutex_lock(&wl->mutex);
2986
2987 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2988 ret = -EAGAIN;
2989 goto out;
2990 }
2991
a620865e 2992 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 2993 if (ret < 0)
2994 goto out;
2995
5f704d18 2996 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 2997 if (ret < 0)
2998 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2999
3000 wl1271_ps_elp_sleep(wl);
3001
3002out:
3003 mutex_unlock(&wl->mutex);
3004
3005 return ret;
3006}
3007
f5fc0f86
LC		 3008static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3009{
3010 struct wl1271 *wl = hw->priv;
aecb0565 3011 int ret = 0;
f5fc0f86
LC		 3012
3013 mutex_lock(&wl->mutex);
3014
f8d9802f
JO		 3015 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3016 ret = -EAGAIN;
aecb0565 3017 goto out;
f8d9802f 3018 }
aecb0565 3019
a620865e 3020 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 3021 if (ret < 0)
3022 goto out;
3023
5f704d18 3024 ret = wl1271_acx_rts_threshold(wl, value);
f5fc0f86
LC		 3025 if (ret < 0)
3026 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
3027
3028 wl1271_ps_elp_sleep(wl);
3029
3030out:
3031 mutex_unlock(&wl->mutex);
3032
3033 return ret;
3034}
3035
e78a287a 3036static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 3037 int offset)
30240fc7 3038{
889cb360
EP		 3039 u8 ssid_len;
3040 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
3041 skb->len - offset);
30240fc7 3042
889cb360
EP		 3043 if (!ptr) {
3044 wl1271_error("No SSID in IEs!");
3045 return -ENOENT;
3046 }
3047
3048 ssid_len = ptr[1];
3049 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
3050 wl1271_error("SSID is too long!");
3051 return -EINVAL;
30240fc7 3052 }
e78a287a 3053
889cb360
EP		 3054 wl->ssid_len = ssid_len;
3055 memcpy(wl->ssid, ptr+2, ssid_len);
3056 return 0;
30240fc7
JO		 3057}
3058
e78a287a 3059static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 3060 struct ieee80211_bss_conf *bss_conf,
3061 u32 changed)
3062{
e78a287a 3063 int ret = 0;
f5fc0f86 3064
e78a287a
AN		 3065 if (changed & BSS_CHANGED_ERP_SLOT) {
3066 if (bss_conf->use_short_slot)
3067 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
3068 else
3069 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
3070 if (ret < 0) {
3071 wl1271_warning("Set slot time failed %d", ret);
3072 goto out;
3073 }
3074 }
f5fc0f86 3075
e78a287a
AN		 3076 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3077 if (bss_conf->use_short_preamble)
3078 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
3079 else
3080 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
3081 }
f5fc0f86 3082
e78a287a
AN		 3083 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3084 if (bss_conf->use_cts_prot)
3085 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
3086 else
3087 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
3088 if (ret < 0) {
3089 wl1271_warning("Set ctsprotect failed %d", ret);
3090 goto out;
3091 }
3092 }
f8d9802f 3093
e78a287a
AN		 3094out:
3095 return ret;
3096}
f5fc0f86 3097
e78a287a
AN		 3098static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3099 struct ieee80211_vif *vif,
3100 struct ieee80211_bss_conf *bss_conf,
3101 u32 changed)
3102{
3103 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3104 int ret = 0;
3105
3106 if ((changed & BSS_CHANGED_BEACON_INT)) {
3107 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 3108 bss_conf->beacon_int);
3109
3110 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 3111 }
3112
e78a287a
AN		 3113 if ((changed & BSS_CHANGED_BEACON)) {
3114 struct ieee80211_hdr *hdr;
3115 int ieoffset = offsetof(struct ieee80211_mgmt,
3116 u.beacon.variable);
3117 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3118 u16 tmpl_id;
3119
3120 if (!beacon)
3121 goto out;
3122
3123 wl1271_debug(DEBUG_MASTER, "beacon updated");
3124
3125 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3126 if (ret < 0) {
3127 dev_kfree_skb(beacon);
3128 goto out;
3129 }
3130 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3131 CMD_TEMPL_BEACON;
3132 ret = wl1271_cmd_template_set(wl, tmpl_id,
3133 beacon->data,
3134 beacon->len, 0,
3135 wl1271_tx_min_rate_get(wl));
3136 if (ret < 0) {
3137 dev_kfree_skb(beacon);
3138 goto out;
3139 }
3140
3141 hdr = (struct ieee80211_hdr *) beacon->data;
3142 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3143 IEEE80211_STYPE_PROBE_RESP);
3144
3145 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3146 CMD_TEMPL_PROBE_RESPONSE;
3147 ret = wl1271_cmd_template_set(wl,
3148 tmpl_id,
3149 beacon->data,
3150 beacon->len, 0,
3151 wl1271_tx_min_rate_get(wl));
3152 dev_kfree_skb(beacon);
3153 if (ret < 0)
3154 goto out;
3155 }
3156
3157out:
3158 return ret;
3159}
3160
3161/* AP mode changes */
3162static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3163 struct ieee80211_vif *vif,
3164 struct ieee80211_bss_conf *bss_conf,
3165 u32 changed)
3166{
3167 int ret = 0;
e0d8bbf0 3168
e78a287a
AN		 3169 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3170 u32 rates = bss_conf->basic_rates;
5da11dcd 3171
e78a287a
AN		 3172 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3173 wl->basic_rate = wl1271_tx_min_rate_get(wl);
70f47424
AN		 3174
3175 ret = wl1271_init_ap_rates(wl);
e78a287a 3176 if (ret < 0) {
70f47424 3177 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 3178 goto out;
3179 }
c45a85b5
AN		 3180
3181 ret = wl1271_ap_init_templates(wl);
3182 if (ret < 0)
3183 goto out;
e78a287a 3184 }
2f6724b2 3185
e78a287a
AN		 3186 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3187 if (ret < 0)
3188 goto out;
30240fc7 3189
e78a287a
AN		 3190 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3191 if (bss_conf->enable_beacon) {
3192 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
c690ec81 3193 ret = wl12xx_cmd_role_start_ap(wl);
e78a287a
AN		 3194 if (ret < 0)
3195 goto out;
e0d8bbf0 3196
7f179b46
AN		 3197 ret = wl1271_ap_init_hwenc(wl);
3198 if (ret < 0)
3199 goto out;
cf42039f
AN		 3200
3201 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3202 wl1271_debug(DEBUG_AP, "started AP");
e0d8bbf0 3203 }
e78a287a
AN		 3204 } else {
3205 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
c690ec81 3206 ret = wl12xx_cmd_role_stop_ap(wl);
e78a287a
AN		 3207 if (ret < 0)
3208 goto out;
e0d8bbf0 3209
e78a287a
AN		 3210 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3211 wl1271_debug(DEBUG_AP, "stopped AP");
3212 }
3213 }
3214 }
e0d8bbf0 3215
e78a287a
AN		 3216 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3217 if (ret < 0)
3218 goto out;
0b932ab9
AN		 3219
3220 /* Handle HT information change */
3221 if ((changed & BSS_CHANGED_HT) &&
3222 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3223 ret = wl1271_acx_set_ht_information(wl,
3224 bss_conf->ht_operation_mode);
3225 if (ret < 0) {
3226 wl1271_warning("Set ht information failed %d", ret);
3227 goto out;
3228 }
3229 }
3230
e78a287a
AN		 3231out:
3232 return;
3233}
8bf29b0e 3234
e78a287a
AN		 3235/* STA/IBSS mode changes */
3236static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3237 struct ieee80211_vif *vif,
3238 struct ieee80211_bss_conf *bss_conf,
3239 u32 changed)
3240{
3241 bool do_join = false, set_assoc = false;
3242 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
227e81e1 3243 bool ibss_joined = false;
72c2d9e5 3244 u32 sta_rate_set = 0;
e78a287a 3245 int ret;
2d6e4e76 3246 struct ieee80211_sta *sta;
a100885d
AN		 3247 bool sta_exists = false;
3248 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 3249
3250 if (is_ibss) {
3251 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3252 changed);
3253 if (ret < 0)
3254 goto out;
e0d8bbf0
JO		 3255 }
3256
227e81e1
EP		 3257 if (changed & BSS_CHANGED_IBSS) {
3258 if (bss_conf->ibss_joined) {
3259 set_bit(WL1271_FLAG_IBSS_JOINED, &wl->flags);
3260 ibss_joined = true;
3261 } else {
3262 if (test_and_clear_bit(WL1271_FLAG_IBSS_JOINED,
3263 &wl->flags)) {
3264 wl1271_unjoin(wl);
3265 wl12xx_cmd_role_start_dev(wl);
3266 wl12xx_roc(wl, wl->dev_role_id);
3267 }
3268 }
3269 }
3270
3271 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
e78a287a
AN		 3272 do_join = true;
3273
3274 /* Need to update the SSID (for filtering etc) */
227e81e1 3275 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
e78a287a
AN		 3276 do_join = true;
3277
227e81e1 3278 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
5da11dcd
JO		 3279 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3280 bss_conf->enable_beacon ? "enabled" : "disabled");
3281
3282 if (bss_conf->enable_beacon)
3283 wl->set_bss_type = BSS_TYPE_IBSS;
3284 else
3285 wl->set_bss_type = BSS_TYPE_STA_BSS;
3286 do_join = true;
3287 }
3288
e78a287a 3289 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 3290 bool enable = false;
3291 if (bss_conf->cqm_rssi_thold)
3292 enable = true;
3293 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3294 bss_conf->cqm_rssi_thold,
3295 bss_conf->cqm_rssi_hyst);
3296 if (ret < 0)
3297 goto out;
3298 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3299 }
3300
30240fc7
JO		 3301 if ((changed & BSS_CHANGED_BSSID) &&
3302 /*
3303 * Now we know the correct bssid, so we send a new join command
3304 * and enable the BSSID filter
3305 */
3306 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 3307 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 3308
fa287b8f
EP		 3309 if (!is_zero_ether_addr(wl->bssid)) {
3310 ret = wl1271_cmd_build_null_data(wl);
3311 if (ret < 0)
3312 goto out;
30240fc7 3313
fa287b8f
EP		 3314 ret = wl1271_build_qos_null_data(wl);
3315 if (ret < 0)
3316 goto out;
30240fc7 3317
fa287b8f
EP		 3318 /* Need to update the BSSID (for filtering etc) */
3319 do_join = true;
3320 }
30240fc7
JO		 3321 }
3322
0f9c8250
AN		 3323 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3324 rcu_read_lock();
3325 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3326 if (!sta)
3327 goto sta_not_found;
3328
72c2d9e5
EP		 3329 /* save the supp_rates of the ap */
3330 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3331 if (sta->ht_cap.ht_supported)
3332 sta_rate_set |=
3333 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 3334 sta_ht_cap = sta->ht_cap;
3335 sta_exists = true;
72c2d9e5 3336
0f9c8250
AN		 3337sta_not_found:
3338 rcu_read_unlock();
72c2d9e5 3339 }
72c2d9e5 3340
e78a287a 3341 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 3342 if (bss_conf->assoc) {
ebba60c6 3343 u32 rates;
2f6724b2 3344 int ieoffset;
f5fc0f86 3345 wl->aid = bss_conf->aid;
69e5434c 3346 set_assoc = true;
f5fc0f86 3347
90494a90
JO		 3348 wl->ps_poll_failures = 0;
3349
ebba60c6
JO		 3350 /*
3351 * use basic rates from AP, and determine lowest rate
3352 * to use with control frames.
3353 */
3354 rates = bss_conf->basic_rates;
3355 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3356 rates);
e0fe371b 3357 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 3358 if (sta_rate_set)
3359 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3360 sta_rate_set);
79b223f4 3361 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3362 if (ret < 0)
e78a287a 3363 goto out;
ebba60c6 3364
ae751bab
LC		 3365 /*
3366 * with wl1271, we don't need to update the
3367 * beacon_int and dtim_period, because the firmware
3368 * updates it by itself when the first beacon is
3369 * received after a join.
3370 */
f5fc0f86
LC		 3371 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3372 if (ret < 0)
e78a287a 3373 goto out;
f5fc0f86 3374
c2b2d99b 3375 /*
2f6724b2 3376 * Get a template for hardware connection maintenance
c2b2d99b 3377 */
2f6724b2
JO		 3378 dev_kfree_skb(wl->probereq);
3379 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3380 ieoffset = offsetof(struct ieee80211_mgmt,
3381 u.probe_req.variable);
3382 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 3383
6ccbb92e
JO		 3384 /* enable the connection monitoring feature */
3385 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 3386 if (ret < 0)
e78a287a 3387 goto out;
d94cd297
JO		 3388 } else {
3389 /* use defaults when not associated */
30df14d0
EP		 3390 bool was_assoc =
3391 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3392 &wl->flags);
251c177f
EP		 3393 bool was_ifup =
3394 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3395 &wl->flags);
d94cd297 3396 wl->aid = 0;
6ccbb92e 3397
2f6724b2
JO		 3398 /* free probe-request template */
3399 dev_kfree_skb(wl->probereq);
3400 wl->probereq = NULL;
3401
8d2ef7bd 3402 /* re-enable dynamic ps - just in case */
f532be6d 3403 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 3404
ebba60c6
JO		 3405 /* revert back to minimum rates for the current band */
3406 wl1271_set_band_rate(wl);
e0fe371b 3407 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 3408 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3409 if (ret < 0)
e78a287a 3410 goto out;
ebba60c6 3411
6ccbb92e
JO		 3412 /* disable connection monitor features */
3413 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 3414
3415 /* Disable the keep-alive feature */
3416 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 3417 if (ret < 0)
e78a287a 3418 goto out;
b84a7d3d
JO		 3419
3420 /* restore the bssid filter and go to dummy bssid */
30df14d0 3421 if (was_assoc) {
251c177f
EP		 3422 u32 conf_flags = wl->hw->conf.flags;
3423 /*
3424 * we might have to disable roc, if there was
3425 * no IF_OPER_UP notification.
3426 */
3427 if (!was_ifup) {
3428 ret = wl12xx_croc(wl, wl->role_id);
3429 if (ret < 0)
3430 goto out;
3431 }
3432 /*
3433 * (we also need to disable roc in case of
3434 * roaming on the same channel. until we will
3435 * have a better flow...)
3436 */
3437 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3438 ret = wl12xx_croc(wl, wl->dev_role_id);
3439 if (ret < 0)
3440 goto out;
3441 }
3442
30df14d0 3443 wl1271_unjoin(wl);
251c177f
EP		 3444 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3445 wl12xx_cmd_role_start_dev(wl);
3446 wl12xx_roc(wl, wl->dev_role_id);
3447 }
30df14d0 3448 }
f5fc0f86 3449 }
f5fc0f86
LC		 3450 }
3451
d192d268
EP		 3452 if (changed & BSS_CHANGED_IBSS) {
3453 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3454 bss_conf->ibss_joined);
3455
3456 if (bss_conf->ibss_joined) {
3457 u32 rates = bss_conf->basic_rates;
3458 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3459 rates);
3460 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3461
3462 /* by default, use 11b rates */
3463 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3464 ret = wl1271_acx_sta_rate_policies(wl);
3465 if (ret < 0)
3466 goto out;
3467 }
3468 }
3469
e78a287a
AN		 3470 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3471 if (ret < 0)
3472 goto out;
f5fc0f86 3473
ca52a5eb
JO		 3474 if (changed & BSS_CHANGED_ARP_FILTER) {
3475 __be32 addr = bss_conf->arp_addr_list[0];
3476 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3477
c5312772
EP		 3478 if (bss_conf->arp_addr_cnt == 1 &&
3479 bss_conf->arp_filter_enabled) {
3480 /*
3481 * The template should have been configured only upon
3482 * association. however, it seems that the correct ip
3483 * isn't being set (when sending), so we have to
3484 * reconfigure the template upon every ip change.
3485 */
3486 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3487 if (ret < 0) {
3488 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 3489 goto out;
c5312772
EP		 3490 }
3491
3492 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 3493 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 3494 addr);
3495 } else
3496 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 3497
3498 if (ret < 0)
e78a287a 3499 goto out;
ca52a5eb
JO		 3500 }
3501
8bf29b0e 3502 if (do_join) {
69e5434c 3503 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 3504 if (ret < 0) {
3505 wl1271_warning("cmd join failed %d", ret);
e78a287a 3506 goto out;
8bf29b0e 3507 }
251c177f
EP		 3508
3509 /* ROC until connected (after EAPOL exchange) */
3510 if (!is_ibss) {
3511 ret = wl12xx_roc(wl, wl->role_id);
3512 if (ret < 0)
3513 goto out;
3514
3515 wl1271_check_operstate(wl,
3516 ieee80211_get_operstate(vif));
3517 }
3518 /*
3519 * stop device role if started (we might already be in
3520 * STA role). TODO: make it better.
3521 */
3522 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3523 ret = wl12xx_croc(wl, wl->dev_role_id);
3524 if (ret < 0)
3525 goto out;
3526
3527 ret = wl12xx_cmd_role_stop_dev(wl);
3528 if (ret < 0)
3529 goto out;
3530 }
05dba355
EP		 3531
3532 /* If we want to go in PSM but we're not there yet */
3533 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3534 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
3535 enum wl1271_cmd_ps_mode mode;
3536
3537 mode = STATION_POWER_SAVE_MODE;
3538 ret = wl1271_ps_set_mode(wl, mode,
3539 wl->basic_rate,
3540 true);
3541 if (ret < 0)
3542 goto out;
3543 }
c1899554
JO		 3544 }
3545
0b932ab9 3546 /* Handle new association with HT. Do this after join. */
0f9c8250
AN		 3547 if (sta_exists) {
3548 if ((changed & BSS_CHANGED_HT) &&
3549 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0b932ab9
AN		 3550 ret = wl1271_acx_set_ht_capabilities(wl,
3551 &sta_ht_cap,
3552 true,
3553 wl->sta_hlid);
0f9c8250
AN		 3554 if (ret < 0) {
3555 wl1271_warning("Set ht cap true failed %d",
3556 ret);
3557 goto out;
3558 }
3559 }
3560 /* handle new association without HT and disassociation */
3561 else if (changed & BSS_CHANGED_ASSOC) {
0b932ab9
AN		 3562 ret = wl1271_acx_set_ht_capabilities(wl,
3563 &sta_ht_cap,
3564 false,
3565 wl->sta_hlid);
0f9c8250
AN		 3566 if (ret < 0) {
3567 wl1271_warning("Set ht cap false failed %d",
3568 ret);
3569 goto out;
3570 }
3571 }
3572 }
3573
0b932ab9
AN		 3574 /* Handle HT information change. Done after join. */
3575 if ((changed & BSS_CHANGED_HT) &&
0f9c8250
AN		 3576 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3577 ret = wl1271_acx_set_ht_information(wl,
3578 bss_conf->ht_operation_mode);
3579 if (ret < 0) {
3580 wl1271_warning("Set ht information failed %d", ret);
3581 goto out;
3582 }
3583 }
3584
e78a287a
AN		 3585out:
3586 return;
3587}
3588
3589static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3590 struct ieee80211_vif *vif,
3591 struct ieee80211_bss_conf *bss_conf,
3592 u32 changed)
3593{
3594 struct wl1271 *wl = hw->priv;
3595 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3596 int ret;
3597
3598 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3599 (int)changed);
3600
3601 mutex_lock(&wl->mutex);
3602
3603 if (unlikely(wl->state == WL1271_STATE_OFF))
3604 goto out;
3605
a620865e 3606 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3607 if (ret < 0)
3608 goto out;
3609
3610 if (is_ap)
3611 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3612 else
3613 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3614
f5fc0f86
LC		 3615 wl1271_ps_elp_sleep(wl);
3616
3617out:
3618 mutex_unlock(&wl->mutex);
3619}
3620
c6999d83
KV		 3621static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3622 const struct ieee80211_tx_queue_params *params)
3623{
3624 struct wl1271 *wl = hw->priv;
4695dc91 3625 u8 ps_scheme;
488fc540 3626 int ret = 0;
c6999d83
KV		 3627
3628 mutex_lock(&wl->mutex);
3629
3630 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3631
4695dc91
KV		 3632 if (params->uapsd)
3633 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3634 else
3635 ps_scheme = CONF_PS_SCHEME_LEGACY;
3636
488fc540
AN		 3637 if (wl->state == WL1271_STATE_OFF) {
3638 /*
3639 * If the state is off, the parameters will be recorded and
3640 * configured on init. This happens in AP-mode.
3641 */
3642 struct conf_tx_ac_category *conf_ac =
3643 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3644 struct conf_tx_tid *conf_tid =
3645 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3646
3647 conf_ac->ac = wl1271_tx_get_queue(queue);
3648 conf_ac->cw_min = (u8)params->cw_min;
3649 conf_ac->cw_max = params->cw_max;
3650 conf_ac->aifsn = params->aifs;
3651 conf_ac->tx_op_limit = params->txop << 5;
3652
3653 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3654 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3655 conf_tid->tsid = wl1271_tx_get_queue(queue);
3656 conf_tid->ps_scheme = ps_scheme;
3657 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3658 conf_tid->apsd_conf[0] = 0;
3659 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3660 goto out;
3661 }
488fc540 3662
c1b193eb
EP		 3663 ret = wl1271_ps_elp_wakeup(wl);
3664 if (ret < 0)
3665 goto out;
488fc540 3666
c1b193eb
EP		 3667 /*
3668 * the txop is confed in units of 32us by the mac80211,
3669 * we need us
3670 */
3671 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3672 params->cw_min, params->cw_max,
3673 params->aifs, params->txop << 5);
3674 if (ret < 0)
3675 goto out_sleep;
3676
3677 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3678 CONF_CHANNEL_TYPE_EDCF,
3679 wl1271_tx_get_queue(queue),
3680 ps_scheme, CONF_ACK_POLICY_LEGACY,
3681 0, 0);
c82c1dde
KV		 3682
3683out_sleep:
c1b193eb 3684 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 3685
3686out:
3687 mutex_unlock(&wl->mutex);
3688
3689 return ret;
3690}
3691
bbbb538e
JO		 3692static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3693{
3694
3695 struct wl1271 *wl = hw->priv;
3696 u64 mactime = ULLONG_MAX;
3697 int ret;
3698
3699 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3700
3701 mutex_lock(&wl->mutex);
3702
f8d9802f
JO		 3703 if (unlikely(wl->state == WL1271_STATE_OFF))
3704 goto out;
3705
a620865e 3706 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 3707 if (ret < 0)
3708 goto out;
3709
3710 ret = wl1271_acx_tsf_info(wl, &mactime);
3711 if (ret < 0)
3712 goto out_sleep;
3713
3714out_sleep:
3715 wl1271_ps_elp_sleep(wl);
3716
3717out:
3718 mutex_unlock(&wl->mutex);
3719 return mactime;
3720}
f5fc0f86 3721
ece550d0
JL		 3722static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3723 struct survey_info *survey)
3724{
3725 struct wl1271 *wl = hw->priv;
3726 struct ieee80211_conf *conf = &hw->conf;
b739a42c 3727
ece550d0
JL		 3728 if (idx != 0)
3729 return -ENOENT;
b739a42c 3730
ece550d0
JL		 3731 survey->channel = conf->channel;
3732 survey->filled = SURVEY_INFO_NOISE_DBM;
3733 survey->noise = wl->noise;
b739a42c 3734
ece550d0
JL		 3735 return 0;
3736}
3737
409622ec 3738static int wl1271_allocate_sta(struct wl1271 *wl,
f84f7d78
AN		 3739 struct ieee80211_sta *sta,
3740 u8 *hlid)
3741{
3742 struct wl1271_station *wl_sta;
3743 int id;
3744
3745 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3746 if (id >= AP_MAX_STATIONS) {
3747 wl1271_warning("could not allocate HLID - too much stations");
3748 return -EBUSY;
3749 }
3750
3751 wl_sta = (struct wl1271_station *)sta->drv_priv;
04216da3 3752 set_bit(id, wl->ap_hlid_map);
f84f7d78
AN		 3753 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3754 *hlid = wl_sta->hlid;
b622d992 3755 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
da03209e 3756 wl->active_sta_count++;
f84f7d78
AN		 3757 return 0;
3758}
3759
f1acea9a 3760void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
f84f7d78
AN		 3761{
3762 int id = hlid - WL1271_AP_STA_HLID_START;
3763
f1acea9a
AN		 3764 if (hlid < WL1271_AP_STA_HLID_START)
3765 return;
3766
3767 if (!test_bit(id, wl->ap_hlid_map))
409622ec
AN		 3768 return;
3769
04216da3 3770 clear_bit(id, wl->ap_hlid_map);
b622d992 3771 memset(wl->links[hlid].addr, 0, ETH_ALEN);
0f9c8250 3772 wl->links[hlid].ba_bitmap = 0;
a8c0ddb5 3773 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 3774 __clear_bit(hlid, &wl->ap_ps_map);
3775 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
da03209e 3776 wl->active_sta_count--;
f84f7d78
AN		 3777}
3778
3779static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3780 struct ieee80211_vif *vif,
3781 struct ieee80211_sta *sta)
3782{
3783 struct wl1271 *wl = hw->priv;
3784 int ret = 0;
3785 u8 hlid;
3786
3787 mutex_lock(&wl->mutex);
3788
3789 if (unlikely(wl->state == WL1271_STATE_OFF))
3790 goto out;
3791
3792 if (wl->bss_type != BSS_TYPE_AP_BSS)
3793 goto out;
3794
3795 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3796
409622ec 3797 ret = wl1271_allocate_sta(wl, sta, &hlid);
f84f7d78
AN		 3798 if (ret < 0)
3799 goto out;
3800
a620865e 3801 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 3802 if (ret < 0)
409622ec 3803 goto out_free_sta;
f84f7d78 3804
c690ec81 3805 ret = wl12xx_cmd_add_peer(wl, sta, hlid);
f84f7d78
AN		 3806 if (ret < 0)
3807 goto out_sleep;
3808
b67476ef
EP		 3809 ret = wl12xx_cmd_set_peer_state(wl, hlid);
3810 if (ret < 0)
3811 goto out_sleep;
3812
0b932ab9
AN		 3813 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
3814 if (ret < 0)
3815 goto out_sleep;
3816
f84f7d78
AN		 3817out_sleep:
3818 wl1271_ps_elp_sleep(wl);
3819
409622ec
AN		 3820out_free_sta:
3821 if (ret < 0)
3822 wl1271_free_sta(wl, hlid);
3823
f84f7d78
AN		 3824out:
3825 mutex_unlock(&wl->mutex);
3826 return ret;
3827}
3828
3829static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3830 struct ieee80211_vif *vif,
3831 struct ieee80211_sta *sta)
3832{
3833 struct wl1271 *wl = hw->priv;
3834 struct wl1271_station *wl_sta;
3835 int ret = 0, id;
3836
3837 mutex_lock(&wl->mutex);
3838
3839 if (unlikely(wl->state == WL1271_STATE_OFF))
3840 goto out;
3841
3842 if (wl->bss_type != BSS_TYPE_AP_BSS)
3843 goto out;
3844
3845 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3846
3847 wl_sta = (struct wl1271_station *)sta->drv_priv;
3848 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3849 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3850 goto out;
3851
a620865e 3852 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 3853 if (ret < 0)
3854 goto out;
3855
c690ec81 3856 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
f84f7d78
AN		 3857 if (ret < 0)
3858 goto out_sleep;
3859
409622ec 3860 wl1271_free_sta(wl, wl_sta->hlid);
f84f7d78
AN		 3861
3862out_sleep:
3863 wl1271_ps_elp_sleep(wl);
3864
3865out:
3866 mutex_unlock(&wl->mutex);
3867 return ret;
3868}
3869
4623ec7d
LC		 3870static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3871 struct ieee80211_vif *vif,
3872 enum ieee80211_ampdu_mlme_action action,
3873 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3874 u8 buf_size)
bbba3e68
LS		 3875{
3876 struct wl1271 *wl = hw->priv;
3877 int ret;
0f9c8250
AN		 3878 u8 hlid, *ba_bitmap;
3879
3880 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
3881 tid);
3882
3883 /* sanity check - the fields in FW are only 8bits wide */
3884 if (WARN_ON(tid > 0xFF))
3885 return -ENOTSUPP;
bbba3e68
LS		 3886
3887 mutex_lock(&wl->mutex);
3888
3889 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3890 ret = -EAGAIN;
3891 goto out;
3892 }
3893
0f9c8250
AN		 3894 if (wl->bss_type == BSS_TYPE_STA_BSS) {
3895 hlid = wl->sta_hlid;
3896 ba_bitmap = &wl->ba_rx_bitmap;
3897 } else if (wl->bss_type == BSS_TYPE_AP_BSS) {
3898 struct wl1271_station *wl_sta;
3899
3900 wl_sta = (struct wl1271_station *)sta->drv_priv;
3901 hlid = wl_sta->hlid;
3902 ba_bitmap = &wl->links[hlid].ba_bitmap;
3903 } else {
3904 ret = -EINVAL;
3905 goto out;
3906 }
3907
a620865e 3908 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 3909 if (ret < 0)
3910 goto out;
3911
70559a06
SL		 3912 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3913 tid, action);
3914
bbba3e68
LS		 3915 switch (action) {
3916 case IEEE80211_AMPDU_RX_START:
0f9c8250 3917 if (!wl->ba_support || !wl->ba_allowed) {
bbba3e68 3918 ret = -ENOTSUPP;
0f9c8250
AN		 3919 break;
3920 }
3921
3922 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
3923 ret = -EBUSY;
3924 wl1271_error("exceeded max RX BA sessions");
3925 break;
3926 }
3927
3928 if (*ba_bitmap & BIT(tid)) {
3929 ret = -EINVAL;
3930 wl1271_error("cannot enable RX BA session on active "
3931 "tid: %d", tid);
3932 break;
3933 }
3934
3935 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
3936 hlid);
3937 if (!ret) {
3938 *ba_bitmap |= BIT(tid);
3939 wl->ba_rx_session_count++;
bbba3e68
LS		 3940 }
3941 break;
3942
3943 case IEEE80211_AMPDU_RX_STOP:
0f9c8250
AN		 3944 if (!(*ba_bitmap & BIT(tid))) {
3945 ret = -EINVAL;
3946 wl1271_error("no active RX BA session on tid: %d",
3947 tid);
3948 break;
3949 }
3950
3951 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
3952 hlid);
3953 if (!ret) {
3954 *ba_bitmap &= ~BIT(tid);
3955 wl->ba_rx_session_count--;
3956 }
bbba3e68
LS		 3957 break;
3958
3959 /*
3960 * The BA initiator session management in FW independently.
3961 * Falling break here on purpose for all TX APDU commands.
3962 */
3963 case IEEE80211_AMPDU_TX_START:
3964 case IEEE80211_AMPDU_TX_STOP:
3965 case IEEE80211_AMPDU_TX_OPERATIONAL:
3966 ret = -EINVAL;
3967 break;
3968
3969 default:
3970 wl1271_error("Incorrect ampdu action id=%x\n", action);
3971 ret = -EINVAL;
3972 }
3973
3974 wl1271_ps_elp_sleep(wl);
3975
3976out:
3977 mutex_unlock(&wl->mutex);
3978
3979 return ret;
3980}
3981
33437893
AN		 3982static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3983{
3984 struct wl1271 *wl = hw->priv;
3985 bool ret = false;
3986
3987 mutex_lock(&wl->mutex);
3988
3989 if (unlikely(wl->state == WL1271_STATE_OFF))
3990 goto out;
3991
3992 /* packets are considered pending if in the TX queue or the FW */
f1a46384 3993 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 3994
3995 /* the above is appropriate for STA mode for PS purposes */
3996 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3997
3998out:
3999 mutex_unlock(&wl->mutex);
4000
4001 return ret;
4002}
4003
f5fc0f86
LC		 4004/* can't be const, mac80211 writes to this */
4005static struct ieee80211_rate wl1271_rates[] = {
4006 { .bitrate = 10,
2b60100b
JO		 4007 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4008 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 4009 { .bitrate = 20,
2b60100b
JO		 4010 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4011 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 4012 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4013 { .bitrate = 55,
2b60100b
JO		 4014 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4015 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 4016 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4017 { .bitrate = 110,
2b60100b
JO		 4018 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4019 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 4020 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4021 { .bitrate = 60,
2b60100b
JO		 4022 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4023 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 4024 { .bitrate = 90,
2b60100b
JO		 4025 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4026 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 4027 { .bitrate = 120,
2b60100b
JO		 4028 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4029 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 4030 { .bitrate = 180,
2b60100b
JO		 4031 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4032 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 4033 { .bitrate = 240,
2b60100b
JO		 4034 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4035 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 4036 { .bitrate = 360,
2b60100b
JO		 4037 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4038 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 4039 { .bitrate = 480,
2b60100b
JO		 4040 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4041 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 4042 { .bitrate = 540,
2b60100b
JO		 4043 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4044 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 4045};
4046
fa97f46b 4047/* can't be const, mac80211 writes to this */
f5fc0f86 4048static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 4049 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 4050 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 4051 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4052 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4053 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 4054 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 4055 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4056 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4057 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 4058 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 4059 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4060 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4061 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 4062 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 4063};
4064
f876bb9a 4065/* mapping to indexes for wl1271_rates */
a0ea9493 4066static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 4067 /* MCS rates are used only with 11n */
18357850
SL		 4068 7, /* CONF_HW_RXTX_RATE_MCS7 */
4069 6, /* CONF_HW_RXTX_RATE_MCS6 */
4070 5, /* CONF_HW_RXTX_RATE_MCS5 */
4071 4, /* CONF_HW_RXTX_RATE_MCS4 */
4072 3, /* CONF_HW_RXTX_RATE_MCS3 */
4073 2, /* CONF_HW_RXTX_RATE_MCS2 */
4074 1, /* CONF_HW_RXTX_RATE_MCS1 */
4075 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4076
4077 11, /* CONF_HW_RXTX_RATE_54 */
4078 10, /* CONF_HW_RXTX_RATE_48 */
4079 9, /* CONF_HW_RXTX_RATE_36 */
4080 8, /* CONF_HW_RXTX_RATE_24 */
4081
4082 /* TI-specific rate */
4083 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4084
4085 7, /* CONF_HW_RXTX_RATE_18 */
4086 6, /* CONF_HW_RXTX_RATE_12 */
4087 3, /* CONF_HW_RXTX_RATE_11 */
4088 5, /* CONF_HW_RXTX_RATE_9 */
4089 4, /* CONF_HW_RXTX_RATE_6 */
4090 2, /* CONF_HW_RXTX_RATE_5_5 */
4091 1, /* CONF_HW_RXTX_RATE_2 */
4092 0 /* CONF_HW_RXTX_RATE_1 */
4093};
4094
e8b03a2b
SL		 4095/* 11n STA capabilities */
4096#define HW_RX_HIGHEST_RATE 72
4097
00d20100 4098#define WL12XX_HT_CAP { \
871d0c3b
SL		 4099 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4100 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 4101 .ht_supported = true, \
4102 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4103 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4104 .mcs = { \
4105 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4106 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4107 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4108 }, \
4109}
4110
f5fc0f86
LC		 4111/* can't be const, mac80211 writes to this */
4112static struct ieee80211_supported_band wl1271_band_2ghz = {
4113 .channels = wl1271_channels,
4114 .n_channels = ARRAY_SIZE(wl1271_channels),
4115 .bitrates = wl1271_rates,
4116 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 4117 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 4118};
4119
1ebec3d7
TP		 4120/* 5 GHz data rates for WL1273 */
4121static struct ieee80211_rate wl1271_rates_5ghz[] = {
4122 { .bitrate = 60,
4123 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4124 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4125 { .bitrate = 90,
4126 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4127 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4128 { .bitrate = 120,
4129 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4130 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4131 { .bitrate = 180,
4132 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4133 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4134 { .bitrate = 240,
4135 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4136 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4137 { .bitrate = 360,
4138 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4139 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4140 { .bitrate = 480,
4141 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4142 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4143 { .bitrate = 540,
4144 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4145 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4146};
4147
fa97f46b 4148/* 5 GHz band channels for WL1273 */
1ebec3d7 4149static struct ieee80211_channel wl1271_channels_5ghz[] = {
6cfa5cff
AN		 4150 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4151 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4152 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4153 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4154 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4155 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4156 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4157 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4158 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4159 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4160 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4161 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4162 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4163 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4164 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4165 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4166 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4167 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4168 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4169 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4170 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4171 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4172 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4173 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4174 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4175 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4176 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4177 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4178 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4179 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4180 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4181 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4182 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4183 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
1ebec3d7
TP		 4184};
4185
f876bb9a 4186/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 4187static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 4188 /* MCS rates are used only with 11n */
18357850
SL		 4189 7, /* CONF_HW_RXTX_RATE_MCS7 */
4190 6, /* CONF_HW_RXTX_RATE_MCS6 */
4191 5, /* CONF_HW_RXTX_RATE_MCS5 */
4192 4, /* CONF_HW_RXTX_RATE_MCS4 */
4193 3, /* CONF_HW_RXTX_RATE_MCS3 */
4194 2, /* CONF_HW_RXTX_RATE_MCS2 */
4195 1, /* CONF_HW_RXTX_RATE_MCS1 */
4196 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4197
4198 7, /* CONF_HW_RXTX_RATE_54 */
4199 6, /* CONF_HW_RXTX_RATE_48 */
4200 5, /* CONF_HW_RXTX_RATE_36 */
4201 4, /* CONF_HW_RXTX_RATE_24 */
4202
4203 /* TI-specific rate */
4204 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4205
4206 3, /* CONF_HW_RXTX_RATE_18 */
4207 2, /* CONF_HW_RXTX_RATE_12 */
4208 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4209 1, /* CONF_HW_RXTX_RATE_9 */
4210 0, /* CONF_HW_RXTX_RATE_6 */
4211 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4212 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4213 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4214};
1ebec3d7
TP		 4215
4216static struct ieee80211_supported_band wl1271_band_5ghz = {
4217 .channels = wl1271_channels_5ghz,
4218 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4219 .bitrates = wl1271_rates_5ghz,
4220 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 4221 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 4222};
4223
a0ea9493 4224static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 4225 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4226 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4227};
4228
f5fc0f86
LC		 4229static const struct ieee80211_ops wl1271_ops = {
4230 .start = wl1271_op_start,
4231 .stop = wl1271_op_stop,
4232 .add_interface = wl1271_op_add_interface,
4233 .remove_interface = wl1271_op_remove_interface,
f634a4e7 4234#ifdef CONFIG_PM
402e4861
EP		 4235 .suspend = wl1271_op_suspend,
4236 .resume = wl1271_op_resume,
f634a4e7 4237#endif
f5fc0f86 4238 .config = wl1271_op_config,
c87dec9f 4239 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 4240 .configure_filter = wl1271_op_configure_filter,
4241 .tx = wl1271_op_tx,
4242 .set_key = wl1271_op_set_key,
4243 .hw_scan = wl1271_op_hw_scan,
73ecce31 4244 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 4245 .sched_scan_start = wl1271_op_sched_scan_start,
4246 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 4247 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 4248 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 4249 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 4250 .conf_tx = wl1271_op_conf_tx,
bbbb538e 4251 .get_tsf = wl1271_op_get_tsf,
ece550d0 4252 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 4253 .sta_add = wl1271_op_sta_add,
4254 .sta_remove = wl1271_op_sta_remove,
bbba3e68 4255 .ampdu_action = wl1271_op_ampdu_action,
33437893 4256 .tx_frames_pending = wl1271_tx_frames_pending,
c8c90873 4257 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 4258};
4259
f876bb9a 4260
6a2de93b 4261u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 4262{
4263 u8 idx;
4264
6a2de93b 4265 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 4266
4267 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4268 wl1271_error("Illegal RX rate from HW: %d", rate);
4269 return 0;
4270 }
4271
6a2de93b 4272 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 4273 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4274 wl1271_error("Unsupported RX rate from HW: %d", rate);
4275 return 0;
4276 }
4277
4278 return idx;
4279}
4280
7fc3a864
JO		 4281static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4282 struct device_attribute *attr,
4283 char *buf)
4284{
4285 struct wl1271 *wl = dev_get_drvdata(dev);
4286 ssize_t len;
4287
2f63b011 4288 len = PAGE_SIZE;
7fc3a864
JO		 4289
4290 mutex_lock(&wl->mutex);
4291 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4292 wl->sg_enabled);
4293 mutex_unlock(&wl->mutex);
4294
4295 return len;
4296
4297}
4298
4299static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4300 struct device_attribute *attr,
4301 const char *buf, size_t count)
4302{
4303 struct wl1271 *wl = dev_get_drvdata(dev);
4304 unsigned long res;
4305 int ret;
4306
6277ed65 4307 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 4308 if (ret < 0) {
4309 wl1271_warning("incorrect value written to bt_coex_mode");
4310 return count;
4311 }
4312
4313 mutex_lock(&wl->mutex);
4314
4315 res = !!res;
4316
4317 if (res == wl->sg_enabled)
4318 goto out;
4319
4320 wl->sg_enabled = res;
4321
4322 if (wl->state == WL1271_STATE_OFF)
4323 goto out;
4324
a620865e 4325 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 4326 if (ret < 0)
4327 goto out;
4328
4329 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4330 wl1271_ps_elp_sleep(wl);
4331
4332 out:
4333 mutex_unlock(&wl->mutex);
4334 return count;
4335}
4336
4337static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4338 wl1271_sysfs_show_bt_coex_state,
4339 wl1271_sysfs_store_bt_coex_state);
4340
d717fd61
JO		 4341static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4342 struct device_attribute *attr,
4343 char *buf)
4344{
4345 struct wl1271 *wl = dev_get_drvdata(dev);
4346 ssize_t len;
4347
2f63b011 4348 len = PAGE_SIZE;
d717fd61
JO		 4349
4350 mutex_lock(&wl->mutex);
4351 if (wl->hw_pg_ver >= 0)
4352 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4353 else
4354 len = snprintf(buf, len, "n/a\n");
4355 mutex_unlock(&wl->mutex);
4356
4357 return len;
4358}
4359
6f07b72a 4360static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
d717fd61
JO		 4361 wl1271_sysfs_show_hw_pg_ver, NULL);
4362
95dac04f
IY		 4363static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4364 struct bin_attribute *bin_attr,
4365 char *buffer, loff_t pos, size_t count)
4366{
4367 struct device *dev = container_of(kobj, struct device, kobj);
4368 struct wl1271 *wl = dev_get_drvdata(dev);
4369 ssize_t len;
4370 int ret;
4371
4372 ret = mutex_lock_interruptible(&wl->mutex);
4373 if (ret < 0)
4374 return -ERESTARTSYS;
4375
4376 /* Let only one thread read the log at a time, blocking others */
4377 while (wl->fwlog_size == 0) {
4378 DEFINE_WAIT(wait);
4379
4380 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4381 &wait,
4382 TASK_INTERRUPTIBLE);
4383
4384 if (wl->fwlog_size != 0) {
4385 finish_wait(&wl->fwlog_waitq, &wait);
4386 break;
4387 }
4388
4389 mutex_unlock(&wl->mutex);
4390
4391 schedule();
4392 finish_wait(&wl->fwlog_waitq, &wait);
4393
4394 if (signal_pending(current))
4395 return -ERESTARTSYS;
4396
4397 ret = mutex_lock_interruptible(&wl->mutex);
4398 if (ret < 0)
4399 return -ERESTARTSYS;
4400 }
4401
4402 /* Check if the fwlog is still valid */
4403 if (wl->fwlog_size < 0) {
4404 mutex_unlock(&wl->mutex);
4405 return 0;
4406 }
4407
4408 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4409 len = min(count, (size_t)wl->fwlog_size);
4410 wl->fwlog_size -= len;
4411 memcpy(buffer, wl->fwlog, len);
4412
4413 /* Make room for new messages */
4414 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4415
4416 mutex_unlock(&wl->mutex);
4417
4418 return len;
4419}
4420
4421static struct bin_attribute fwlog_attr = {
4422 .attr = {.name = "fwlog", .mode = S_IRUSR},
4423 .read = wl1271_sysfs_read_fwlog,
4424};
4425
2d5e82b8 4426int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 4427{
4428 int ret;
4429
4430 if (wl->mac80211_registered)
4431 return 0;
4432
31d26ec6
AN		 4433 ret = wl1271_fetch_nvs(wl);
4434 if (ret == 0) {
bc765bf3
SL		 4435 /* NOTE: The wl->nvs->nvs element must be first, in
4436 * order to simplify the casting, we assume it is at
4437 * the beginning of the wl->nvs structure.
4438 */
4439 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 4440
4441 wl->mac_addr[0] = nvs_ptr[11];
4442 wl->mac_addr[1] = nvs_ptr[10];
4443 wl->mac_addr[2] = nvs_ptr[6];
4444 wl->mac_addr[3] = nvs_ptr[5];
4445 wl->mac_addr[4] = nvs_ptr[4];
4446 wl->mac_addr[5] = nvs_ptr[3];
4447 }
4448
f5fc0f86
LC		 4449 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4450
4451 ret = ieee80211_register_hw(wl->hw);
4452 if (ret < 0) {
4453 wl1271_error("unable to register mac80211 hw: %d", ret);
4454 return ret;
4455 }
4456
4457 wl->mac80211_registered = true;
4458
d60080ae
EP		 4459 wl1271_debugfs_init(wl);
4460
c2c192ac
JO		 4461 register_netdevice_notifier(&wl1271_dev_notifier);
4462
f5fc0f86
LC		 4463 wl1271_notice("loaded");
4464
4465 return 0;
4466}
50b3eb4b 4467EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 4468
3b56dd6a
TP		 4469void wl1271_unregister_hw(struct wl1271 *wl)
4470{
4ae3fa87
JO		 4471 if (wl->state == WL1271_STATE_PLT)
4472 __wl1271_plt_stop(wl);
4473
c2c192ac 4474 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 4475 ieee80211_unregister_hw(wl->hw);
4476 wl->mac80211_registered = false;
4477
4478}
4479EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4480
2d5e82b8 4481int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 4482{
7a55724e
JO		 4483 static const u32 cipher_suites[] = {
4484 WLAN_CIPHER_SUITE_WEP40,
4485 WLAN_CIPHER_SUITE_WEP104,
4486 WLAN_CIPHER_SUITE_TKIP,
4487 WLAN_CIPHER_SUITE_CCMP,
4488 WL1271_CIPHER_SUITE_GEM,
4489 };
4490
1e2b7976
JO		 4491 /* The tx descriptor buffer and the TKIP space. */
4492 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4493 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 4494
4495 /* unit us */
4496 /* FIXME: find a proper value */
4497 wl->hw->channel_change_time = 10000;
50c500ad 4498 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 4499
4500 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 4501 IEEE80211_HW_BEACON_FILTER |
0a34332f 4502 IEEE80211_HW_SUPPORTS_PS |
4695dc91 4503 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 4504 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 4505 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 4506 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 4507 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 4508 IEEE80211_HW_SPECTRUM_MGMT |
ba7c082a 4509 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 4510
7a55724e
JO		 4511 wl->hw->wiphy->cipher_suites = cipher_suites;
4512 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4513
e0d8bbf0 4514 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 4515 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 4516 wl->hw->wiphy->max_scan_ssids = 1;
221737d2
LC		 4517 wl->hw->wiphy->max_sched_scan_ssids = 16;
4518 wl->hw->wiphy->max_match_sets = 16;
ea559b46
GE		 4519 /*
4520 * Maximum length of elements in scanning probe request templates
4521 * should be the maximum length possible for a template, without
4522 * the IEEE80211 header of the template
4523 */
154037d1 4524 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
ea559b46 4525 sizeof(struct ieee80211_header);
a8aaaf53 4526
1ec23f7f
EP		 4527 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4528
4a31c11c
LC		 4529 /* make sure all our channels fit in the scanned_ch bitmask */
4530 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4531 ARRAY_SIZE(wl1271_channels_5ghz) >
4532 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 4533 /*
4534 * We keep local copies of the band structs because we need to
4535 * modify them on a per-device basis.
4536 */
4537 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4538 sizeof(wl1271_band_2ghz));
4539 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4540 sizeof(wl1271_band_5ghz));
4541
4542 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4543 &wl->bands[IEEE80211_BAND_2GHZ];
4544 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4545 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 4546
12bd8949 4547 wl->hw->queues = 4;
31627dc5 4548 wl->hw->max_rates = 1;
12bd8949 4549
b7417d93
JO		 4550 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4551
8197b711 4552 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 4553
f84f7d78
AN		 4554 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4555
4c9cfa78
LC		 4556 wl->hw->max_rx_aggregation_subframes = 8;
4557
f5fc0f86
LC		 4558 return 0;
4559}
50b3eb4b 4560EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 4561
f5fc0f86 4562#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 4563
2d5e82b8 4564struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 4565{
f5fc0f86 4566 struct ieee80211_hw *hw;
3b56dd6a 4567 struct platform_device *plat_dev = NULL;
f5fc0f86 4568 struct wl1271 *wl;
a8c0ddb5 4569 int i, j, ret;
1f37cbc9 4570 unsigned int order;
f5fc0f86
LC		 4571
4572 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4573 if (!hw) {
4574 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 4575 ret = -ENOMEM;
3b56dd6a
TP		 4576 goto err_hw_alloc;
4577 }
4578
929ebd30 4579 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 4580 if (!plat_dev) {
4581 wl1271_error("could not allocate platform_device");
4582 ret = -ENOMEM;
4583 goto err_plat_alloc;
f5fc0f86
LC		 4584 }
4585
4586 wl = hw->priv;
4587 memset(wl, 0, sizeof(*wl));
4588
01c09162
JO		 4589 INIT_LIST_HEAD(&wl->list);
4590
f5fc0f86 4591 wl->hw = hw;
3b56dd6a 4592 wl->plat_dev = plat_dev;
f5fc0f86 4593
6742f554
JO		 4594 for (i = 0; i < NUM_TX_QUEUES; i++)
4595 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 4596
a8c0ddb5
AN		 4597 for (i = 0; i < NUM_TX_QUEUES; i++)
4598 for (j = 0; j < AP_MAX_LINKS; j++)
4599 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4600
a620865e
IY		 4601 skb_queue_head_init(&wl->deferred_rx_queue);
4602 skb_queue_head_init(&wl->deferred_tx_queue);
4603
37b70a81 4604 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 4605 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
a620865e 4606 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 4607 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4608 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4609 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
77ddaa10
EP		 4610 INIT_WORK(&wl->rx_streaming_enable_work,
4611 wl1271_rx_streaming_enable_work);
4612 INIT_WORK(&wl->rx_streaming_disable_work,
4613 wl1271_rx_streaming_disable_work);
4614
92ef8960
EP		 4615 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4616 if (!wl->freezable_wq) {
4617 ret = -ENOMEM;
4618 goto err_hw;
4619 }
4620
f5fc0f86 4621 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 4622 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 4623 wl->default_key = 0;
f5fc0f86 4624 wl->rx_counter = 0;
19ad0715 4625 wl->psm_entry_retry = 0;
f5fc0f86 4626 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 4627 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 4628 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 4629 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 4630 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 4631 wl->vif = NULL;
830fb67b 4632 wl->flags = 0;
7fc3a864 4633 wl->sg_enabled = true;
d717fd61 4634 wl->hw_pg_ver = -1;
166d504e
AN		 4635 wl->bss_type = MAX_BSS_TYPE;
4636 wl->set_bss_type = MAX_BSS_TYPE;
a8c0ddb5 4637 wl->last_tx_hlid = 0;
b622d992
AN		 4638 wl->ap_ps_map = 0;
4639 wl->ap_fw_ps_map = 0;
606ea9fa 4640 wl->quirks = 0;
341b7cde 4641 wl->platform_quirks = 0;
33c2c06c 4642 wl->sched_scanning = false;
b992c682
OK		 4643 wl->tx_security_seq = 0;
4644 wl->tx_security_last_seq_lsb = 0;
e9eb8cbe 4645 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
7f097988 4646 wl->role_id = WL12XX_INVALID_ROLE_ID;
f4df1bd5 4647 wl->system_hlid = WL12XX_SYSTEM_HLID;
7f097988 4648 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
04e8079c
EP		 4649 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4650 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
712e9bf7 4651 wl->session_counter = 0;
e51ae9be
AN		 4652 wl->ap_bcast_hlid = WL12XX_INVALID_LINK_ID;
4653 wl->ap_global_hlid = WL12XX_INVALID_LINK_ID;
da03209e 4654 wl->active_sta_count = 0;
77ddaa10
EP		 4655 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4656 (unsigned long) wl);
95dac04f
IY		 4657 wl->fwlog_size = 0;
4658 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 4659
f4df1bd5
EP		 4660 /* The system link is always allocated */
4661 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4662
25eeb9e3 4663 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 4664 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 4665 wl->tx_frames[i] = NULL;
4666
4667 spin_lock_init(&wl->wl_lock);
4668
f5fc0f86
LC		 4669 wl->state = WL1271_STATE_OFF;
4670 mutex_init(&wl->mutex);
4671
c332a4b8
TP		 4672 /* Apply default driver configuration. */
4673 wl1271_conf_init(wl);
4674
1f37cbc9
IY		 4675 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4676 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4677 if (!wl->aggr_buf) {
4678 ret = -ENOMEM;
92ef8960 4679 goto err_wq;
1f37cbc9
IY		 4680 }
4681
990f5de7
IY		 4682 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4683 if (!wl->dummy_packet) {
4684 ret = -ENOMEM;
4685 goto err_aggr;
4686 }
4687
95dac04f
IY		 4688 /* Allocate one page for the FW log */
4689 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4690 if (!wl->fwlog) {
4691 ret = -ENOMEM;
4692 goto err_dummy_packet;
4693 }
4694
a1dd8187 4695 /* Register platform device */
3b56dd6a 4696 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 4697 if (ret) {
4698 wl1271_error("couldn't register platform device");
95dac04f 4699 goto err_fwlog;
a1dd8187 4700 }
3b56dd6a 4701 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 4702
7fc3a864 4703 /* Create sysfs file to control bt coex state */
3b56dd6a 4704 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 4705 if (ret < 0) {
4706 wl1271_error("failed to create sysfs file bt_coex_state");
4707 goto err_platform;
4708 }
a1dd8187 4709
d717fd61
JO		 4710 /* Create sysfs file to get HW PG version */
4711 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4712 if (ret < 0) {
4713 wl1271_error("failed to create sysfs file hw_pg_ver");
4714 goto err_bt_coex_state;
4715 }
4716
95dac04f
IY		 4717 /* Create sysfs file for the FW log */
4718 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4719 if (ret < 0) {
4720 wl1271_error("failed to create sysfs file fwlog");
4721 goto err_hw_pg_ver;
4722 }
4723
c332a4b8 4724 return hw;
a1dd8187 4725
95dac04f
IY		 4726err_hw_pg_ver:
4727 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4728
d717fd61
JO		 4729err_bt_coex_state:
4730 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4731
7fc3a864 4732err_platform:
3b56dd6a 4733 platform_device_unregister(wl->plat_dev);
7fc3a864 4734
95dac04f
IY		 4735err_fwlog:
4736 free_page((unsigned long)wl->fwlog);
4737
990f5de7
IY		 4738err_dummy_packet:
4739 dev_kfree_skb(wl->dummy_packet);
4740
1f37cbc9
IY		 4741err_aggr:
4742 free_pages((unsigned long)wl->aggr_buf, order);
4743
92ef8960
EP		 4744err_wq:
4745 destroy_workqueue(wl->freezable_wq);
4746
a1dd8187 4747err_hw:
3b56dd6a
TP		 4748 wl1271_debugfs_exit(wl);
4749 kfree(plat_dev);
4750
4751err_plat_alloc:
4752 ieee80211_free_hw(hw);
4753
4754err_hw_alloc:
a1dd8187 4755
a1dd8187 4756 return ERR_PTR(ret);
c332a4b8 4757}
50b3eb4b 4758EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 4759
4760int wl1271_free_hw(struct wl1271 *wl)
4761{
95dac04f
IY		 4762 /* Unblock any fwlog readers */
4763 mutex_lock(&wl->mutex);
4764 wl->fwlog_size = -1;
4765 wake_up_interruptible_all(&wl->fwlog_waitq);
4766 mutex_unlock(&wl->mutex);
4767
4768 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
6f07b72a
GK		 4769
4770 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4771
4772 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3b56dd6a 4773 platform_device_unregister(wl->plat_dev);
95dac04f 4774 free_page((unsigned long)wl->fwlog);
990f5de7 4775 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 4776 free_pages((unsigned long)wl->aggr_buf,
4777 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 4778 kfree(wl->plat_dev);
c332a4b8
TP		 4779
4780 wl1271_debugfs_exit(wl);
4781
c332a4b8
TP		 4782 vfree(wl->fw);
4783 wl->fw = NULL;
4784 kfree(wl->nvs);
4785 wl->nvs = NULL;
4786
4787 kfree(wl->fw_status);
4788 kfree(wl->tx_res_if);
92ef8960 4789 destroy_workqueue(wl->freezable_wq);
c332a4b8
TP		 4790
4791 ieee80211_free_hw(wl->hw);
4792
4793 return 0;
4794}
50b3eb4b
TP		 4795EXPORT_SYMBOL_GPL(wl1271_free_hw);
4796
491bbd6b 4797u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 4798EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 4799module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 4800MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4801
95dac04f
IY		 4802module_param_named(fwlog, fwlog_param, charp, 0);
4803MODULE_PARM_DESC(keymap,
4804 "FW logger options: continuous, ondemand, dbgpins or disable");
4805
2a5bff09
EP		 4806module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
4807MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
4808
50b3eb4b 4809MODULE_LICENSE("GPL");
b1a48cab 4810MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 4811MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)