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