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