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