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