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