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