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