projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx_sdio: set MMC_PM_KEEP_POWER flag on suspend
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / wl12xx / main.c
CommitLineData
f5fc0f86
LC		 1/*
2 * This file is part of wl1271
3 *
8bf29b0e 4 * Copyright (C) 2008-2010 Nokia Corporation
f5fc0f86
LC		 5 *
6 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 *
22 */
23
24#include <linux/module.h>
f5fc0f86
LC		 25#include <linux/firmware.h>
26#include <linux/delay.h>
f5fc0f86
LC		 27#include <linux/spi/spi.h>
28#include <linux/crc32.h>
29#include <linux/etherdevice.h>
1fba4974 30#include <linux/vmalloc.h>
a1dd8187 31#include <linux/platform_device.h>
5a0e3ad6 32#include <linux/slab.h>
341b7cde 33#include <linux/wl12xx.h>
f5fc0f86 34
00d20100 35#include "wl12xx.h"
f5fc0f86 36#include "wl12xx_80211.h"
00d20100
SL		 37#include "reg.h"
38#include "io.h"
39#include "event.h"
40#include "tx.h"
41#include "rx.h"
42#include "ps.h"
43#include "init.h"
44#include "debugfs.h"
45#include "cmd.h"
46#include "boot.h"
47#include "testmode.h"
48#include "scan.h"
f5fc0f86 49
9ccd9217
JO		 50#define WL1271_BOOT_RETRIES 3
51
8a08048a
JO		 52static struct conf_drv_settings default_conf = {
53 .sg = {
801f870b 54 .sta_params = {
1b00f546
JO		 55 [CONF_SG_BT_PER_THRESHOLD] = 7500,
56 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
57 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
d9482e2b 58 [CONF_SG_BT_LOAD_RATIO] = 200,
8d2ef7bd 59 [CONF_SG_AUTO_PS_MODE] = 1,
1b00f546
JO		 60 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
61 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
62 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
63 [CONF_SG_BEACON_MISS_PERCENT] = 60,
64 [CONF_SG_RATE_ADAPT_THRESH] = 12,
65 [CONF_SG_RATE_ADAPT_SNR] = 0,
66 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
67 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30,
68 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8,
69 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
70 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50,
71 /* Note: with UPSD, this should be 4 */
72 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8,
73 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
74 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
75 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20,
76 /* Note: with UPDS, this should be 15 */
77 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
78 /* Note: with UPDS, this should be 50 */
79 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40,
80 /* Note: with UPDS, this should be 10 */
81 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 20,
82 [CONF_SG_RXT] = 1200,
83 [CONF_SG_TXT] = 1000,
84 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
85 [CONF_SG_PS_POLL_TIMEOUT] = 10,
86 [CONF_SG_UPSD_TIMEOUT] = 10,
87 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
88 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
89 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
90 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
91 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
92 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
93 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
94 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
95 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
96 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
97 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
98 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
99 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
100 [CONF_SG_HV3_MAX_SERVED] = 6,
101 [CONF_SG_DHCP_TIME] = 5000,
102 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
103 },
801f870b
AN		 104 .ap_params = {
105 [CONF_SG_BT_PER_THRESHOLD] = 7500,
106 [CONF_SG_HV3_MAX_OVERRIDE] = 0,
107 [CONF_SG_BT_NFS_SAMPLE_INTERVAL] = 400,
108 [CONF_SG_BT_LOAD_RATIO] = 50,
109 [CONF_SG_AUTO_PS_MODE] = 1,
110 [CONF_SG_AUTO_SCAN_PROBE_REQ] = 170,
111 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50,
112 [CONF_SG_ANTENNA_CONFIGURATION] = 0,
113 [CONF_SG_BEACON_MISS_PERCENT] = 60,
114 [CONF_SG_RATE_ADAPT_THRESH] = 64,
115 [CONF_SG_RATE_ADAPT_SNR] = 1,
116 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10,
117 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 25,
118 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 25,
119 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20,
120 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 25,
121 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 25,
122 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7,
123 [CONF_SG_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25,
124 [CONF_SG_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 25,
125 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8,
126 [CONF_SG_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 25,
127 [CONF_SG_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 25,
128 [CONF_SG_RXT] = 1200,
129 [CONF_SG_TXT] = 1000,
130 [CONF_SG_ADAPTIVE_RXT_TXT] = 1,
131 [CONF_SG_PS_POLL_TIMEOUT] = 10,
132 [CONF_SG_UPSD_TIMEOUT] = 10,
133 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7,
134 [CONF_SG_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15,
135 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15,
136 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8,
137 [CONF_SG_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20,
138 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15,
139 [CONF_SG_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20,
140 [CONF_SG_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50,
141 [CONF_SG_WLAN_ACTIVE_MAX_BT_ACL_BR] = 10,
142 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200,
143 [CONF_SG_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800,
144 [CONF_SG_PASSIVE_SCAN_A2DP_BT_TIME] = 75,
145 [CONF_SG_PASSIVE_SCAN_A2DP_WLAN_TIME] = 15,
146 [CONF_SG_HV3_MAX_SERVED] = 6,
147 [CONF_SG_DHCP_TIME] = 5000,
148 [CONF_SG_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100,
149 [CONF_SG_TEMP_PARAM_1] = 0,
150 [CONF_SG_TEMP_PARAM_2] = 0,
151 [CONF_SG_TEMP_PARAM_3] = 0,
152 [CONF_SG_TEMP_PARAM_4] = 0,
153 [CONF_SG_TEMP_PARAM_5] = 0,
154 [CONF_SG_AP_BEACON_MISS_TX] = 3,
155 [CONF_SG_RX_WINDOW_LENGTH] = 6,
156 [CONF_SG_AP_CONNECTION_PROTECTION_TIME] = 50,
157 [CONF_SG_TEMP_PARAM_6] = 1,
158 },
1b00f546 159 .state = CONF_SG_PROTECTIVE,
8a08048a
JO		 160 },
161 .rx = {
162 .rx_msdu_life_time = 512000,
163 .packet_detection_threshold = 0,
164 .ps_poll_timeout = 15,
165 .upsd_timeout = 15,
5f704d18 166 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
3ed8f2c6
LC		 167 .rx_cca_threshold = 0,
168 .irq_blk_threshold = 0xFFFF,
169 .irq_pkt_threshold = 0,
170 .irq_timeout = 600,
8a08048a
JO		 171 .queue_type = CONF_RX_QUEUE_TYPE_LOW_PRIORITY,
172 },
173 .tx = {
174 .tx_energy_detection = 0,
1e05a818 175 .sta_rc_conf = {
ebba60c6 176 .enabled_rates = 0,
8a08048a
JO		 177 .short_retry_limit = 10,
178 .long_retry_limit = 10,
1e05a818 179 .aflags = 0,
45b531a8 180 },
8a08048a
JO		 181 .ac_conf_count = 4,
182 .ac_conf = {
9987a9da 183 [CONF_TX_AC_BE] = {
8a08048a
JO		 184 .ac = CONF_TX_AC_BE,
185 .cw_min = 15,
186 .cw_max = 63,
187 .aifsn = 3,
188 .tx_op_limit = 0,
45b531a8 189 },
9987a9da 190 [CONF_TX_AC_BK] = {
8a08048a
JO		 191 .ac = CONF_TX_AC_BK,
192 .cw_min = 15,
193 .cw_max = 63,
194 .aifsn = 7,
195 .tx_op_limit = 0,
45b531a8 196 },
9987a9da 197 [CONF_TX_AC_VI] = {
8a08048a
JO		 198 .ac = CONF_TX_AC_VI,
199 .cw_min = 15,
200 .cw_max = 63,
201 .aifsn = CONF_TX_AIFS_PIFS,
202 .tx_op_limit = 3008,
203 },
9987a9da 204 [CONF_TX_AC_VO] = {
8a08048a
JO		 205 .ac = CONF_TX_AC_VO,
206 .cw_min = 15,
207 .cw_max = 63,
208 .aifsn = CONF_TX_AIFS_PIFS,
209 .tx_op_limit = 1504,
45b531a8 210 },
51f2be24 211 },
25eaea30 212 .ap_max_tx_retries = 100,
9987a9da 213 .tid_conf_count = 4,
8a08048a 214 .tid_conf = {
9987a9da
JO		 215 [CONF_TX_AC_BE] = {
216 .queue_id = CONF_TX_AC_BE,
217 .channel_type = CONF_CHANNEL_TYPE_EDCF,
8a08048a
JO		 218 .tsid = CONF_TX_AC_BE,
219 .ps_scheme = CONF_PS_SCHEME_LEGACY,
220 .ack_policy = CONF_ACK_POLICY_LEGACY,
221 .apsd_conf = {0, 0},
51f2be24 222 },
9987a9da
JO		 223 [CONF_TX_AC_BK] = {
224 .queue_id = CONF_TX_AC_BK,
225 .channel_type = CONF_CHANNEL_TYPE_EDCF,
226 .tsid = CONF_TX_AC_BK,
8a08048a
JO		 227 .ps_scheme = CONF_PS_SCHEME_LEGACY,
228 .ack_policy = CONF_ACK_POLICY_LEGACY,
229 .apsd_conf = {0, 0},
230 },
9987a9da
JO		 231 [CONF_TX_AC_VI] = {
232 .queue_id = CONF_TX_AC_VI,
233 .channel_type = CONF_CHANNEL_TYPE_EDCF,
234 .tsid = CONF_TX_AC_VI,
8a08048a
JO		 235 .ps_scheme = CONF_PS_SCHEME_LEGACY,
236 .ack_policy = CONF_ACK_POLICY_LEGACY,
237 .apsd_conf = {0, 0},
238 },
9987a9da
JO		 239 [CONF_TX_AC_VO] = {
240 .queue_id = CONF_TX_AC_VO,
241 .channel_type = CONF_CHANNEL_TYPE_EDCF,
242 .tsid = CONF_TX_AC_VO,
8a08048a
JO		 243 .ps_scheme = CONF_PS_SCHEME_LEGACY,
244 .ack_policy = CONF_ACK_POLICY_LEGACY,
245 .apsd_conf = {0, 0},
246 },
8a08048a
JO		 247 },
248 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
3ed8f2c6 249 .tx_compl_timeout = 700,
ebba60c6
JO		 250 .tx_compl_threshold = 4,
251 .basic_rate = CONF_HW_BIT_RATE_1MBPS,
252 .basic_rate_5 = CONF_HW_BIT_RATE_6MBPS,
1e05a818
AN		 253 .tmpl_short_retry_limit = 10,
254 .tmpl_long_retry_limit = 10,
8a08048a
JO		 255 },
256 .conn = {
257 .wake_up_event = CONF_WAKE_UP_EVENT_DTIM,
50c500ad 258 .listen_interval = 1,
8a08048a 259 .bcn_filt_mode = CONF_BCN_FILT_MODE_ENABLED,
bc76b940 260 .bcn_filt_ie_count = 2,
8a08048a
JO		 261 .bcn_filt_ie = {
262 [0] = {
263 .ie = WLAN_EID_CHANNEL_SWITCH,
264 .rule = CONF_BCN_RULE_PASS_ON_APPEARANCE,
bc76b940
SL		 265 },
266 [1] = {
267 .ie = WLAN_EID_HT_INFORMATION,
268 .rule = CONF_BCN_RULE_PASS_ON_CHANGE,
269 },
47fab7d5 270 },
3ed8f2c6 271 .synch_fail_thold = 10,
8a08048a
JO		 272 .bss_lose_timeout = 100,
273 .beacon_rx_timeout = 10000,
274 .broadcast_timeout = 20000,
275 .rx_broadcast_in_ps = 1,
90494a90
JO		 276 .ps_poll_threshold = 10,
277 .ps_poll_recovery_period = 700,
11f70f97 278 .bet_enable = CONF_BET_MODE_ENABLE,
958b20e0 279 .bet_max_consecutive = 50,
8eab7b47 280 .psm_entry_retries = 5,
2370841b 281 .psm_exit_retries = 16,
8eab7b47
JO		 282 .psm_entry_nullfunc_retries = 3,
283 .psm_entry_hangover_period = 1,
50c500ad
JO		 284 .keep_alive_interval = 55000,
285 .max_listen_interval = 20,
8a08048a 286 },
6e92b416
LC		 287 .itrim = {
288 .enable = false,
289 .timeout = 50000,
38ad2d87
JO		 290 },
291 .pm_config = {
292 .host_clk_settling_time = 5000,
293 .host_fast_wakeup_support = false
00236aed
JO		 294 },
295 .roam_trigger = {
00236aed
JO		 296 .trigger_pacing = 1,
297 .avg_weight_rssi_beacon = 20,
298 .avg_weight_rssi_data = 10,
299 .avg_weight_snr_beacon = 20,
4b7fac77 300 .avg_weight_snr_data = 10,
bea39d6a
JO		 301 },
302 .scan = {
303 .min_dwell_time_active = 7500,
304 .max_dwell_time_active = 30000,
ea45b2cb
JO		 305 .min_dwell_time_passive = 100000,
306 .max_dwell_time_passive = 100000,
bea39d6a
JO		 307 .num_probe_reqs = 2,
308 },
3a9d60e5
LC		 309 .sched_scan = {
310 /* sched_scan requires dwell times in TU instead of TU/1000 */
311 .min_dwell_time_active = 8,
312 .max_dwell_time_active = 30,
313 .dwell_time_passive = 100,
314 .num_probe_reqs = 2,
315 .rssi_threshold = -90,
316 .snr_threshold = 0,
317 },
644a4860
JO		 318 .rf = {
319 .tx_per_channel_power_compensation_2 = {
320 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
321 },
322 .tx_per_channel_power_compensation_5 = {
323 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
324 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
325 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
326 },
327 },
4b7fac77
LS		 328 .ht = {
329 .tx_ba_win_size = 64,
330 .inactivity_timeout = 10000,
331 },
13b107dd 332 .mem_wl127x = {
fe5ef090
EP		 333 .num_stations = 1,
334 .ssid_profiles = 1,
335 .rx_block_num = 70,
336 .tx_min_block_num = 40,
4cf557fc 337 .dynamic_memory = 1,
b16d4b68 338 .min_req_tx_blocks = 100,
c8bde243
EP		 339 .min_req_rx_blocks = 22,
340 .tx_min = 27,
13b107dd
SL		 341 },
342 .mem_wl128x = {
343 .num_stations = 1,
344 .ssid_profiles = 1,
345 .rx_block_num = 40,
346 .tx_min_block_num = 40,
347 .dynamic_memory = 1,
348 .min_req_tx_blocks = 45,
349 .min_req_rx_blocks = 22,
350 .tx_min = 27,
351 },
ff86843d
SL		 352 .fm_coex = {
353 .enable = true,
354 .swallow_period = 5,
355 .n_divider_fref_set_1 = 0xff, /* default */
356 .n_divider_fref_set_2 = 12,
357 .m_divider_fref_set_1 = 148,
358 .m_divider_fref_set_2 = 0xffff, /* default */
359 .coex_pll_stabilization_time = 0xffffffff, /* default */
360 .ldo_stabilization_time = 0xffff, /* default */
361 .fm_disturbed_band_margin = 0xff, /* default */
362 .swallow_clk_diff = 0xff, /* default */
363 },
afb7d3cd 364 .hci_io_ds = HCI_IO_DS_6MA,
8a08048a
JO		 365};
366
7dece1c8
AN		 367static void __wl1271_op_remove_interface(struct wl1271 *wl,
368 bool reset_tx_queues);
7f179b46 369static void wl1271_free_ap_keys(struct wl1271 *wl);
52b0e7a6
JO		 370
371
a1dd8187
JO		 372static void wl1271_device_release(struct device *dev)
373{
374
375}
376
377static struct platform_device wl1271_device = {
378 .name = "wl1271",
379 .id = -1,
380
381 /* device model insists to have a release function */
382 .dev = {
383 .release = wl1271_device_release,
384 },
385};
386
f9f774c1 387static DEFINE_MUTEX(wl_list_mutex);
01c09162
JO		 388static LIST_HEAD(wl_list);
389
c2c192ac
JO		 390static int wl1271_dev_notify(struct notifier_block *me, unsigned long what,
391 void *arg)
392{
393 struct net_device *dev = arg;
394 struct wireless_dev *wdev;
395 struct wiphy *wiphy;
396 struct ieee80211_hw *hw;
397 struct wl1271 *wl;
398 struct wl1271 *wl_temp;
399 int ret = 0;
400
401 /* Check that this notification is for us. */
402 if (what != NETDEV_CHANGE)
403 return NOTIFY_DONE;
404
405 wdev = dev->ieee80211_ptr;
406 if (wdev == NULL)
407 return NOTIFY_DONE;
408
409 wiphy = wdev->wiphy;
410 if (wiphy == NULL)
411 return NOTIFY_DONE;
412
413 hw = wiphy_priv(wiphy);
414 if (hw == NULL)
415 return NOTIFY_DONE;
416
417 wl_temp = hw->priv;
f9f774c1 418 mutex_lock(&wl_list_mutex);
c2c192ac
JO		 419 list_for_each_entry(wl, &wl_list, list) {
420 if (wl == wl_temp)
421 break;
422 }
f9f774c1 423 mutex_unlock(&wl_list_mutex);
c2c192ac
JO		 424 if (wl != wl_temp)
425 return NOTIFY_DONE;
426
427 mutex_lock(&wl->mutex);
428
429 if (wl->state == WL1271_STATE_OFF)
430 goto out;
431
432 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
433 goto out;
434
a620865e 435 ret = wl1271_ps_elp_wakeup(wl);
c2c192ac
JO		 436 if (ret < 0)
437 goto out;
438
439 if ((dev->operstate == IF_OPER_UP) &&
440 !test_and_set_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags)) {
441 wl1271_cmd_set_sta_state(wl);
442 wl1271_info("Association completed.");
443 }
444
445 wl1271_ps_elp_sleep(wl);
446
447out:
448 mutex_unlock(&wl->mutex);
449
450 return NOTIFY_OK;
451}
452
b7417d93 453static int wl1271_reg_notify(struct wiphy *wiphy,
573c67cf
LC		 454 struct regulatory_request *request)
455{
b7417d93
JO		 456 struct ieee80211_supported_band *band;
457 struct ieee80211_channel *ch;
458 int i;
459
460 band = wiphy->bands[IEEE80211_BAND_5GHZ];
461 for (i = 0; i < band->n_channels; i++) {
462 ch = &band->channels[i];
463 if (ch->flags & IEEE80211_CHAN_DISABLED)
464 continue;
465
466 if (ch->flags & IEEE80211_CHAN_RADAR)
467 ch->flags |= IEEE80211_CHAN_NO_IBSS |
468 IEEE80211_CHAN_PASSIVE_SCAN;
469
470 }
471
472 return 0;
473}
474
8a08048a
JO		 475static void wl1271_conf_init(struct wl1271 *wl)
476{
2b60100b
JO		 477
478 /*
479 * This function applies the default configuration to the driver. This
480 * function is invoked upon driver load (spi probe.)
481 *
482 * The configuration is stored in a run-time structure in order to
483 * facilitate for run-time adjustment of any of the parameters. Making
484 * changes to the configuration structure will apply the new values on
485 * the next interface up (wl1271_op_start.)
486 */
487
488 /* apply driver default configuration */
8a08048a 489 memcpy(&wl->conf, &default_conf, sizeof(default_conf));
2b60100b
JO		 490}
491
492
f5fc0f86
LC		 493static int wl1271_plt_init(struct wl1271 *wl)
494{
12419cce
LC		 495 struct conf_tx_ac_category *conf_ac;
496 struct conf_tx_tid *conf_tid;
497 int ret, i;
f5fc0f86 498
49d750ca
SL		 499 if (wl->chip.id == CHIP_ID_1283_PG20)
500 ret = wl128x_cmd_general_parms(wl);
501 else
502 ret = wl1271_cmd_general_parms(wl);
4a90406b 503 if (ret < 0)
cc7defa3
LC		 504 return ret;
505
49d750ca
SL		 506 if (wl->chip.id == CHIP_ID_1283_PG20)
507 ret = wl128x_cmd_radio_parms(wl);
508 else
509 ret = wl1271_cmd_radio_parms(wl);
4a90406b 510 if (ret < 0)
cc7defa3
LC		 511 return ret;
512
49d750ca
SL		 513 if (wl->chip.id != CHIP_ID_1283_PG20) {
514 ret = wl1271_cmd_ext_radio_parms(wl);
515 if (ret < 0)
516 return ret;
517 }
644a4860
JO		 518 if (ret < 0)
519 return ret;
520
48a61477
SL		 521 /* Chip-specific initializations */
522 ret = wl1271_chip_specific_init(wl);
523 if (ret < 0)
524 return ret;
525
e0fe371b 526 ret = wl1271_sta_init_templates_config(wl);
12419cce
LC		 527 if (ret < 0)
528 return ret;
529
f5fc0f86
LC		 530 ret = wl1271_acx_init_mem_config(wl);
531 if (ret < 0)
532 return ret;
533
12419cce
LC		 534 /* PHY layer config */
535 ret = wl1271_init_phy_config(wl);
536 if (ret < 0)
537 goto out_free_memmap;
538
539 ret = wl1271_acx_dco_itrim_params(wl);
540 if (ret < 0)
541 goto out_free_memmap;
542
543 /* Initialize connection monitoring thresholds */
6ccbb92e 544 ret = wl1271_acx_conn_monit_params(wl, false);
12419cce
LC		 545 if (ret < 0)
546 goto out_free_memmap;
547
548 /* Bluetooth WLAN coexistence */
549 ret = wl1271_init_pta(wl);
550 if (ret < 0)
551 goto out_free_memmap;
552
ff86843d
SL		 553 /* FM WLAN coexistence */
554 ret = wl1271_acx_fm_coex(wl);
555 if (ret < 0)
556 goto out_free_memmap;
557
12419cce
LC		 558 /* Energy detection */
559 ret = wl1271_init_energy_detection(wl);
560 if (ret < 0)
561 goto out_free_memmap;
562
1ec610eb
GK		 563 ret = wl1271_acx_sta_mem_cfg(wl);
564 if (ret < 0)
565 goto out_free_memmap;
566
12419cce 567 /* Default fragmentation threshold */
68d069c4 568 ret = wl1271_acx_frag_threshold(wl, wl->conf.tx.frag_threshold);
12419cce
LC		 569 if (ret < 0)
570 goto out_free_memmap;
571
9987a9da
JO		 572 /* Default TID/AC configuration */
573 BUG_ON(wl->conf.tx.tid_conf_count != wl->conf.tx.ac_conf_count);
12419cce 574 for (i = 0; i < wl->conf.tx.tid_conf_count; i++) {
9987a9da
JO		 575 conf_ac = &wl->conf.tx.ac_conf[i];
576 ret = wl1271_acx_ac_cfg(wl, conf_ac->ac, conf_ac->cw_min,
577 conf_ac->cw_max, conf_ac->aifsn,
578 conf_ac->tx_op_limit);
579 if (ret < 0)
580 goto out_free_memmap;
581
12419cce
LC		 582 conf_tid = &wl->conf.tx.tid_conf[i];
583 ret = wl1271_acx_tid_cfg(wl, conf_tid->queue_id,
584 conf_tid->channel_type,
585 conf_tid->tsid,
586 conf_tid->ps_scheme,
587 conf_tid->ack_policy,
588 conf_tid->apsd_conf[0],
589 conf_tid->apsd_conf[1]);
590 if (ret < 0)
591 goto out_free_memmap;
592 }
593
12419cce 594 /* Enable data path */
94210897 595 ret = wl1271_cmd_data_path(wl, 1);
f5fc0f86 596 if (ret < 0)
12419cce
LC		 597 goto out_free_memmap;
598
599 /* Configure for CAM power saving (ie. always active) */
600 ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
601 if (ret < 0)
602 goto out_free_memmap;
603
604 /* configure PM */
605 ret = wl1271_acx_pm_config(wl);
606 if (ret < 0)
607 goto out_free_memmap;
f5fc0f86
LC		 608
609 return 0;
12419cce
LC		 610
611 out_free_memmap:
612 kfree(wl->target_mem_map);
613 wl->target_mem_map = NULL;
614
615 return ret;
f5fc0f86
LC		 616}
617
b622d992
AN		 618static void wl1271_irq_ps_regulate_link(struct wl1271 *wl, u8 hlid, u8 tx_blks)
619{
620 bool fw_ps;
621
622 /* only regulate station links */
623 if (hlid < WL1271_AP_STA_HLID_START)
624 return;
625
626 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
627
628 /*
629 * Wake up from high level PS if the STA is asleep with too little
630 * blocks in FW or if the STA is awake.
631 */
632 if (!fw_ps || tx_blks < WL1271_PS_STA_MAX_BLOCKS)
633 wl1271_ps_link_end(wl, hlid);
634
635 /* Start high-level PS if the STA is asleep with enough blocks in FW */
636 else if (fw_ps && tx_blks >= WL1271_PS_STA_MAX_BLOCKS)
637 wl1271_ps_link_start(wl, hlid, true);
638}
639
640static void wl1271_irq_update_links_status(struct wl1271 *wl,
641 struct wl1271_fw_ap_status *status)
642{
643 u32 cur_fw_ps_map;
644 u8 hlid;
645
646 cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
647 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
648 wl1271_debug(DEBUG_PSM,
649 "link ps prev 0x%x cur 0x%x changed 0x%x",
650 wl->ap_fw_ps_map, cur_fw_ps_map,
651 wl->ap_fw_ps_map ^ cur_fw_ps_map);
652
653 wl->ap_fw_ps_map = cur_fw_ps_map;
654 }
655
656 for (hlid = WL1271_AP_STA_HLID_START; hlid < AP_MAX_LINKS; hlid++) {
657 u8 cnt = status->tx_lnk_free_blks[hlid] -
658 wl->links[hlid].prev_freed_blks;
659
660 wl->links[hlid].prev_freed_blks =
661 status->tx_lnk_free_blks[hlid];
662 wl->links[hlid].allocated_blks -= cnt;
663
664 wl1271_irq_ps_regulate_link(wl, hlid,
665 wl->links[hlid].allocated_blks);
666 }
667}
668
c15f63bf 669static void wl1271_fw_status(struct wl1271 *wl,
c8bde243 670 struct wl1271_fw_full_status *full_status)
f5fc0f86 671{
c8bde243 672 struct wl1271_fw_common_status *status = &full_status->common;
ac5e1e39 673 struct timespec ts;
13b107dd 674 u32 old_tx_blk_count = wl->tx_blocks_available;
d2f4d47d 675 u32 freed_blocks = 0;
f5fc0f86
LC		 676 int i;
677
13b107dd 678 if (wl->bss_type == BSS_TYPE_AP_BSS) {
c8bde243
EP		 679 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
680 sizeof(struct wl1271_fw_ap_status), false);
13b107dd 681 } else {
c8bde243
EP		 682 wl1271_raw_read(wl, FW_STATUS_ADDR, status,
683 sizeof(struct wl1271_fw_sta_status), false);
13b107dd
SL		 684 }
685
f5fc0f86
LC		 686 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
687 "drv_rx_counter = %d, tx_results_counter = %d)",
688 status->intr,
689 status->fw_rx_counter,
690 status->drv_rx_counter,
691 status->tx_results_counter);
692
693 /* update number of available TX blocks */
694 for (i = 0; i < NUM_TX_QUEUES; i++) {
d2f4d47d
IY		 695 freed_blocks += le32_to_cpu(status->tx_released_blks[i]) -
696 wl->tx_blocks_freed[i];
d0f63b20
LC		 697
698 wl->tx_blocks_freed[i] =
699 le32_to_cpu(status->tx_released_blks[i]);
13b107dd
SL		 700 }
701
d2f4d47d
IY		 702 wl->tx_allocated_blocks -= freed_blocks;
703
704 if (wl->bss_type == BSS_TYPE_AP_BSS) {
705 /* Update num of allocated TX blocks per link and ps status */
706 wl1271_irq_update_links_status(wl, &full_status->ap);
707 wl->tx_blocks_available += freed_blocks;
708 } else {
709 int avail = full_status->sta.tx_total - wl->tx_allocated_blocks;
13b107dd 710
d2f4d47d
IY		 711 /*
712 * The FW might change the total number of TX memblocks before
713 * we get a notification about blocks being released. Thus, the
714 * available blocks calculation might yield a temporary result
715 * which is lower than the actual available blocks. Keeping in
716 * mind that only blocks that were allocated can be moved from
717 * TX to RX, tx_blocks_available should never decrease here.
718 */
719 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
720 avail);
f5fc0f86
LC		 721 }
722
a522550a 723 /* if more blocks are available now, tx work can be scheduled */
13b107dd 724 if (wl->tx_blocks_available > old_tx_blk_count)
a522550a 725 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
f5fc0f86
LC		 726
727 /* update the host-chipset time offset */
ac5e1e39
JO		 728 getnstimeofday(&ts);
729 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
730 (s64)le32_to_cpu(status->fw_localtime);
f5fc0f86
LC		 731}
732
a620865e
IY		 733static void wl1271_flush_deferred_work(struct wl1271 *wl)
734{
735 struct sk_buff *skb;
736
737 /* Pass all received frames to the network stack */
738 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
739 ieee80211_rx_ni(wl->hw, skb);
740
741 /* Return sent skbs to the network stack */
742 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
743 ieee80211_tx_status(wl->hw, skb);
744}
745
746static void wl1271_netstack_work(struct work_struct *work)
747{
748 struct wl1271 *wl =
749 container_of(work, struct wl1271, netstack_work);
750
751 do {
752 wl1271_flush_deferred_work(wl);
753 } while (skb_queue_len(&wl->deferred_rx_queue));
754}
1e73eb62 755
a620865e
IY		 756#define WL1271_IRQ_MAX_LOOPS 256
757
758irqreturn_t wl1271_irq(int irq, void *cookie)
f5fc0f86 759{
f5fc0f86 760 int ret;
c15f63bf 761 u32 intr;
1e73eb62 762 int loopcount = WL1271_IRQ_MAX_LOOPS;
a620865e
IY		 763 struct wl1271 *wl = (struct wl1271 *)cookie;
764 bool done = false;
765 unsigned int defer_count;
b07d4037
IY		 766 unsigned long flags;
767
768 /* TX might be handled here, avoid redundant work */
769 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
770 cancel_work_sync(&wl->tx_work);
f5fc0f86 771
341b7cde
IY		 772 /*
773 * In case edge triggered interrupt must be used, we cannot iterate
774 * more than once without introducing race conditions with the hardirq.
775 */
776 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
777 loopcount = 1;
778
f5fc0f86
LC		 779 mutex_lock(&wl->mutex);
780
781 wl1271_debug(DEBUG_IRQ, "IRQ work");
782
1e73eb62 783 if (unlikely(wl->state == WL1271_STATE_OFF))
f5fc0f86
LC		 784 goto out;
785
a620865e 786 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 787 if (ret < 0)
788 goto out;
789
a620865e
IY		 790 while (!done && loopcount--) {
791 /*
792 * In order to avoid a race with the hardirq, clear the flag
793 * before acknowledging the chip. Since the mutex is held,
794 * wl1271_ps_elp_wakeup cannot be called concurrently.
795 */
796 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
797 smp_mb__after_clear_bit();
1e73eb62
JO		 798
799 wl1271_fw_status(wl, wl->fw_status);
c8bde243 800 intr = le32_to_cpu(wl->fw_status->common.intr);
a620865e 801 intr &= WL1271_INTR_MASK;
1e73eb62 802 if (!intr) {
a620865e 803 done = true;
1e73eb62
JO		 804 continue;
805 }
f5fc0f86 806
ccc83b04
EP		 807 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
808 wl1271_error("watchdog interrupt received! "
809 "starting recovery.");
810 ieee80211_queue_work(wl->hw, &wl->recovery_work);
811
812 /* restarting the chip. ignore any other interrupt. */
813 goto out;
814 }
815
a620865e 816 if (likely(intr & WL1271_ACX_INTR_DATA)) {
1e73eb62 817 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
1fd2794f 818
8aad2464 819 wl1271_rx(wl, &wl->fw_status->common);
f5fc0f86 820
a522550a 821 /* Check if any tx blocks were freed */
b07d4037 822 spin_lock_irqsave(&wl->wl_lock, flags);
a522550a 823 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
6742f554 824 wl->tx_queue_count) {
b07d4037 825 spin_unlock_irqrestore(&wl->wl_lock, flags);
a522550a
IY		 826 /*
827 * In order to avoid starvation of the TX path,
828 * call the work function directly.
829 */
830 wl1271_tx_work_locked(wl);
b07d4037
IY		 831 } else {
832 spin_unlock_irqrestore(&wl->wl_lock, flags);
a522550a
IY		 833 }
834
8aad2464
IY		 835 /* check for tx results */
836 if (wl->fw_status->common.tx_results_counter !=
837 (wl->tx_results_count & 0xff))
838 wl1271_tx_complete(wl);
a620865e
IY		 839
840 /* Make sure the deferred queues don't get too long */
841 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
842 skb_queue_len(&wl->deferred_rx_queue);
843 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
844 wl1271_flush_deferred_work(wl);
1e73eb62 845 }
f5fc0f86 846
1e73eb62
JO		 847 if (intr & WL1271_ACX_INTR_EVENT_A) {
848 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
849 wl1271_event_handle(wl, 0);
850 }
f5fc0f86 851
1e73eb62
JO		 852 if (intr & WL1271_ACX_INTR_EVENT_B) {
853 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
854 wl1271_event_handle(wl, 1);
855 }
f5fc0f86 856
1e73eb62
JO		 857 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
858 wl1271_debug(DEBUG_IRQ,
859 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 860
1e73eb62
JO		 861 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
862 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
c15f63bf 863 }
f5fc0f86 864
f5fc0f86
LC		 865 wl1271_ps_elp_sleep(wl);
866
867out:
b07d4037
IY		 868 spin_lock_irqsave(&wl->wl_lock, flags);
869 /* In case TX was not handled here, queue TX work */
870 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
871 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
872 wl->tx_queue_count)
873 ieee80211_queue_work(wl->hw, &wl->tx_work);
874 spin_unlock_irqrestore(&wl->wl_lock, flags);
875
f5fc0f86 876 mutex_unlock(&wl->mutex);
a620865e
IY		 877
878 return IRQ_HANDLED;
f5fc0f86 879}
a620865e 880EXPORT_SYMBOL_GPL(wl1271_irq);
f5fc0f86 881
f5fc0f86
LC		 882static int wl1271_fetch_firmware(struct wl1271 *wl)
883{
884 const struct firmware *fw;
166d504e 885 const char *fw_name;
f5fc0f86
LC		 886 int ret;
887
166d504e
AN		 888 switch (wl->bss_type) {
889 case BSS_TYPE_AP_BSS:
1aed55fd
AN		 890 if (wl->chip.id == CHIP_ID_1283_PG20)
891 fw_name = WL128X_AP_FW_NAME;
892 else
893 fw_name = WL127X_AP_FW_NAME;
166d504e
AN		 894 break;
895 case BSS_TYPE_IBSS:
896 case BSS_TYPE_STA_BSS:
bc765bf3
SL		 897 if (wl->chip.id == CHIP_ID_1283_PG20)
898 fw_name = WL128X_FW_NAME;
899 else
900 fw_name = WL1271_FW_NAME;
166d504e
AN		 901 break;
902 default:
903 wl1271_error("no compatible firmware for bss_type %d",
904 wl->bss_type);
905 return -EINVAL;
906 }
907
908 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
909
910 ret = request_firmware(&fw, fw_name, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 911
912 if (ret < 0) {
913 wl1271_error("could not get firmware: %d", ret);
914 return ret;
915 }
916
917 if (fw->size % 4) {
918 wl1271_error("firmware size is not multiple of 32 bits: %zu",
919 fw->size);
920 ret = -EILSEQ;
921 goto out;
922 }
923
166d504e 924 vfree(wl->fw);
f5fc0f86 925 wl->fw_len = fw->size;
1fba4974 926 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 927
928 if (!wl->fw) {
929 wl1271_error("could not allocate memory for the firmware");
930 ret = -ENOMEM;
931 goto out;
932 }
933
934 memcpy(wl->fw, fw->data, wl->fw_len);
166d504e 935 wl->fw_bss_type = wl->bss_type;
f5fc0f86
LC		 936 ret = 0;
937
938out:
939 release_firmware(fw);
940
941 return ret;
942}
943
944static int wl1271_fetch_nvs(struct wl1271 *wl)
945{
946 const struct firmware *fw;
947 int ret;
948
5aa42346 949 ret = request_firmware(&fw, WL12XX_NVS_NAME, wl1271_wl_to_dev(wl));
f5fc0f86
LC		 950
951 if (ret < 0) {
952 wl1271_error("could not get nvs file: %d", ret);
953 return ret;
954 }
955
bc765bf3 956 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
f5fc0f86
LC		 957
958 if (!wl->nvs) {
959 wl1271_error("could not allocate memory for the nvs file");
960 ret = -ENOMEM;
961 goto out;
962 }
963
02fabb0e
JO		 964 wl->nvs_len = fw->size;
965
f5fc0f86
LC		 966out:
967 release_firmware(fw);
968
969 return ret;
970}
971
52b0e7a6
JO		 972static void wl1271_recovery_work(struct work_struct *work)
973{
974 struct wl1271 *wl =
975 container_of(work, struct wl1271, recovery_work);
976
977 mutex_lock(&wl->mutex);
978
979 if (wl->state != WL1271_STATE_ON)
980 goto out;
981
52dcaf57
AN		 982 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
983 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
52b0e7a6 984
d25611da
JO		 985 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
986 ieee80211_connection_loss(wl->vif);
987
7dece1c8
AN		 988 /* Prevent spurious TX during FW restart */
989 ieee80211_stop_queues(wl->hw);
990
33c2c06c
LC		 991 if (wl->sched_scanning) {
992 ieee80211_sched_scan_stopped(wl->hw);
993 wl->sched_scanning = false;
994 }
995
52b0e7a6 996 /* reboot the chipset */
7dece1c8 997 __wl1271_op_remove_interface(wl, false);
52b0e7a6
JO		 998 ieee80211_restart_hw(wl->hw);
999
7dece1c8
AN		 1000 /*
1001 * Its safe to enable TX now - the queues are stopped after a request
1002 * to restart the HW.
1003 */
1004 ieee80211_wake_queues(wl->hw);
1005
52b0e7a6
JO		 1006out:
1007 mutex_unlock(&wl->mutex);
1008}
1009
f5fc0f86
LC		 1010static void wl1271_fw_wakeup(struct wl1271 *wl)
1011{
1012 u32 elp_reg;
1013
1014 elp_reg = ELPCTRL_WAKE_UP;
74621417 1015 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 1016}
1017
1018static int wl1271_setup(struct wl1271 *wl)
1019{
1020 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1021 if (!wl->fw_status)
1022 return -ENOMEM;
1023
1024 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1025 if (!wl->tx_res_if) {
1026 kfree(wl->fw_status);
1027 return -ENOMEM;
1028 }
1029
f5fc0f86
LC		 1030 return 0;
1031}
1032
1033static int wl1271_chip_wakeup(struct wl1271 *wl)
1034{
451de97a 1035 struct wl1271_partition_set partition;
f5fc0f86
LC		 1036 int ret = 0;
1037
01ac17ec 1038 msleep(WL1271_PRE_POWER_ON_SLEEP);
2cc78ff7
OBC		 1039 ret = wl1271_power_on(wl);
1040 if (ret < 0)
1041 goto out;
f5fc0f86 1042 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 1043 wl1271_io_reset(wl);
1044 wl1271_io_init(wl);
f5fc0f86
LC		 1045
1046 /* We don't need a real memory partition here, because we only want
1047 * to use the registers at this point. */
451de97a
JO		 1048 memset(&partition, 0, sizeof(partition));
1049 partition.reg.start = REGISTERS_BASE;
1050 partition.reg.size = REGISTERS_DOWN_SIZE;
1051 wl1271_set_partition(wl, &partition);
f5fc0f86
LC		 1052
1053 /* ELP module wake up */
1054 wl1271_fw_wakeup(wl);
1055
1056 /* whal_FwCtrl_BootSm() */
1057
1058 /* 0. read chip id from CHIP_ID */
7b048c52 1059 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 1060
1061 /* 1. check if chip id is valid */
1062
1063 switch (wl->chip.id) {
1064 case CHIP_ID_1271_PG10:
1065 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1066 wl->chip.id);
1067
1068 ret = wl1271_setup(wl);
1069 if (ret < 0)
9ccd9217 1070 goto out;
f5fc0f86
LC		 1071 break;
1072 case CHIP_ID_1271_PG20:
1073 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
1074 wl->chip.id);
1075
564f5950
SL		 1076 /* end-of-transaction flag should be set in wl127x AP mode */
1077 if (wl->bss_type == BSS_TYPE_AP_BSS)
1078 wl->quirks |= WL12XX_QUIRK_END_OF_TRANSACTION;
1079
f5fc0f86
LC		 1080 ret = wl1271_setup(wl);
1081 if (ret < 0)
9ccd9217 1082 goto out;
f5fc0f86 1083 break;
0830ceed
SL		 1084 case CHIP_ID_1283_PG20:
1085 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1086 wl->chip.id);
1087
1088 ret = wl1271_setup(wl);
1089 if (ret < 0)
1090 goto out;
0da13da7
IY		 1091 if (wl1271_set_block_size(wl))
1092 wl->quirks |= WL12XX_QUIRK_BLOCKSIZE_ALIGNMENT;
0830ceed
SL		 1093 break;
1094 case CHIP_ID_1283_PG10:
f5fc0f86 1095 default:
9ccd9217 1096 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 1097 ret = -ENODEV;
9ccd9217 1098 goto out;
f5fc0f86
LC		 1099 }
1100
166d504e
AN		 1101 /* Make sure the firmware type matches the BSS type */
1102 if (wl->fw == NULL || wl->fw_bss_type != wl->bss_type) {
f5fc0f86
LC		 1103 ret = wl1271_fetch_firmware(wl);
1104 if (ret < 0)
9ccd9217 1105 goto out;
f5fc0f86
LC		 1106 }
1107
1108 /* No NVS from netlink, try to get it from the filesystem */
1109 if (wl->nvs == NULL) {
1110 ret = wl1271_fetch_nvs(wl);
1111 if (ret < 0)
9ccd9217 1112 goto out;
f5fc0f86
LC		 1113 }
1114
1115out:
1116 return ret;
1117}
1118
e7ddf549
LC		 1119static unsigned int wl1271_get_fw_ver_quirks(struct wl1271 *wl)
1120{
1121 unsigned int quirks = 0;
1122 unsigned int *fw_ver = wl->chip.fw_ver;
1123
1124 /* Only for wl127x */
1125 if ((fw_ver[FW_VER_CHIP] == FW_VER_CHIP_WL127X) &&
1126 /* Check STA version */
1127 (((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_STA) &&
1128 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_STA_MIN)) ||
1129 /* Check AP version */
1130 ((fw_ver[FW_VER_IF_TYPE] == FW_VER_IF_TYPE_AP) &&
1131 (fw_ver[FW_VER_MINOR] < FW_VER_MINOR_1_SPARE_AP_MIN))))
1132 quirks |= WL12XX_QUIRK_USE_2_SPARE_BLOCKS;
1133
1134 return quirks;
1135}
1136
f5fc0f86
LC		 1137int wl1271_plt_start(struct wl1271 *wl)
1138{
9ccd9217 1139 int retries = WL1271_BOOT_RETRIES;
f5fc0f86
LC		 1140 int ret;
1141
1142 mutex_lock(&wl->mutex);
1143
1144 wl1271_notice("power up");
1145
1146 if (wl->state != WL1271_STATE_OFF) {
1147 wl1271_error("cannot go into PLT state because not "
1148 "in off state: %d", wl->state);
1149 ret = -EBUSY;
1150 goto out;
1151 }
1152
166d504e
AN		 1153 wl->bss_type = BSS_TYPE_STA_BSS;
1154
9ccd9217
JO		 1155 while (retries) {
1156 retries--;
1157 ret = wl1271_chip_wakeup(wl);
1158 if (ret < 0)
1159 goto power_off;
f5fc0f86 1160
9ccd9217
JO		 1161 ret = wl1271_boot(wl);
1162 if (ret < 0)
1163 goto power_off;
eb5b28d0 1164
9ccd9217
JO		 1165 ret = wl1271_plt_init(wl);
1166 if (ret < 0)
1167 goto irq_disable;
bd5ea18f 1168
9ccd9217
JO		 1169 wl->state = WL1271_STATE_PLT;
1170 wl1271_notice("firmware booted in PLT mode (%s)",
4b7fac77 1171 wl->chip.fw_ver_str);
e7ddf549
LC		 1172
1173 /* Check if any quirks are needed with older fw versions */
1174 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
9ccd9217 1175 goto out;
eb5b28d0 1176
9ccd9217 1177irq_disable:
9ccd9217
JO		 1178 mutex_unlock(&wl->mutex);
1179 /* Unlocking the mutex in the middle of handling is
1180 inherently unsafe. In this case we deem it safe to do,
1181 because we need to let any possibly pending IRQ out of
1182 the system (and while we are WL1271_STATE_OFF the IRQ
1183 work function will not do anything.) Also, any other
1184 possible concurrent operations will fail due to the
1185 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 1186 wl1271_disable_interrupts(wl);
1187 wl1271_flush_deferred_work(wl);
1188 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 1189 mutex_lock(&wl->mutex);
1190power_off:
1191 wl1271_power_off(wl);
1192 }
f5fc0f86 1193
9ccd9217
JO		 1194 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1195 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 1196out:
1197 mutex_unlock(&wl->mutex);
1198
1199 return ret;
1200}
1201
4623ec7d 1202static int __wl1271_plt_stop(struct wl1271 *wl)
f5fc0f86
LC		 1203{
1204 int ret = 0;
1205
f5fc0f86
LC		 1206 wl1271_notice("power down");
1207
1208 if (wl->state != WL1271_STATE_PLT) {
1209 wl1271_error("cannot power down because not in PLT "
1210 "state: %d", wl->state);
1211 ret = -EBUSY;
1212 goto out;
1213 }
1214
f5fc0f86
LC		 1215 wl1271_power_off(wl);
1216
1217 wl->state = WL1271_STATE_OFF;
bd5ea18f 1218 wl->rx_counter = 0;
f5fc0f86 1219
f5fc0f86 1220 mutex_unlock(&wl->mutex);
a620865e
IY		 1221 wl1271_disable_interrupts(wl);
1222 wl1271_flush_deferred_work(wl);
1223 cancel_work_sync(&wl->netstack_work);
52b0e7a6 1224 cancel_work_sync(&wl->recovery_work);
4ae3fa87
JO		 1225 mutex_lock(&wl->mutex);
1226out:
1227 return ret;
1228}
1229
1230int wl1271_plt_stop(struct wl1271 *wl)
1231{
1232 int ret;
8c7f4f31 1233
4ae3fa87
JO		 1234 mutex_lock(&wl->mutex);
1235 ret = __wl1271_plt_stop(wl);
1236 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1237 return ret;
1238}
1239
7bb45683 1240static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
f5fc0f86
LC		 1241{
1242 struct wl1271 *wl = hw->priv;
830fb67b 1243 unsigned long flags;
6742f554 1244 int q;
a8c0ddb5 1245 u8 hlid = 0;
f5fc0f86 1246
b07d4037
IY		 1247 q = wl1271_tx_get_queue(skb_get_queue_mapping(skb));
1248
1249 if (wl->bss_type == BSS_TYPE_AP_BSS)
1250 hlid = wl1271_tx_get_hlid(skb);
1251
830fb67b 1252 spin_lock_irqsave(&wl->wl_lock, flags);
b07d4037 1253
6742f554 1254 wl->tx_queue_count++;
f4d08ddd
AN		 1255
1256 /*
1257 * The workqueue is slow to process the tx_queue and we need stop
1258 * the queue here, otherwise the queue will get too long.
1259 */
1260 if (wl->tx_queue_count >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1261 wl1271_debug(DEBUG_TX, "op_tx: stopping queues");
1262 ieee80211_stop_queues(wl->hw);
1263 set_bit(WL1271_FLAG_TX_QUEUE_STOPPED, &wl->flags);
1264 }
1265
830fb67b 1266 /* queue the packet */
a8c0ddb5 1267 if (wl->bss_type == BSS_TYPE_AP_BSS) {
a8c0ddb5
AN		 1268 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1269 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1270 } else {
1271 skb_queue_tail(&wl->tx_queue[q], skb);
1272 }
f5fc0f86
LC		 1273
1274 /*
1275 * The chip specific setup must run before the first TX packet -
1276 * before that, the tx_work will not be initialized!
1277 */
1278
b07d4037
IY		 1279 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1280 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
a522550a 1281 ieee80211_queue_work(wl->hw, &wl->tx_work);
b07d4037
IY		 1282
1283 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 1284}
1285
ae47c45f
SL		 1286int wl1271_tx_dummy_packet(struct wl1271 *wl)
1287{
990f5de7
IY		 1288 unsigned long flags;
1289
1290 spin_lock_irqsave(&wl->wl_lock, flags);
1291 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1292 wl->tx_queue_count++;
1293 spin_unlock_irqrestore(&wl->wl_lock, flags);
1294
1295 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1296 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1297 wl1271_tx_work_locked(wl);
1298
1299 /*
1300 * If the FW TX is busy, TX work will be scheduled by the threaded
1301 * interrupt handler function
1302 */
1303 return 0;
1304}
1305
1306/*
1307 * The size of the dummy packet should be at least 1400 bytes. However, in
1308 * order to minimize the number of bus transactions, aligning it to 512 bytes
1309 * boundaries could be beneficial, performance wise
1310 */
1311#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1312
cf27d867 1313static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
990f5de7
IY		 1314{
1315 struct sk_buff *skb;
ae47c45f 1316 struct ieee80211_hdr_3addr *hdr;
990f5de7
IY		 1317 unsigned int dummy_packet_size;
1318
1319 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1320 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
ae47c45f 1321
990f5de7 1322 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
ae47c45f 1323 if (!skb) {
990f5de7
IY		 1324 wl1271_warning("Failed to allocate a dummy packet skb");
1325 return NULL;
ae47c45f
SL		 1326 }
1327
1328 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1329
1330 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1331 memset(hdr, 0, sizeof(*hdr));
1332 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
990f5de7
IY		 1333 IEEE80211_STYPE_NULLFUNC |
1334 IEEE80211_FCTL_TODS);
ae47c45f 1335
990f5de7 1336 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
ae47c45f 1337
18b92ffa
LC		 1338 /* Dummy packets require the TID to be management */
1339 skb->priority = WL1271_TID_MGMT;
ae47c45f 1340
990f5de7 1341 /* Initialize all fields that might be used */
86c438f4 1342 skb_set_queue_mapping(skb, 0);
990f5de7 1343 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
ae47c45f 1344
990f5de7 1345 return skb;
ae47c45f
SL		 1346}
1347
990f5de7 1348
c2c192ac
JO		 1349static struct notifier_block wl1271_dev_notifier = {
1350 .notifier_call = wl1271_dev_notify,
1351};
1352
402e4861
EP		 1353static int wl1271_op_suspend(struct ieee80211_hw *hw,
1354 struct cfg80211_wowlan *wow)
1355{
1356 struct wl1271 *wl = hw->priv;
1357 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1358 wl->wow_enabled = !!wow;
1359 return 0;
1360}
1361
1362static int wl1271_op_resume(struct ieee80211_hw *hw)
1363{
1364 struct wl1271 *wl = hw->priv;
1365 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1366 wl->wow_enabled);
1367 return 0;
1368}
1369
f5fc0f86 1370static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1371{
1372 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1373
1374 /*
1375 * We have to delay the booting of the hardware because
1376 * we need to know the local MAC address before downloading and
1377 * initializing the firmware. The MAC address cannot be changed
1378 * after boot, and without the proper MAC address, the firmware
1379 * will not function properly.
1380 *
1381 * The MAC address is first known when the corresponding interface
1382 * is added. That is where we will initialize the hardware.
166d504e
AN		 1383 *
1384 * In addition, we currently have different firmwares for AP and managed
1385 * operation. We will know which to boot according to interface type.
1b72aecd
JO		 1386 */
1387
1388 return 0;
1389}
1390
1391static void wl1271_op_stop(struct ieee80211_hw *hw)
1392{
1393 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1394}
1395
1396static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1397 struct ieee80211_vif *vif)
f5fc0f86
LC		 1398{
1399 struct wl1271 *wl = hw->priv;
ac01e948 1400 struct wiphy *wiphy = hw->wiphy;
9ccd9217 1401 int retries = WL1271_BOOT_RETRIES;
f5fc0f86 1402 int ret = 0;
71125abd 1403 bool booted = false;
f5fc0f86 1404
1b72aecd
JO		 1405 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1406 vif->type, vif->addr);
f5fc0f86
LC		 1407
1408 mutex_lock(&wl->mutex);
1b72aecd 1409 if (wl->vif) {
71125abd
EP		 1410 wl1271_debug(DEBUG_MAC80211,
1411 "multiple vifs are not supported yet");
1b72aecd
JO		 1412 ret = -EBUSY;
1413 goto out;
1414 }
1415
13026dec
JO		 1416 /*
1417 * in some very corner case HW recovery scenarios its possible to
1418 * get here before __wl1271_op_remove_interface is complete, so
1419 * opt out if that is the case.
1420 */
1421 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1422 ret = -EBUSY;
1423 goto out;
1424 }
1425
1b72aecd
JO		 1426 switch (vif->type) {
1427 case NL80211_IFTYPE_STATION:
1428 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 1429 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 1430 break;
1431 case NL80211_IFTYPE_ADHOC:
1432 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 1433 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd 1434 break;
038d925b
AN		 1435 case NL80211_IFTYPE_AP:
1436 wl->bss_type = BSS_TYPE_AP_BSS;
1437 break;
1b72aecd
JO		 1438 default:
1439 ret = -EOPNOTSUPP;
1440 goto out;
1441 }
1442
1443 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 1444
1445 if (wl->state != WL1271_STATE_OFF) {
1446 wl1271_error("cannot start because not in off state: %d",
1447 wl->state);
1448 ret = -EBUSY;
1449 goto out;
1450 }
1451
9ccd9217
JO		 1452 while (retries) {
1453 retries--;
1454 ret = wl1271_chip_wakeup(wl);
1455 if (ret < 0)
1456 goto power_off;
f5fc0f86 1457
9ccd9217
JO		 1458 ret = wl1271_boot(wl);
1459 if (ret < 0)
1460 goto power_off;
f5fc0f86 1461
9ccd9217
JO		 1462 ret = wl1271_hw_init(wl);
1463 if (ret < 0)
1464 goto irq_disable;
f5fc0f86 1465
71125abd
EP		 1466 booted = true;
1467 break;
eb5b28d0 1468
9ccd9217 1469irq_disable:
9ccd9217
JO		 1470 mutex_unlock(&wl->mutex);
1471 /* Unlocking the mutex in the middle of handling is
1472 inherently unsafe. In this case we deem it safe to do,
1473 because we need to let any possibly pending IRQ out of
1474 the system (and while we are WL1271_STATE_OFF the IRQ
1475 work function will not do anything.) Also, any other
1476 possible concurrent operations will fail due to the
1477 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 1478 wl1271_disable_interrupts(wl);
1479 wl1271_flush_deferred_work(wl);
1480 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 1481 mutex_lock(&wl->mutex);
1482power_off:
1483 wl1271_power_off(wl);
1484 }
eb5b28d0 1485
71125abd
EP		 1486 if (!booted) {
1487 wl1271_error("firmware boot failed despite %d retries",
1488 WL1271_BOOT_RETRIES);
1489 goto out;
1490 }
1491
1492 wl->vif = vif;
1493 wl->state = WL1271_STATE_ON;
13026dec 1494 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
4b7fac77 1495 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 1496
1497 /* update hw/fw version info in wiphy struct */
1498 wiphy->hw_version = wl->chip.id;
4b7fac77 1499 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 1500 sizeof(wiphy->fw_version));
1501
e7ddf549
LC		 1502 /* Check if any quirks are needed with older fw versions */
1503 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1504
fb6a6819
LC		 1505 /*
1506 * Now we know if 11a is supported (info from the NVS), so disable
1507 * 11a channels if not supported
1508 */
1509 if (!wl->enable_11a)
1510 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1511
1512 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1513 wl->enable_11a ? "" : "not ");
1514
eb5b28d0 1515out:
f5fc0f86
LC		 1516 mutex_unlock(&wl->mutex);
1517
f9f774c1 1518 mutex_lock(&wl_list_mutex);
eb887dfd 1519 if (!ret)
01c09162 1520 list_add(&wl->list, &wl_list);
f9f774c1 1521 mutex_unlock(&wl_list_mutex);
01c09162 1522
f5fc0f86
LC		 1523 return ret;
1524}
1525
7dece1c8
AN		 1526static void __wl1271_op_remove_interface(struct wl1271 *wl,
1527 bool reset_tx_queues)
f5fc0f86 1528{
f5fc0f86
LC		 1529 int i;
1530
1b72aecd 1531 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 1532
13026dec
JO		 1533 /* because of hardware recovery, we may get here twice */
1534 if (wl->state != WL1271_STATE_ON)
1535 return;
1536
1b72aecd 1537 wl1271_info("down");
f5fc0f86 1538
f9f774c1 1539 mutex_lock(&wl_list_mutex);
01c09162 1540 list_del(&wl->list);
f9f774c1 1541 mutex_unlock(&wl_list_mutex);
01c09162 1542
8d2ef7bd 1543 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 1544 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 1545 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1546
08688d6b 1547 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b 1548 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 1549 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
b739a42c 1550 wl->scan.req = NULL;
76a029fb 1551 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 1552 }
1553
13026dec
JO		 1554 /*
1555 * this must be before the cancel_work calls below, so that the work
1556 * functions don't perform further work.
1557 */
f5fc0f86
LC		 1558 wl->state = WL1271_STATE_OFF;
1559
f5fc0f86
LC		 1560 mutex_unlock(&wl->mutex);
1561
a620865e
IY		 1562 wl1271_disable_interrupts(wl);
1563 wl1271_flush_deferred_work(wl);
78abd320 1564 cancel_delayed_work_sync(&wl->scan_complete_work);
a620865e 1565 cancel_work_sync(&wl->netstack_work);
f5fc0f86 1566 cancel_work_sync(&wl->tx_work);
90494a90 1567 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1568 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1569
1570 mutex_lock(&wl->mutex);
1571
1572 /* let's notify MAC80211 about the remaining pending TX frames */
7dece1c8 1573 wl1271_tx_reset(wl, reset_tx_queues);
f5fc0f86
LC		 1574 wl1271_power_off(wl);
1575
1576 memset(wl->bssid, 0, ETH_ALEN);
1577 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1578 wl->ssid_len = 0;
f5fc0f86 1579 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 1580 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 1581 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1582
1583 wl->rx_counter = 0;
19ad0715 1584 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1585 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1586 wl->tx_blocks_available = 0;
d2f4d47d 1587 wl->tx_allocated_blocks = 0;
f5fc0f86
LC		 1588 wl->tx_results_count = 0;
1589 wl->tx_packets_count = 0;
ac4e4ce5 1590 wl->tx_security_last_seq = 0;
04e36fc5 1591 wl->tx_security_seq = 0;
f5fc0f86
LC		 1592 wl->time_offset = 0;
1593 wl->session_counter = 0;
830fb67b 1594 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1b72aecd 1595 wl->vif = NULL;
14b228a0 1596 wl->filters = 0;
7f179b46 1597 wl1271_free_ap_keys(wl);
f84f7d78 1598 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
b622d992
AN		 1599 wl->ap_fw_ps_map = 0;
1600 wl->ap_ps_map = 0;
33c2c06c 1601 wl->sched_scanning = false;
d6e19d13 1602
13026dec
JO		 1603 /*
1604 * this is performed after the cancel_work calls and the associated
1605 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1606 * get executed before all these vars have been reset.
1607 */
1608 wl->flags = 0;
1609
f5fc0f86
LC		 1610 for (i = 0; i < NUM_TX_QUEUES; i++)
1611 wl->tx_blocks_freed[i] = 0;
1612
1613 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1614
1615 kfree(wl->fw_status);
1616 wl->fw_status = NULL;
1617 kfree(wl->tx_res_if);
1618 wl->tx_res_if = NULL;
1619 kfree(wl->target_mem_map);
1620 wl->target_mem_map = NULL;
52a2a375 1621}
bd9dc49c 1622
52a2a375
JO		 1623static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1624 struct ieee80211_vif *vif)
1625{
1626 struct wl1271 *wl = hw->priv;
1627
1628 mutex_lock(&wl->mutex);
67353299
JO		 1629 /*
1630 * wl->vif can be null here if someone shuts down the interface
1631 * just when hardware recovery has been started.
1632 */
1633 if (wl->vif) {
1634 WARN_ON(wl->vif != vif);
7dece1c8 1635 __wl1271_op_remove_interface(wl, true);
67353299 1636 }
52b0e7a6 1637
67353299 1638 mutex_unlock(&wl->mutex);
52b0e7a6 1639 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1640}
1641
c5745187 1642void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
14b228a0 1643{
ae113b57 1644 wl1271_set_default_filters(wl);
14b228a0
JO		 1645
1646 /* combine requested filters with current filter config */
1647 filters = wl->filters | filters;
1648
1649 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1650
1651 if (filters & FIF_PROMISC_IN_BSS) {
1652 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1653 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1654 wl->rx_config |= CFG_BSSID_FILTER_EN;
1655 }
1656 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1657 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1658 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1659 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1660 }
1661 if (filters & FIF_OTHER_BSS) {
1662 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1663 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1664 }
1665 if (filters & FIF_CONTROL) {
1666 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1667 wl->rx_filter |= CFG_RX_CTL_EN;
1668 }
1669 if (filters & FIF_FCSFAIL) {
1670 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1671 wl->rx_filter |= CFG_RX_FCS_ERROR;
1672 }
1673}
1674
82429d32 1675static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1676{
e0d8bbf0 1677 int ret = 0;
c7f43e45
LC		 1678 /* we need to use a dummy BSSID for now */
1679 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1680 0xad, 0xbe, 0xef };
1681
c7f43e45
LC		 1682 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1683
14b228a0
JO		 1684 /* pass through frames from all BSS */
1685 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1686
5da11dcd 1687 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1688 if (ret < 0)
1689 goto out;
1690
71449f8d 1691 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1692
1693out:
1694 return ret;
1695}
1696
69e5434c 1697static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1698{
1699 int ret;
1700
69e5434c
JO		 1701 /*
1702 * One of the side effects of the JOIN command is that is clears
1703 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1704 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 1705 * Currently the only valid scenario for JOIN during association
1706 * is on roaming, in which case we will also be given new keys.
1707 * Keep the below message for now, unless it starts bothering
1708 * users who really like to roam a lot :)
69e5434c
JO		 1709 */
1710 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1711 wl1271_info("JOIN while associated.");
1712
1713 if (set_assoc)
1714 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1715
82429d32
JO		 1716 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1717 if (ret < 0)
1718 goto out;
1719
1720 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1721
1722 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1723 goto out;
1724
1725 /*
1726 * The join command disable the keep-alive mode, shut down its process,
1727 * and also clear the template config, so we need to reset it all after
1728 * the join. The acx_aid starts the keep-alive process, and the order
1729 * of the commands below is relevant.
1730 */
1731 ret = wl1271_acx_keep_alive_mode(wl, true);
1732 if (ret < 0)
1733 goto out;
1734
1735 ret = wl1271_acx_aid(wl, wl->aid);
1736 if (ret < 0)
1737 goto out;
1738
1739 ret = wl1271_cmd_build_klv_null_data(wl);
1740 if (ret < 0)
1741 goto out;
1742
1743 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1744 ACX_KEEP_ALIVE_TPL_VALID);
1745 if (ret < 0)
1746 goto out;
1747
1748out:
1749 return ret;
1750}
1751
1752static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1753{
1754 int ret;
1755
1756 /* to stop listening to a channel, we disconnect */
1757 ret = wl1271_cmd_disconnect(wl);
1758 if (ret < 0)
1759 goto out;
1760
71449f8d 1761 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1762 memset(wl->bssid, 0, ETH_ALEN);
14b228a0 1763
c5745187 1764 /* stop filtering packets based on bssid */
14b228a0 1765 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1766
1767out:
1768 return ret;
1769}
1770
ebba60c6
JO		 1771static void wl1271_set_band_rate(struct wl1271 *wl)
1772{
1773 if (wl->band == IEEE80211_BAND_2GHZ)
1774 wl->basic_rate_set = wl->conf.tx.basic_rate;
1775 else
1776 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1777}
1778
bee0ffec 1779static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 1780{
1781 int ret;
1782
1783 if (idle) {
1784 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1785 ret = wl1271_unjoin(wl);
1786 if (ret < 0)
1787 goto out;
1788 }
e0fe371b 1789 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 1790 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 1791 if (ret < 0)
1792 goto out;
1793 ret = wl1271_acx_keep_alive_config(
1794 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1795 ACX_KEEP_ALIVE_TPL_INVALID);
1796 if (ret < 0)
1797 goto out;
1798 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1799 } else {
1800 /* increment the session counter */
1801 wl->session_counter++;
1802 if (wl->session_counter >= SESSION_COUNTER_MAX)
1803 wl->session_counter = 0;
33c2c06c
LC		 1804
1805 /* The current firmware only supports sched_scan in idle */
1806 if (wl->sched_scanning) {
1807 wl1271_scan_sched_scan_stop(wl);
1808 ieee80211_sched_scan_stopped(wl->hw);
1809 }
1810
0d58cbff
JO		 1811 ret = wl1271_dummy_join(wl);
1812 if (ret < 0)
1813 goto out;
1814 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1815 }
1816
1817out:
1818 return ret;
1819}
1820
f5fc0f86
LC		 1821static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1822{
1823 struct wl1271 *wl = hw->priv;
1824 struct ieee80211_conf *conf = &hw->conf;
1825 int channel, ret = 0;
bee0ffec 1826 bool is_ap;
f5fc0f86
LC		 1827
1828 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1829
bee0ffec
AN		 1830 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1831 " changed 0x%x",
f5fc0f86
LC		 1832 channel,
1833 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 1834 conf->power_level,
bee0ffec
AN		 1835 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1836 changed);
f5fc0f86 1837
781608c4
JO		 1838 /*
1839 * mac80211 will go to idle nearly immediately after transmitting some
1840 * frames, such as the deauth. To make sure those frames reach the air,
1841 * wait here until the TX queue is fully flushed.
1842 */
1843 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1844 (conf->flags & IEEE80211_CONF_IDLE))
1845 wl1271_tx_flush(wl);
1846
f5fc0f86
LC		 1847 mutex_lock(&wl->mutex);
1848
f8d9802f 1849 if (unlikely(wl->state == WL1271_STATE_OFF)) {
17e672d6
AN		 1850 /* we support configuring the channel and band while off */
1851 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1852 wl->band = conf->channel->band;
1853 wl->channel = channel;
1854 }
1855
2c10bb9c 1856 goto out;
f8d9802f 1857 }
8a5a37a6 1858
bee0ffec
AN		 1859 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1860
a620865e 1861 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 1862 if (ret < 0)
1863 goto out;
1864
ebba60c6 1865 /* if the channel changes while joined, join again */
69e5434c
JO		 1866 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1867 ((wl->band != conf->channel->band) ||
1868 (wl->channel != channel))) {
ebba60c6
JO		 1869 wl->band = conf->channel->band;
1870 wl->channel = channel;
1871
bee0ffec
AN		 1872 if (!is_ap) {
1873 /*
1874 * FIXME: the mac80211 should really provide a fixed
1875 * rate to use here. for now, just use the smallest
1876 * possible rate for the band as a fixed rate for
1877 * association frames and other control messages.
1878 */
1879 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1880 wl1271_set_band_rate(wl);
1881
1882 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1883 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 1884 if (ret < 0)
bee0ffec 1885 wl1271_warning("rate policy for channel "
ebba60c6 1886 "failed %d", ret);
bee0ffec
AN		 1887
1888 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1889 ret = wl1271_join(wl, false);
1890 if (ret < 0)
1891 wl1271_warning("cmd join on channel "
1892 "failed %d", ret);
1893 }
ebba60c6
JO		 1894 }
1895 }
1896
bee0ffec
AN		 1897 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1898 ret = wl1271_sta_handle_idle(wl,
1899 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 1900 if (ret < 0)
1901 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1902 }
1903
90494a90
JO		 1904 /*
1905 * if mac80211 changes the PSM mode, make sure the mode is not
1906 * incorrectly changed after the pspoll failure active window.
1907 */
1908 if (changed & IEEE80211_CONF_CHANGE_PS)
1909 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1910
71449f8d
JO		 1911 if (conf->flags & IEEE80211_CONF_PS &&
1912 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1913 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1914
1915 /*
1916 * We enter PSM only if we're already associated.
1917 * If we're not, we'll enter it when joining an SSID,
1918 * through the bss_info_changed() hook.
1919 */
830fb67b 1920 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1921 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1922 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 1923 wl->basic_rate, true);
af5e084b 1924 }
f5fc0f86 1925 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1926 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1927 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1928
71449f8d 1929 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1930
71449f8d 1931 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1932 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 1933 wl->basic_rate, true);
f5fc0f86
LC		 1934 }
1935
1936 if (conf->power_level != wl->power_level) {
1937 ret = wl1271_acx_tx_power(wl, conf->power_level);
1938 if (ret < 0)
c6317a54 1939 goto out_sleep;
f5fc0f86
LC		 1940
1941 wl->power_level = conf->power_level;
1942 }
1943
1944out_sleep:
1945 wl1271_ps_elp_sleep(wl);
1946
1947out:
1948 mutex_unlock(&wl->mutex);
1949
1950 return ret;
1951}
1952
b54853f1
JO		 1953struct wl1271_filter_params {
1954 bool enabled;
1955 int mc_list_length;
1956 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
1957};
1958
22bedad3
JP		 1959static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
1960 struct netdev_hw_addr_list *mc_list)
c87dec9f 1961{
c87dec9f 1962 struct wl1271_filter_params *fp;
22bedad3 1963 struct netdev_hw_addr *ha;
2c10bb9c 1964 struct wl1271 *wl = hw->priv;
c87dec9f 1965
2c10bb9c
SD		 1966 if (unlikely(wl->state == WL1271_STATE_OFF))
1967 return 0;
c87dec9f 1968
74441130 1969 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 1970 if (!fp) {
1971 wl1271_error("Out of memory setting filters.");
1972 return 0;
1973 }
1974
1975 /* update multicast filtering parameters */
c87dec9f 1976 fp->mc_list_length = 0;
22bedad3
JP		 1977 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
1978 fp->enabled = false;
1979 } else {
1980 fp->enabled = true;
1981 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 1982 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 1983 ha->addr, ETH_ALEN);
c87dec9f 1984 fp->mc_list_length++;
22bedad3 1985 }
c87dec9f
JO		 1986 }
1987
b54853f1 1988 return (u64)(unsigned long)fp;
c87dec9f 1989}
f5fc0f86 1990
b54853f1
JO		 1991#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
1992 FIF_ALLMULTI | \
1993 FIF_FCSFAIL | \
1994 FIF_BCN_PRBRESP_PROMISC | \
1995 FIF_CONTROL | \
1996 FIF_OTHER_BSS)
1997
f5fc0f86
LC		 1998static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
1999 unsigned int changed,
c87dec9f 2000 unsigned int *total, u64 multicast)
f5fc0f86 2001{
b54853f1 2002 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2003 struct wl1271 *wl = hw->priv;
b54853f1 2004 int ret;
f5fc0f86 2005
7d057869
AN		 2006 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2007 " total %x", changed, *total);
f5fc0f86 2008
b54853f1
JO		 2009 mutex_lock(&wl->mutex);
2010
2c10bb9c
SD		 2011 *total &= WL1271_SUPPORTED_FILTERS;
2012 changed &= WL1271_SUPPORTED_FILTERS;
2013
2014 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2015 goto out;
2016
a620865e 2017 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2018 if (ret < 0)
2019 goto out;
2020
7d057869
AN		 2021 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2022 if (*total & FIF_ALLMULTI)
2023 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2024 else if (fp)
2025 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2026 fp->mc_list,
2027 fp->mc_list_length);
2028 if (ret < 0)
2029 goto out_sleep;
2030 }
f5fc0f86 2031
b54853f1
JO		 2032 /* determine, whether supported filter values have changed */
2033 if (changed == 0)
2034 goto out_sleep;
c87dec9f 2035
14b228a0
JO		 2036 /* configure filters */
2037 wl->filters = *total;
2038 wl1271_configure_filters(wl, 0);
2039
b54853f1
JO		 2040 /* apply configured filters */
2041 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2042 if (ret < 0)
2043 goto out_sleep;
2044
2045out_sleep:
2046 wl1271_ps_elp_sleep(wl);
2047
2048out:
2049 mutex_unlock(&wl->mutex);
14b228a0 2050 kfree(fp);
f5fc0f86
LC		 2051}
2052
7f179b46
AN		 2053static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2054 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2055 u16 tx_seq_16)
2056{
2057 struct wl1271_ap_key *ap_key;
2058 int i;
2059
2060 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2061
2062 if (key_size > MAX_KEY_SIZE)
2063 return -EINVAL;
2064
2065 /*
2066 * Find next free entry in ap_keys. Also check we are not replacing
2067 * an existing key.
2068 */
2069 for (i = 0; i < MAX_NUM_KEYS; i++) {
2070 if (wl->recorded_ap_keys[i] == NULL)
2071 break;
2072
2073 if (wl->recorded_ap_keys[i]->id == id) {
2074 wl1271_warning("trying to record key replacement");
2075 return -EINVAL;
2076 }
2077 }
2078
2079 if (i == MAX_NUM_KEYS)
2080 return -EBUSY;
2081
2082 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2083 if (!ap_key)
2084 return -ENOMEM;
2085
2086 ap_key->id = id;
2087 ap_key->key_type = key_type;
2088 ap_key->key_size = key_size;
2089 memcpy(ap_key->key, key, key_size);
2090 ap_key->hlid = hlid;
2091 ap_key->tx_seq_32 = tx_seq_32;
2092 ap_key->tx_seq_16 = tx_seq_16;
2093
2094 wl->recorded_ap_keys[i] = ap_key;
2095 return 0;
2096}
2097
2098static void wl1271_free_ap_keys(struct wl1271 *wl)
2099{
2100 int i;
2101
2102 for (i = 0; i < MAX_NUM_KEYS; i++) {
2103 kfree(wl->recorded_ap_keys[i]);
2104 wl->recorded_ap_keys[i] = NULL;
2105 }
2106}
2107
2108static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2109{
2110 int i, ret = 0;
2111 struct wl1271_ap_key *key;
2112 bool wep_key_added = false;
2113
2114 for (i = 0; i < MAX_NUM_KEYS; i++) {
2115 if (wl->recorded_ap_keys[i] == NULL)
2116 break;
2117
2118 key = wl->recorded_ap_keys[i];
2119 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2120 key->id, key->key_type,
2121 key->key_size, key->key,
2122 key->hlid, key->tx_seq_32,
2123 key->tx_seq_16);
2124 if (ret < 0)
2125 goto out;
2126
2127 if (key->key_type == KEY_WEP)
2128 wep_key_added = true;
2129 }
2130
2131 if (wep_key_added) {
2132 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2133 if (ret < 0)
2134 goto out;
2135 }
2136
2137out:
2138 wl1271_free_ap_keys(wl);
2139 return ret;
2140}
2141
2142static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2143 u8 key_size, const u8 *key, u32 tx_seq_32,
2144 u16 tx_seq_16, struct ieee80211_sta *sta)
2145{
2146 int ret;
2147 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2148
2149 if (is_ap) {
2150 struct wl1271_station *wl_sta;
2151 u8 hlid;
2152
2153 if (sta) {
2154 wl_sta = (struct wl1271_station *)sta->drv_priv;
2155 hlid = wl_sta->hlid;
2156 } else {
2157 hlid = WL1271_AP_BROADCAST_HLID;
2158 }
2159
2160 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2161 /*
2162 * We do not support removing keys after AP shutdown.
2163 * Pretend we do to make mac80211 happy.
2164 */
2165 if (action != KEY_ADD_OR_REPLACE)
2166 return 0;
2167
2168 ret = wl1271_record_ap_key(wl, id,
2169 key_type, key_size,
2170 key, hlid, tx_seq_32,
2171 tx_seq_16);
2172 } else {
2173 ret = wl1271_cmd_set_ap_key(wl, action,
2174 id, key_type, key_size,
2175 key, hlid, tx_seq_32,
2176 tx_seq_16);
2177 }
2178
2179 if (ret < 0)
2180 return ret;
2181 } else {
2182 const u8 *addr;
2183 static const u8 bcast_addr[ETH_ALEN] = {
2184 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2185 };
2186
2187 addr = sta ? sta->addr : bcast_addr;
2188
2189 if (is_zero_ether_addr(addr)) {
2190 /* We dont support TX only encryption */
2191 return -EOPNOTSUPP;
2192 }
2193
2194 /* The wl1271 does not allow to remove unicast keys - they
2195 will be cleared automatically on next CMD_JOIN. Ignore the
2196 request silently, as we dont want the mac80211 to emit
2197 an error message. */
2198 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2199 return 0;
2200
2201 ret = wl1271_cmd_set_sta_key(wl, action,
2202 id, key_type, key_size,
2203 key, addr, tx_seq_32,
2204 tx_seq_16);
2205 if (ret < 0)
2206 return ret;
2207
2208 /* the default WEP key needs to be configured at least once */
2209 if (key_type == KEY_WEP) {
2210 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2211 wl->default_key);
2212 if (ret < 0)
2213 return ret;
2214 }
2215 }
2216
2217 return 0;
2218}
2219
f5fc0f86
LC		 2220static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2221 struct ieee80211_vif *vif,
2222 struct ieee80211_sta *sta,
2223 struct ieee80211_key_conf *key_conf)
2224{
2225 struct wl1271 *wl = hw->priv;
f5fc0f86 2226 int ret;
ac4e4ce5
JO		 2227 u32 tx_seq_32 = 0;
2228 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2229 u8 key_type;
2230
f5fc0f86
LC		 2231 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2232
7f179b46 2233 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2234 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2235 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2236 key_conf->keylen, key_conf->flags);
2237 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2238
f5fc0f86
LC		 2239 mutex_lock(&wl->mutex);
2240
f8d9802f
JO		 2241 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2242 ret = -EAGAIN;
2243 goto out_unlock;
2244 }
2245
a620865e 2246 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2247 if (ret < 0)
2248 goto out_unlock;
2249
97359d12
JB		 2250 switch (key_conf->cipher) {
2251 case WLAN_CIPHER_SUITE_WEP40:
2252 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2253 key_type = KEY_WEP;
2254
2255 key_conf->hw_key_idx = key_conf->keyidx;
2256 break;
97359d12 2257 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2258 key_type = KEY_TKIP;
2259
2260 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 2261 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2262 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2263 break;
97359d12 2264 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 2265 key_type = KEY_AES;
2266
2267 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 2268 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2269 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2270 break;
7a55724e
JO		 2271 case WL1271_CIPHER_SUITE_GEM:
2272 key_type = KEY_GEM;
2273 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2274 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2275 break;
f5fc0f86 2276 default:
97359d12 2277 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 2278
2279 ret = -EOPNOTSUPP;
2280 goto out_sleep;
2281 }
2282
2283 switch (cmd) {
2284 case SET_KEY:
7f179b46
AN		 2285 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2286 key_conf->keyidx, key_type,
2287 key_conf->keylen, key_conf->key,
2288 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 2289 if (ret < 0) {
2290 wl1271_error("Could not add or replace key");
2291 goto out_sleep;
2292 }
2293 break;
2294
2295 case DISABLE_KEY:
7f179b46
AN		 2296 ret = wl1271_set_key(wl, KEY_REMOVE,
2297 key_conf->keyidx, key_type,
2298 key_conf->keylen, key_conf->key,
2299 0, 0, sta);
f5fc0f86
LC		 2300 if (ret < 0) {
2301 wl1271_error("Could not remove key");
2302 goto out_sleep;
2303 }
2304 break;
2305
2306 default:
2307 wl1271_error("Unsupported key cmd 0x%x", cmd);
2308 ret = -EOPNOTSUPP;
f5fc0f86
LC		 2309 break;
2310 }
2311
2312out_sleep:
2313 wl1271_ps_elp_sleep(wl);
2314
2315out_unlock:
2316 mutex_unlock(&wl->mutex);
2317
f5fc0f86
LC		 2318 return ret;
2319}
2320
2321static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 2322 struct ieee80211_vif *vif,
f5fc0f86
LC		 2323 struct cfg80211_scan_request *req)
2324{
2325 struct wl1271 *wl = hw->priv;
2326 int ret;
2327 u8 *ssid = NULL;
abb0b3bf 2328 size_t len = 0;
f5fc0f86
LC		 2329
2330 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2331
2332 if (req->n_ssids) {
2333 ssid = req->ssids[0].ssid;
abb0b3bf 2334 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 2335 }
2336
2337 mutex_lock(&wl->mutex);
2338
b739a42c
JO		 2339 if (wl->state == WL1271_STATE_OFF) {
2340 /*
2341 * We cannot return -EBUSY here because cfg80211 will expect
2342 * a call to ieee80211_scan_completed if we do - in this case
2343 * there won't be any call.
2344 */
2345 ret = -EAGAIN;
2346 goto out;
2347 }
2348
a620865e 2349 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2350 if (ret < 0)
2351 goto out;
2352
5924f89d 2353 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 2354
2355 wl1271_ps_elp_sleep(wl);
2356
2357out:
2358 mutex_unlock(&wl->mutex);
2359
2360 return ret;
2361}
2362
33c2c06c
LC		 2363static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2364 struct ieee80211_vif *vif,
2365 struct cfg80211_sched_scan_request *req,
2366 struct ieee80211_sched_scan_ies *ies)
2367{
2368 struct wl1271 *wl = hw->priv;
2369 int ret;
2370
2371 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2372
2373 mutex_lock(&wl->mutex);
2374
2375 ret = wl1271_ps_elp_wakeup(wl);
2376 if (ret < 0)
2377 goto out;
2378
2379 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2380 if (ret < 0)
2381 goto out_sleep;
2382
2383 ret = wl1271_scan_sched_scan_start(wl);
2384 if (ret < 0)
2385 goto out_sleep;
2386
2387 wl->sched_scanning = true;
2388
2389out_sleep:
2390 wl1271_ps_elp_sleep(wl);
2391out:
2392 mutex_unlock(&wl->mutex);
2393 return ret;
2394}
2395
2396static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2397 struct ieee80211_vif *vif)
2398{
2399 struct wl1271 *wl = hw->priv;
2400 int ret;
2401
2402 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2403
2404 mutex_lock(&wl->mutex);
2405
2406 ret = wl1271_ps_elp_wakeup(wl);
2407 if (ret < 0)
2408 goto out;
2409
2410 wl1271_scan_sched_scan_stop(wl);
2411
2412 wl1271_ps_elp_sleep(wl);
2413out:
2414 mutex_unlock(&wl->mutex);
2415}
2416
68d069c4
AN		 2417static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2418{
2419 struct wl1271 *wl = hw->priv;
2420 int ret = 0;
2421
2422 mutex_lock(&wl->mutex);
2423
2424 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2425 ret = -EAGAIN;
2426 goto out;
2427 }
2428
a620865e 2429 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 2430 if (ret < 0)
2431 goto out;
2432
5f704d18 2433 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 2434 if (ret < 0)
2435 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2436
2437 wl1271_ps_elp_sleep(wl);
2438
2439out:
2440 mutex_unlock(&wl->mutex);
2441
2442 return ret;
2443}
2444
f5fc0f86
LC		 2445static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2446{
2447 struct wl1271 *wl = hw->priv;
aecb0565 2448 int ret = 0;
f5fc0f86
LC		 2449
2450 mutex_lock(&wl->mutex);
2451
f8d9802f
JO		 2452 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2453 ret = -EAGAIN;
aecb0565 2454 goto out;
f8d9802f 2455 }
aecb0565 2456
a620865e 2457 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2458 if (ret < 0)
2459 goto out;
2460
5f704d18 2461 ret = wl1271_acx_rts_threshold(wl, value);
f5fc0f86
LC		 2462 if (ret < 0)
2463 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2464
2465 wl1271_ps_elp_sleep(wl);
2466
2467out:
2468 mutex_unlock(&wl->mutex);
2469
2470 return ret;
2471}
2472
e78a287a 2473static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2474 int offset)
30240fc7 2475{
889cb360
EP		 2476 u8 ssid_len;
2477 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2478 skb->len - offset);
30240fc7 2479
889cb360
EP		 2480 if (!ptr) {
2481 wl1271_error("No SSID in IEs!");
2482 return -ENOENT;
2483 }
2484
2485 ssid_len = ptr[1];
2486 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2487 wl1271_error("SSID is too long!");
2488 return -EINVAL;
30240fc7 2489 }
e78a287a 2490
889cb360
EP		 2491 wl->ssid_len = ssid_len;
2492 memcpy(wl->ssid, ptr+2, ssid_len);
2493 return 0;
30240fc7
JO		 2494}
2495
e78a287a 2496static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2497 struct ieee80211_bss_conf *bss_conf,
2498 u32 changed)
2499{
e78a287a 2500 int ret = 0;
f5fc0f86 2501
e78a287a
AN		 2502 if (changed & BSS_CHANGED_ERP_SLOT) {
2503 if (bss_conf->use_short_slot)
2504 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2505 else
2506 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2507 if (ret < 0) {
2508 wl1271_warning("Set slot time failed %d", ret);
2509 goto out;
2510 }
2511 }
f5fc0f86 2512
e78a287a
AN		 2513 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2514 if (bss_conf->use_short_preamble)
2515 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2516 else
2517 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2518 }
f5fc0f86 2519
e78a287a
AN		 2520 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2521 if (bss_conf->use_cts_prot)
2522 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2523 else
2524 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2525 if (ret < 0) {
2526 wl1271_warning("Set ctsprotect failed %d", ret);
2527 goto out;
2528 }
2529 }
f8d9802f 2530
e78a287a
AN		 2531out:
2532 return ret;
2533}
f5fc0f86 2534
e78a287a
AN		 2535static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2536 struct ieee80211_vif *vif,
2537 struct ieee80211_bss_conf *bss_conf,
2538 u32 changed)
2539{
2540 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2541 int ret = 0;
2542
2543 if ((changed & BSS_CHANGED_BEACON_INT)) {
2544 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 2545 bss_conf->beacon_int);
2546
2547 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 2548 }
2549
e78a287a
AN		 2550 if ((changed & BSS_CHANGED_BEACON)) {
2551 struct ieee80211_hdr *hdr;
2552 int ieoffset = offsetof(struct ieee80211_mgmt,
2553 u.beacon.variable);
2554 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2555 u16 tmpl_id;
2556
2557 if (!beacon)
2558 goto out;
2559
2560 wl1271_debug(DEBUG_MASTER, "beacon updated");
2561
2562 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2563 if (ret < 0) {
2564 dev_kfree_skb(beacon);
2565 goto out;
2566 }
2567 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2568 CMD_TEMPL_BEACON;
2569 ret = wl1271_cmd_template_set(wl, tmpl_id,
2570 beacon->data,
2571 beacon->len, 0,
2572 wl1271_tx_min_rate_get(wl));
2573 if (ret < 0) {
2574 dev_kfree_skb(beacon);
2575 goto out;
2576 }
2577
2578 hdr = (struct ieee80211_hdr *) beacon->data;
2579 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2580 IEEE80211_STYPE_PROBE_RESP);
2581
2582 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2583 CMD_TEMPL_PROBE_RESPONSE;
2584 ret = wl1271_cmd_template_set(wl,
2585 tmpl_id,
2586 beacon->data,
2587 beacon->len, 0,
2588 wl1271_tx_min_rate_get(wl));
2589 dev_kfree_skb(beacon);
2590 if (ret < 0)
2591 goto out;
2592 }
2593
2594out:
2595 return ret;
2596}
2597
2598/* AP mode changes */
2599static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2600 struct ieee80211_vif *vif,
2601 struct ieee80211_bss_conf *bss_conf,
2602 u32 changed)
2603{
2604 int ret = 0;
e0d8bbf0 2605
e78a287a
AN		 2606 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2607 u32 rates = bss_conf->basic_rates;
5da11dcd 2608
e78a287a
AN		 2609 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2610 wl->basic_rate = wl1271_tx_min_rate_get(wl);
70f47424
AN		 2611
2612 ret = wl1271_init_ap_rates(wl);
e78a287a 2613 if (ret < 0) {
70f47424 2614 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 2615 goto out;
2616 }
c45a85b5
AN		 2617
2618 ret = wl1271_ap_init_templates(wl);
2619 if (ret < 0)
2620 goto out;
e78a287a 2621 }
2f6724b2 2622
e78a287a
AN		 2623 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2624 if (ret < 0)
2625 goto out;
30240fc7 2626
e78a287a
AN		 2627 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2628 if (bss_conf->enable_beacon) {
2629 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2630 ret = wl1271_cmd_start_bss(wl);
2631 if (ret < 0)
2632 goto out;
e0d8bbf0 2633
e78a287a
AN		 2634 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2635 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 2636
2637 ret = wl1271_ap_init_hwenc(wl);
2638 if (ret < 0)
2639 goto out;
e0d8bbf0 2640 }
e78a287a
AN		 2641 } else {
2642 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2643 ret = wl1271_cmd_stop_bss(wl);
2644 if (ret < 0)
2645 goto out;
e0d8bbf0 2646
e78a287a
AN		 2647 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2648 wl1271_debug(DEBUG_AP, "stopped AP");
2649 }
2650 }
2651 }
e0d8bbf0 2652
cb5ae053
EP		 2653 if (changed & BSS_CHANGED_IBSS) {
2654 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
2655 bss_conf->ibss_joined);
2656
2657 if (bss_conf->ibss_joined) {
2658 u32 rates = bss_conf->basic_rates;
2659 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2660 rates);
2661 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2662
2663 /* by default, use 11b rates */
2664 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
2665 ret = wl1271_acx_sta_rate_policies(wl);
2666 if (ret < 0)
2667 goto out;
2668 }
2669 }
2670
e78a287a
AN		 2671 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2672 if (ret < 0)
2673 goto out;
2674out:
2675 return;
2676}
8bf29b0e 2677
e78a287a
AN		 2678/* STA/IBSS mode changes */
2679static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2680 struct ieee80211_vif *vif,
2681 struct ieee80211_bss_conf *bss_conf,
2682 u32 changed)
2683{
2684 bool do_join = false, set_assoc = false;
2685 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 2686 u32 sta_rate_set = 0;
e78a287a 2687 int ret;
2d6e4e76 2688 struct ieee80211_sta *sta;
a100885d
AN		 2689 bool sta_exists = false;
2690 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 2691
2692 if (is_ibss) {
2693 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2694 changed);
2695 if (ret < 0)
2696 goto out;
e0d8bbf0
JO		 2697 }
2698
e78a287a
AN		 2699 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2700 do_join = true;
2701
2702 /* Need to update the SSID (for filtering etc) */
2703 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2704 do_join = true;
2705
2706 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 2707 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2708 bss_conf->enable_beacon ? "enabled" : "disabled");
2709
2710 if (bss_conf->enable_beacon)
2711 wl->set_bss_type = BSS_TYPE_IBSS;
2712 else
2713 wl->set_bss_type = BSS_TYPE_STA_BSS;
2714 do_join = true;
2715 }
2716
e78a287a 2717 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 2718 bool enable = false;
2719 if (bss_conf->cqm_rssi_thold)
2720 enable = true;
2721 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2722 bss_conf->cqm_rssi_thold,
2723 bss_conf->cqm_rssi_hyst);
2724 if (ret < 0)
2725 goto out;
2726 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2727 }
2728
30240fc7
JO		 2729 if ((changed & BSS_CHANGED_BSSID) &&
2730 /*
2731 * Now we know the correct bssid, so we send a new join command
2732 * and enable the BSSID filter
2733 */
2734 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 2735 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 2736
fa287b8f
EP		 2737 if (!is_zero_ether_addr(wl->bssid)) {
2738 ret = wl1271_cmd_build_null_data(wl);
2739 if (ret < 0)
2740 goto out;
30240fc7 2741
fa287b8f
EP		 2742 ret = wl1271_build_qos_null_data(wl);
2743 if (ret < 0)
2744 goto out;
30240fc7 2745
fa287b8f
EP		 2746 /* filter out all packets not from this BSSID */
2747 wl1271_configure_filters(wl, 0);
14b228a0 2748
fa287b8f
EP		 2749 /* Need to update the BSSID (for filtering etc) */
2750 do_join = true;
2751 }
30240fc7
JO		 2752 }
2753
72c2d9e5
EP		 2754 rcu_read_lock();
2755 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2756 if (sta) {
2757 /* save the supp_rates of the ap */
2758 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2759 if (sta->ht_cap.ht_supported)
2760 sta_rate_set |=
2761 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 2762 sta_ht_cap = sta->ht_cap;
2763 sta_exists = true;
2764 }
2765 rcu_read_unlock();
72c2d9e5 2766
a100885d 2767 if (sta_exists) {
72c2d9e5
EP		 2768 /* handle new association with HT and HT information change */
2769 if ((changed & BSS_CHANGED_HT) &&
2770 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 2771 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2772 true);
2773 if (ret < 0) {
2774 wl1271_warning("Set ht cap true failed %d",
2775 ret);
72c2d9e5
EP		 2776 goto out;
2777 }
2778 ret = wl1271_acx_set_ht_information(wl,
2779 bss_conf->ht_operation_mode);
2780 if (ret < 0) {
2781 wl1271_warning("Set ht information failed %d",
2782 ret);
72c2d9e5
EP		 2783 goto out;
2784 }
2785 }
2786 /* handle new association without HT and disassociation */
2787 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 2788 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2789 false);
2790 if (ret < 0) {
2791 wl1271_warning("Set ht cap false failed %d",
2792 ret);
72c2d9e5
EP		 2793 goto out;
2794 }
2795 }
2796 }
72c2d9e5 2797
e78a287a 2798 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 2799 if (bss_conf->assoc) {
ebba60c6 2800 u32 rates;
2f6724b2 2801 int ieoffset;
f5fc0f86 2802 wl->aid = bss_conf->aid;
69e5434c 2803 set_assoc = true;
f5fc0f86 2804
90494a90
JO		 2805 wl->ps_poll_failures = 0;
2806
ebba60c6
JO		 2807 /*
2808 * use basic rates from AP, and determine lowest rate
2809 * to use with control frames.
2810 */
2811 rates = bss_conf->basic_rates;
2812 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2813 rates);
e0fe371b 2814 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 2815 if (sta_rate_set)
2816 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2817 sta_rate_set);
79b223f4 2818 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2819 if (ret < 0)
e78a287a 2820 goto out;
ebba60c6 2821
ae751bab
LC		 2822 /*
2823 * with wl1271, we don't need to update the
2824 * beacon_int and dtim_period, because the firmware
2825 * updates it by itself when the first beacon is
2826 * received after a join.
2827 */
f5fc0f86
LC		 2828 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2829 if (ret < 0)
e78a287a 2830 goto out;
f5fc0f86 2831
c2b2d99b 2832 /*
2f6724b2 2833 * Get a template for hardware connection maintenance
c2b2d99b 2834 */
2f6724b2
JO		 2835 dev_kfree_skb(wl->probereq);
2836 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2837 ieoffset = offsetof(struct ieee80211_mgmt,
2838 u.probe_req.variable);
2839 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 2840
6ccbb92e
JO		 2841 /* enable the connection monitoring feature */
2842 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 2843 if (ret < 0)
e78a287a 2844 goto out;
f5fc0f86
LC		 2845
2846 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 2847 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2848 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 2849 enum wl1271_cmd_ps_mode mode;
2850
f5fc0f86 2851 mode = STATION_POWER_SAVE_MODE;
65cddbf1 2852 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 2853 wl->basic_rate,
65cddbf1 2854 true);
f5fc0f86 2855 if (ret < 0)
e78a287a 2856 goto out;
f5fc0f86 2857 }
d94cd297
JO		 2858 } else {
2859 /* use defaults when not associated */
30df14d0
EP		 2860 bool was_assoc =
2861 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
2862 &wl->flags);
c2c192ac 2863 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
d94cd297 2864 wl->aid = 0;
6ccbb92e 2865
2f6724b2
JO		 2866 /* free probe-request template */
2867 dev_kfree_skb(wl->probereq);
2868 wl->probereq = NULL;
2869
8d2ef7bd 2870 /* re-enable dynamic ps - just in case */
f532be6d 2871 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2872
ebba60c6
JO		 2873 /* revert back to minimum rates for the current band */
2874 wl1271_set_band_rate(wl);
e0fe371b 2875 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 2876 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2877 if (ret < 0)
e78a287a 2878 goto out;
ebba60c6 2879
6ccbb92e
JO		 2880 /* disable connection monitor features */
2881 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2882
2883 /* Disable the keep-alive feature */
2884 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 2885 if (ret < 0)
e78a287a 2886 goto out;
b84a7d3d
JO		 2887
2888 /* restore the bssid filter and go to dummy bssid */
30df14d0
EP		 2889 if (was_assoc) {
2890 wl1271_unjoin(wl);
2891 wl1271_dummy_join(wl);
2892 }
f5fc0f86 2893 }
f5fc0f86
LC		 2894 }
2895
e78a287a
AN		 2896 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2897 if (ret < 0)
2898 goto out;
f5fc0f86 2899
ca52a5eb
JO		 2900 if (changed & BSS_CHANGED_ARP_FILTER) {
2901 __be32 addr = bss_conf->arp_addr_list[0];
2902 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2903
c5312772
EP		 2904 if (bss_conf->arp_addr_cnt == 1 &&
2905 bss_conf->arp_filter_enabled) {
2906 /*
2907 * The template should have been configured only upon
2908 * association. however, it seems that the correct ip
2909 * isn't being set (when sending), so we have to
2910 * reconfigure the template upon every ip change.
2911 */
2912 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2913 if (ret < 0) {
2914 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 2915 goto out;
c5312772
EP		 2916 }
2917
2918 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 2919 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 2920 addr);
2921 } else
2922 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 2923
2924 if (ret < 0)
e78a287a 2925 goto out;
ca52a5eb
JO		 2926 }
2927
8bf29b0e 2928 if (do_join) {
69e5434c 2929 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2930 if (ret < 0) {
2931 wl1271_warning("cmd join failed %d", ret);
e78a287a 2932 goto out;
8bf29b0e 2933 }
c1899554
JO		 2934 }
2935
e78a287a
AN		 2936out:
2937 return;
2938}
2939
2940static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2941 struct ieee80211_vif *vif,
2942 struct ieee80211_bss_conf *bss_conf,
2943 u32 changed)
2944{
2945 struct wl1271 *wl = hw->priv;
2946 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2947 int ret;
2948
2949 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2950 (int)changed);
2951
2952 mutex_lock(&wl->mutex);
2953
2954 if (unlikely(wl->state == WL1271_STATE_OFF))
2955 goto out;
2956
a620865e 2957 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 2958 if (ret < 0)
2959 goto out;
2960
2961 if (is_ap)
2962 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
2963 else
2964 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
2965
f5fc0f86
LC		 2966 wl1271_ps_elp_sleep(wl);
2967
2968out:
2969 mutex_unlock(&wl->mutex);
2970}
2971
c6999d83
KV		 2972static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
2973 const struct ieee80211_tx_queue_params *params)
2974{
2975 struct wl1271 *wl = hw->priv;
4695dc91 2976 u8 ps_scheme;
488fc540 2977 int ret = 0;
c6999d83
KV		 2978
2979 mutex_lock(&wl->mutex);
2980
2981 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
2982
4695dc91
KV		 2983 if (params->uapsd)
2984 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
2985 else
2986 ps_scheme = CONF_PS_SCHEME_LEGACY;
2987
488fc540
AN		 2988 if (wl->state == WL1271_STATE_OFF) {
2989 /*
2990 * If the state is off, the parameters will be recorded and
2991 * configured on init. This happens in AP-mode.
2992 */
2993 struct conf_tx_ac_category *conf_ac =
2994 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
2995 struct conf_tx_tid *conf_tid =
2996 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
2997
2998 conf_ac->ac = wl1271_tx_get_queue(queue);
2999 conf_ac->cw_min = (u8)params->cw_min;
3000 conf_ac->cw_max = params->cw_max;
3001 conf_ac->aifsn = params->aifs;
3002 conf_ac->tx_op_limit = params->txop << 5;
3003
3004 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3005 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3006 conf_tid->tsid = wl1271_tx_get_queue(queue);
3007 conf_tid->ps_scheme = ps_scheme;
3008 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3009 conf_tid->apsd_conf[0] = 0;
3010 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3011 goto out;
3012 }
488fc540 3013
c1b193eb
EP		 3014 ret = wl1271_ps_elp_wakeup(wl);
3015 if (ret < 0)
3016 goto out;
488fc540 3017
c1b193eb
EP		 3018 /*
3019 * the txop is confed in units of 32us by the mac80211,
3020 * we need us
3021 */
3022 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3023 params->cw_min, params->cw_max,
3024 params->aifs, params->txop << 5);
3025 if (ret < 0)
3026 goto out_sleep;
3027
3028 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3029 CONF_CHANNEL_TYPE_EDCF,
3030 wl1271_tx_get_queue(queue),
3031 ps_scheme, CONF_ACK_POLICY_LEGACY,
3032 0, 0);
c82c1dde
KV		 3033
3034out_sleep:
c1b193eb 3035 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 3036
3037out:
3038 mutex_unlock(&wl->mutex);
3039
3040 return ret;
3041}
3042
bbbb538e
JO		 3043static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3044{
3045
3046 struct wl1271 *wl = hw->priv;
3047 u64 mactime = ULLONG_MAX;
3048 int ret;
3049
3050 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3051
3052 mutex_lock(&wl->mutex);
3053
f8d9802f
JO		 3054 if (unlikely(wl->state == WL1271_STATE_OFF))
3055 goto out;
3056
a620865e 3057 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 3058 if (ret < 0)
3059 goto out;
3060
3061 ret = wl1271_acx_tsf_info(wl, &mactime);
3062 if (ret < 0)
3063 goto out_sleep;
3064
3065out_sleep:
3066 wl1271_ps_elp_sleep(wl);
3067
3068out:
3069 mutex_unlock(&wl->mutex);
3070 return mactime;
3071}
f5fc0f86 3072
ece550d0
JL		 3073static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3074 struct survey_info *survey)
3075{
3076 struct wl1271 *wl = hw->priv;
3077 struct ieee80211_conf *conf = &hw->conf;
b739a42c 3078
ece550d0
JL		 3079 if (idx != 0)
3080 return -ENOENT;
b739a42c 3081
ece550d0
JL		 3082 survey->channel = conf->channel;
3083 survey->filled = SURVEY_INFO_NOISE_DBM;
3084 survey->noise = wl->noise;
b739a42c 3085
ece550d0
JL		 3086 return 0;
3087}
3088
409622ec 3089static int wl1271_allocate_sta(struct wl1271 *wl,
f84f7d78
AN		 3090 struct ieee80211_sta *sta,
3091 u8 *hlid)
3092{
3093 struct wl1271_station *wl_sta;
3094 int id;
3095
3096 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3097 if (id >= AP_MAX_STATIONS) {
3098 wl1271_warning("could not allocate HLID - too much stations");
3099 return -EBUSY;
3100 }
3101
3102 wl_sta = (struct wl1271_station *)sta->drv_priv;
f84f7d78
AN		 3103 __set_bit(id, wl->ap_hlid_map);
3104 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3105 *hlid = wl_sta->hlid;
b622d992 3106 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
f84f7d78
AN		 3107 return 0;
3108}
3109
409622ec 3110static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
f84f7d78
AN		 3111{
3112 int id = hlid - WL1271_AP_STA_HLID_START;
3113
409622ec
AN		 3114 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3115 return;
3116
f84f7d78 3117 __clear_bit(id, wl->ap_hlid_map);
b622d992 3118 memset(wl->links[hlid].addr, 0, ETH_ALEN);
a8c0ddb5 3119 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 3120 __clear_bit(hlid, &wl->ap_ps_map);
3121 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
f84f7d78
AN		 3122}
3123
3124static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3125 struct ieee80211_vif *vif,
3126 struct ieee80211_sta *sta)
3127{
3128 struct wl1271 *wl = hw->priv;
3129 int ret = 0;
3130 u8 hlid;
3131
3132 mutex_lock(&wl->mutex);
3133
3134 if (unlikely(wl->state == WL1271_STATE_OFF))
3135 goto out;
3136
3137 if (wl->bss_type != BSS_TYPE_AP_BSS)
3138 goto out;
3139
3140 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3141
409622ec 3142 ret = wl1271_allocate_sta(wl, sta, &hlid);
f84f7d78
AN		 3143 if (ret < 0)
3144 goto out;
3145
a620865e 3146 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 3147 if (ret < 0)
409622ec 3148 goto out_free_sta;
f84f7d78
AN		 3149
3150 ret = wl1271_cmd_add_sta(wl, sta, hlid);
3151 if (ret < 0)
3152 goto out_sleep;
3153
3154out_sleep:
3155 wl1271_ps_elp_sleep(wl);
3156
409622ec
AN		 3157out_free_sta:
3158 if (ret < 0)
3159 wl1271_free_sta(wl, hlid);
3160
f84f7d78
AN		 3161out:
3162 mutex_unlock(&wl->mutex);
3163 return ret;
3164}
3165
3166static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3167 struct ieee80211_vif *vif,
3168 struct ieee80211_sta *sta)
3169{
3170 struct wl1271 *wl = hw->priv;
3171 struct wl1271_station *wl_sta;
3172 int ret = 0, id;
3173
3174 mutex_lock(&wl->mutex);
3175
3176 if (unlikely(wl->state == WL1271_STATE_OFF))
3177 goto out;
3178
3179 if (wl->bss_type != BSS_TYPE_AP_BSS)
3180 goto out;
3181
3182 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3183
3184 wl_sta = (struct wl1271_station *)sta->drv_priv;
3185 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3186 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3187 goto out;
3188
a620865e 3189 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 3190 if (ret < 0)
3191 goto out;
3192
3193 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3194 if (ret < 0)
3195 goto out_sleep;
3196
409622ec 3197 wl1271_free_sta(wl, wl_sta->hlid);
f84f7d78
AN		 3198
3199out_sleep:
3200 wl1271_ps_elp_sleep(wl);
3201
3202out:
3203 mutex_unlock(&wl->mutex);
3204 return ret;
3205}
3206
4623ec7d
LC		 3207static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3208 struct ieee80211_vif *vif,
3209 enum ieee80211_ampdu_mlme_action action,
3210 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3211 u8 buf_size)
bbba3e68
LS		 3212{
3213 struct wl1271 *wl = hw->priv;
3214 int ret;
3215
3216 mutex_lock(&wl->mutex);
3217
3218 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3219 ret = -EAGAIN;
3220 goto out;
3221 }
3222
a620865e 3223 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 3224 if (ret < 0)
3225 goto out;
3226
3227 switch (action) {
3228 case IEEE80211_AMPDU_RX_START:
3229 if (wl->ba_support) {
3230 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3231 true);
3232 if (!ret)
3233 wl->ba_rx_bitmap |= BIT(tid);
3234 } else {
3235 ret = -ENOTSUPP;
3236 }
3237 break;
3238
3239 case IEEE80211_AMPDU_RX_STOP:
3240 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3241 if (!ret)
3242 wl->ba_rx_bitmap &= ~BIT(tid);
3243 break;
3244
3245 /*
3246 * The BA initiator session management in FW independently.
3247 * Falling break here on purpose for all TX APDU commands.
3248 */
3249 case IEEE80211_AMPDU_TX_START:
3250 case IEEE80211_AMPDU_TX_STOP:
3251 case IEEE80211_AMPDU_TX_OPERATIONAL:
3252 ret = -EINVAL;
3253 break;
3254
3255 default:
3256 wl1271_error("Incorrect ampdu action id=%x\n", action);
3257 ret = -EINVAL;
3258 }
3259
3260 wl1271_ps_elp_sleep(wl);
3261
3262out:
3263 mutex_unlock(&wl->mutex);
3264
3265 return ret;
3266}
3267
33437893
AN		 3268static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3269{
3270 struct wl1271 *wl = hw->priv;
3271 bool ret = false;
3272
3273 mutex_lock(&wl->mutex);
3274
3275 if (unlikely(wl->state == WL1271_STATE_OFF))
3276 goto out;
3277
3278 /* packets are considered pending if in the TX queue or the FW */
3279 ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3280
3281 /* the above is appropriate for STA mode for PS purposes */
3282 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3283
3284out:
3285 mutex_unlock(&wl->mutex);
3286
3287 return ret;
3288}
3289
f5fc0f86
LC		 3290/* can't be const, mac80211 writes to this */
3291static struct ieee80211_rate wl1271_rates[] = {
3292 { .bitrate = 10,
2b60100b
JO		 3293 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3294 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 3295 { .bitrate = 20,
2b60100b
JO		 3296 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3297 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 3298 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3299 { .bitrate = 55,
2b60100b
JO		 3300 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3301 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 3302 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3303 { .bitrate = 110,
2b60100b
JO		 3304 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3305 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 3306 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3307 { .bitrate = 60,
2b60100b
JO		 3308 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3309 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 3310 { .bitrate = 90,
2b60100b
JO		 3311 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3312 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 3313 { .bitrate = 120,
2b60100b
JO		 3314 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3315 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 3316 { .bitrate = 180,
2b60100b
JO		 3317 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3318 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 3319 { .bitrate = 240,
2b60100b
JO		 3320 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3321 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 3322 { .bitrate = 360,
2b60100b
JO		 3323 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3324 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 3325 { .bitrate = 480,
2b60100b
JO		 3326 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3327 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 3328 { .bitrate = 540,
2b60100b
JO		 3329 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3330 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 3331};
3332
fa97f46b 3333/* can't be const, mac80211 writes to this */
f5fc0f86 3334static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 3335 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 3336 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 3337 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3338 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3339 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 3340 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 3341 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3342 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3343 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 3344 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 3345 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3346 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3347 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 3348 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 3349};
3350
f876bb9a 3351/* mapping to indexes for wl1271_rates */
a0ea9493 3352static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 3353 /* MCS rates are used only with 11n */
18357850
SL		 3354 7, /* CONF_HW_RXTX_RATE_MCS7 */
3355 6, /* CONF_HW_RXTX_RATE_MCS6 */
3356 5, /* CONF_HW_RXTX_RATE_MCS5 */
3357 4, /* CONF_HW_RXTX_RATE_MCS4 */
3358 3, /* CONF_HW_RXTX_RATE_MCS3 */
3359 2, /* CONF_HW_RXTX_RATE_MCS2 */
3360 1, /* CONF_HW_RXTX_RATE_MCS1 */
3361 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3362
3363 11, /* CONF_HW_RXTX_RATE_54 */
3364 10, /* CONF_HW_RXTX_RATE_48 */
3365 9, /* CONF_HW_RXTX_RATE_36 */
3366 8, /* CONF_HW_RXTX_RATE_24 */
3367
3368 /* TI-specific rate */
3369 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3370
3371 7, /* CONF_HW_RXTX_RATE_18 */
3372 6, /* CONF_HW_RXTX_RATE_12 */
3373 3, /* CONF_HW_RXTX_RATE_11 */
3374 5, /* CONF_HW_RXTX_RATE_9 */
3375 4, /* CONF_HW_RXTX_RATE_6 */
3376 2, /* CONF_HW_RXTX_RATE_5_5 */
3377 1, /* CONF_HW_RXTX_RATE_2 */
3378 0 /* CONF_HW_RXTX_RATE_1 */
3379};
3380
e8b03a2b
SL		 3381/* 11n STA capabilities */
3382#define HW_RX_HIGHEST_RATE 72
3383
00d20100
SL		 3384#ifdef CONFIG_WL12XX_HT
3385#define WL12XX_HT_CAP { \
871d0c3b
SL		 3386 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3387 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 3388 .ht_supported = true, \
3389 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3390 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3391 .mcs = { \
3392 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3393 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3394 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3395 }, \
3396}
18357850 3397#else
00d20100 3398#define WL12XX_HT_CAP { \
18357850
SL		 3399 .ht_supported = false, \
3400}
3401#endif
e8b03a2b 3402
f5fc0f86
LC		 3403/* can't be const, mac80211 writes to this */
3404static struct ieee80211_supported_band wl1271_band_2ghz = {
3405 .channels = wl1271_channels,
3406 .n_channels = ARRAY_SIZE(wl1271_channels),
3407 .bitrates = wl1271_rates,
3408 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 3409 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 3410};
3411
1ebec3d7
TP		 3412/* 5 GHz data rates for WL1273 */
3413static struct ieee80211_rate wl1271_rates_5ghz[] = {
3414 { .bitrate = 60,
3415 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3416 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3417 { .bitrate = 90,
3418 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3419 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3420 { .bitrate = 120,
3421 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3422 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3423 { .bitrate = 180,
3424 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3425 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3426 { .bitrate = 240,
3427 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3428 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3429 { .bitrate = 360,
3430 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3431 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3432 { .bitrate = 480,
3433 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3434 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3435 { .bitrate = 540,
3436 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3437 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3438};
3439
fa97f46b 3440/* 5 GHz band channels for WL1273 */
1ebec3d7 3441static struct ieee80211_channel wl1271_channels_5ghz[] = {
fa21c7a9 3442 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 3443 { .hw_value = 8, .center_freq = 5040},
3444 { .hw_value = 9, .center_freq = 5045},
3445 { .hw_value = 11, .center_freq = 5055},
3446 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 3447 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 3448 { .hw_value = 34, .center_freq = 5170},
3449 { .hw_value = 36, .center_freq = 5180},
3450 { .hw_value = 38, .center_freq = 5190},
3451 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 3452 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 3453 { .hw_value = 44, .center_freq = 5220},
3454 { .hw_value = 46, .center_freq = 5230},
3455 { .hw_value = 48, .center_freq = 5240},
3456 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 3457 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 3458 { .hw_value = 60, .center_freq = 5300},
3459 { .hw_value = 64, .center_freq = 5320},
3460 { .hw_value = 100, .center_freq = 5500},
3461 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 3462 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 3463 { .hw_value = 112, .center_freq = 5560},
3464 { .hw_value = 116, .center_freq = 5580},
3465 { .hw_value = 120, .center_freq = 5600},
3466 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 3467 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 3468 { .hw_value = 132, .center_freq = 5660},
3469 { .hw_value = 136, .center_freq = 5680},
3470 { .hw_value = 140, .center_freq = 5700},
3471 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 3472 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 3473 { .hw_value = 157, .center_freq = 5785},
3474 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 3475 { .hw_value = 165, .center_freq = 5825},
3476};
3477
f876bb9a 3478/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 3479static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 3480 /* MCS rates are used only with 11n */
18357850
SL		 3481 7, /* CONF_HW_RXTX_RATE_MCS7 */
3482 6, /* CONF_HW_RXTX_RATE_MCS6 */
3483 5, /* CONF_HW_RXTX_RATE_MCS5 */
3484 4, /* CONF_HW_RXTX_RATE_MCS4 */
3485 3, /* CONF_HW_RXTX_RATE_MCS3 */
3486 2, /* CONF_HW_RXTX_RATE_MCS2 */
3487 1, /* CONF_HW_RXTX_RATE_MCS1 */
3488 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3489
3490 7, /* CONF_HW_RXTX_RATE_54 */
3491 6, /* CONF_HW_RXTX_RATE_48 */
3492 5, /* CONF_HW_RXTX_RATE_36 */
3493 4, /* CONF_HW_RXTX_RATE_24 */
3494
3495 /* TI-specific rate */
3496 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3497
3498 3, /* CONF_HW_RXTX_RATE_18 */
3499 2, /* CONF_HW_RXTX_RATE_12 */
3500 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3501 1, /* CONF_HW_RXTX_RATE_9 */
3502 0, /* CONF_HW_RXTX_RATE_6 */
3503 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3504 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3505 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3506};
1ebec3d7
TP		 3507
3508static struct ieee80211_supported_band wl1271_band_5ghz = {
3509 .channels = wl1271_channels_5ghz,
3510 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3511 .bitrates = wl1271_rates_5ghz,
3512 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 3513 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 3514};
3515
a0ea9493 3516static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 3517 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3518 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3519};
3520
f5fc0f86
LC		 3521static const struct ieee80211_ops wl1271_ops = {
3522 .start = wl1271_op_start,
3523 .stop = wl1271_op_stop,
3524 .add_interface = wl1271_op_add_interface,
3525 .remove_interface = wl1271_op_remove_interface,
402e4861
EP		 3526 .suspend = wl1271_op_suspend,
3527 .resume = wl1271_op_resume,
f5fc0f86 3528 .config = wl1271_op_config,
c87dec9f 3529 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 3530 .configure_filter = wl1271_op_configure_filter,
3531 .tx = wl1271_op_tx,
3532 .set_key = wl1271_op_set_key,
3533 .hw_scan = wl1271_op_hw_scan,
33c2c06c
LC		 3534 .sched_scan_start = wl1271_op_sched_scan_start,
3535 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 3536 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 3537 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 3538 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 3539 .conf_tx = wl1271_op_conf_tx,
bbbb538e 3540 .get_tsf = wl1271_op_get_tsf,
ece550d0 3541 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 3542 .sta_add = wl1271_op_sta_add,
3543 .sta_remove = wl1271_op_sta_remove,
bbba3e68 3544 .ampdu_action = wl1271_op_ampdu_action,
33437893 3545 .tx_frames_pending = wl1271_tx_frames_pending,
c8c90873 3546 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 3547};
3548
f876bb9a 3549
6a2de93b 3550u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 3551{
3552 u8 idx;
3553
6a2de93b 3554 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 3555
3556 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3557 wl1271_error("Illegal RX rate from HW: %d", rate);
3558 return 0;
3559 }
3560
6a2de93b 3561 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 3562 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3563 wl1271_error("Unsupported RX rate from HW: %d", rate);
3564 return 0;
3565 }
3566
3567 return idx;
3568}
3569
7fc3a864
JO		 3570static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3571 struct device_attribute *attr,
3572 char *buf)
3573{
3574 struct wl1271 *wl = dev_get_drvdata(dev);
3575 ssize_t len;
3576
2f63b011 3577 len = PAGE_SIZE;
7fc3a864
JO		 3578
3579 mutex_lock(&wl->mutex);
3580 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3581 wl->sg_enabled);
3582 mutex_unlock(&wl->mutex);
3583
3584 return len;
3585
3586}
3587
3588static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3589 struct device_attribute *attr,
3590 const char *buf, size_t count)
3591{
3592 struct wl1271 *wl = dev_get_drvdata(dev);
3593 unsigned long res;
3594 int ret;
3595
6277ed65 3596 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 3597 if (ret < 0) {
3598 wl1271_warning("incorrect value written to bt_coex_mode");
3599 return count;
3600 }
3601
3602 mutex_lock(&wl->mutex);
3603
3604 res = !!res;
3605
3606 if (res == wl->sg_enabled)
3607 goto out;
3608
3609 wl->sg_enabled = res;
3610
3611 if (wl->state == WL1271_STATE_OFF)
3612 goto out;
3613
a620865e 3614 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 3615 if (ret < 0)
3616 goto out;
3617
3618 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3619 wl1271_ps_elp_sleep(wl);
3620
3621 out:
3622 mutex_unlock(&wl->mutex);
3623 return count;
3624}
3625
3626static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3627 wl1271_sysfs_show_bt_coex_state,
3628 wl1271_sysfs_store_bt_coex_state);
3629
d717fd61
JO		 3630static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3631 struct device_attribute *attr,
3632 char *buf)
3633{
3634 struct wl1271 *wl = dev_get_drvdata(dev);
3635 ssize_t len;
3636
2f63b011 3637 len = PAGE_SIZE;
d717fd61
JO		 3638
3639 mutex_lock(&wl->mutex);
3640 if (wl->hw_pg_ver >= 0)
3641 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3642 else
3643 len = snprintf(buf, len, "n/a\n");
3644 mutex_unlock(&wl->mutex);
3645
3646 return len;
3647}
3648
3649static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3650 wl1271_sysfs_show_hw_pg_ver, NULL);
3651
2d5e82b8 3652int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 3653{
3654 int ret;
3655
3656 if (wl->mac80211_registered)
3657 return 0;
3658
31d26ec6
AN		 3659 ret = wl1271_fetch_nvs(wl);
3660 if (ret == 0) {
bc765bf3
SL		 3661 /* NOTE: The wl->nvs->nvs element must be first, in
3662 * order to simplify the casting, we assume it is at
3663 * the beginning of the wl->nvs structure.
3664 */
3665 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 3666
3667 wl->mac_addr[0] = nvs_ptr[11];
3668 wl->mac_addr[1] = nvs_ptr[10];
3669 wl->mac_addr[2] = nvs_ptr[6];
3670 wl->mac_addr[3] = nvs_ptr[5];
3671 wl->mac_addr[4] = nvs_ptr[4];
3672 wl->mac_addr[5] = nvs_ptr[3];
3673 }
3674
f5fc0f86
LC		 3675 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3676
3677 ret = ieee80211_register_hw(wl->hw);
3678 if (ret < 0) {
3679 wl1271_error("unable to register mac80211 hw: %d", ret);
3680 return ret;
3681 }
3682
3683 wl->mac80211_registered = true;
3684
d60080ae
EP		 3685 wl1271_debugfs_init(wl);
3686
c2c192ac
JO		 3687 register_netdevice_notifier(&wl1271_dev_notifier);
3688
f5fc0f86
LC		 3689 wl1271_notice("loaded");
3690
3691 return 0;
3692}
50b3eb4b 3693EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 3694
3b56dd6a
TP		 3695void wl1271_unregister_hw(struct wl1271 *wl)
3696{
4ae3fa87
JO		 3697 if (wl->state == WL1271_STATE_PLT)
3698 __wl1271_plt_stop(wl);
3699
c2c192ac 3700 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 3701 ieee80211_unregister_hw(wl->hw);
3702 wl->mac80211_registered = false;
3703
3704}
3705EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3706
2d5e82b8 3707int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 3708{
7a55724e
JO		 3709 static const u32 cipher_suites[] = {
3710 WLAN_CIPHER_SUITE_WEP40,
3711 WLAN_CIPHER_SUITE_WEP104,
3712 WLAN_CIPHER_SUITE_TKIP,
3713 WLAN_CIPHER_SUITE_CCMP,
3714 WL1271_CIPHER_SUITE_GEM,
3715 };
3716
1e2b7976
JO		 3717 /* The tx descriptor buffer and the TKIP space. */
3718 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3719 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 3720
3721 /* unit us */
3722 /* FIXME: find a proper value */
3723 wl->hw->channel_change_time = 10000;
50c500ad 3724 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 3725
3726 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 3727 IEEE80211_HW_BEACON_FILTER |
0a34332f 3728 IEEE80211_HW_SUPPORTS_PS |
4695dc91 3729 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 3730 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 3731 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 3732 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 3733 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 3734 IEEE80211_HW_SPECTRUM_MGMT |
ba7c082a 3735 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 3736
7a55724e
JO		 3737 wl->hw->wiphy->cipher_suites = cipher_suites;
3738 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3739
e0d8bbf0 3740 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 3741 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 3742 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 3743 /*
3744 * Maximum length of elements in scanning probe request templates
3745 * should be the maximum length possible for a template, without
3746 * the IEEE80211 header of the template
3747 */
3748 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3749 sizeof(struct ieee80211_header);
a8aaaf53 3750
4a31c11c
LC		 3751 /* make sure all our channels fit in the scanned_ch bitmask */
3752 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3753 ARRAY_SIZE(wl1271_channels_5ghz) >
3754 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 3755 /*
3756 * We keep local copies of the band structs because we need to
3757 * modify them on a per-device basis.
3758 */
3759 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3760 sizeof(wl1271_band_2ghz));
3761 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3762 sizeof(wl1271_band_5ghz));
3763
3764 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3765 &wl->bands[IEEE80211_BAND_2GHZ];
3766 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3767 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 3768
12bd8949 3769 wl->hw->queues = 4;
31627dc5 3770 wl->hw->max_rates = 1;
12bd8949 3771
b7417d93
JO		 3772 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3773
8197b711 3774 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 3775
f84f7d78
AN		 3776 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3777
4c9cfa78
LC		 3778 wl->hw->max_rx_aggregation_subframes = 8;
3779
f5fc0f86
LC		 3780 return 0;
3781}
50b3eb4b 3782EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 3783
f5fc0f86 3784#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 3785
2d5e82b8 3786struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 3787{
f5fc0f86 3788 struct ieee80211_hw *hw;
3b56dd6a 3789 struct platform_device *plat_dev = NULL;
f5fc0f86 3790 struct wl1271 *wl;
a8c0ddb5 3791 int i, j, ret;
1f37cbc9 3792 unsigned int order;
f5fc0f86
LC		 3793
3794 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3795 if (!hw) {
3796 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 3797 ret = -ENOMEM;
3b56dd6a
TP		 3798 goto err_hw_alloc;
3799 }
3800
929ebd30 3801 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 3802 if (!plat_dev) {
3803 wl1271_error("could not allocate platform_device");
3804 ret = -ENOMEM;
3805 goto err_plat_alloc;
f5fc0f86
LC		 3806 }
3807
3808 wl = hw->priv;
3809 memset(wl, 0, sizeof(*wl));
3810
01c09162
JO		 3811 INIT_LIST_HEAD(&wl->list);
3812
f5fc0f86 3813 wl->hw = hw;
3b56dd6a 3814 wl->plat_dev = plat_dev;
f5fc0f86 3815
6742f554
JO		 3816 for (i = 0; i < NUM_TX_QUEUES; i++)
3817 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 3818
a8c0ddb5
AN		 3819 for (i = 0; i < NUM_TX_QUEUES; i++)
3820 for (j = 0; j < AP_MAX_LINKS; j++)
3821 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3822
a620865e
IY		 3823 skb_queue_head_init(&wl->deferred_rx_queue);
3824 skb_queue_head_init(&wl->deferred_tx_queue);
3825
37b70a81 3826 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 3827 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
a620865e 3828 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 3829 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3830 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3831 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 3832 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 3833 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 3834 wl->default_key = 0;
f5fc0f86 3835 wl->rx_counter = 0;
ae113b57
AN		 3836 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3837 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
19ad0715 3838 wl->psm_entry_retry = 0;
f5fc0f86 3839 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 3840 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 3841 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 3842 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 3843 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 3844 wl->vif = NULL;
830fb67b 3845 wl->flags = 0;
7fc3a864 3846 wl->sg_enabled = true;
d717fd61 3847 wl->hw_pg_ver = -1;
166d504e
AN		 3848 wl->bss_type = MAX_BSS_TYPE;
3849 wl->set_bss_type = MAX_BSS_TYPE;
3850 wl->fw_bss_type = MAX_BSS_TYPE;
a8c0ddb5 3851 wl->last_tx_hlid = 0;
b622d992
AN		 3852 wl->ap_ps_map = 0;
3853 wl->ap_fw_ps_map = 0;
606ea9fa 3854 wl->quirks = 0;
341b7cde 3855 wl->platform_quirks = 0;
33c2c06c 3856 wl->sched_scanning = false;
f5fc0f86 3857
25eeb9e3 3858 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 3859 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 3860 wl->tx_frames[i] = NULL;
3861
3862 spin_lock_init(&wl->wl_lock);
3863
f5fc0f86
LC		 3864 wl->state = WL1271_STATE_OFF;
3865 mutex_init(&wl->mutex);
3866
c332a4b8
TP		 3867 /* Apply default driver configuration. */
3868 wl1271_conf_init(wl);
3869
1f37cbc9
IY		 3870 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3871 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3872 if (!wl->aggr_buf) {
3873 ret = -ENOMEM;
3874 goto err_hw;
3875 }
3876
990f5de7
IY		 3877 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
3878 if (!wl->dummy_packet) {
3879 ret = -ENOMEM;
3880 goto err_aggr;
3881 }
3882
a1dd8187 3883 /* Register platform device */
3b56dd6a 3884 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 3885 if (ret) {
3886 wl1271_error("couldn't register platform device");
990f5de7 3887 goto err_dummy_packet;
a1dd8187 3888 }
3b56dd6a 3889 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 3890
7fc3a864 3891 /* Create sysfs file to control bt coex state */
3b56dd6a 3892 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 3893 if (ret < 0) {
3894 wl1271_error("failed to create sysfs file bt_coex_state");
3895 goto err_platform;
3896 }
a1dd8187 3897
d717fd61
JO		 3898 /* Create sysfs file to get HW PG version */
3899 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3900 if (ret < 0) {
3901 wl1271_error("failed to create sysfs file hw_pg_ver");
3902 goto err_bt_coex_state;
3903 }
3904
c332a4b8 3905 return hw;
a1dd8187 3906
d717fd61
JO		 3907err_bt_coex_state:
3908 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3909
7fc3a864 3910err_platform:
3b56dd6a 3911 platform_device_unregister(wl->plat_dev);
7fc3a864 3912
990f5de7
IY		 3913err_dummy_packet:
3914 dev_kfree_skb(wl->dummy_packet);
3915
1f37cbc9
IY		 3916err_aggr:
3917 free_pages((unsigned long)wl->aggr_buf, order);
3918
a1dd8187 3919err_hw:
3b56dd6a
TP		 3920 wl1271_debugfs_exit(wl);
3921 kfree(plat_dev);
3922
3923err_plat_alloc:
3924 ieee80211_free_hw(hw);
3925
3926err_hw_alloc:
a1dd8187 3927
a1dd8187 3928 return ERR_PTR(ret);
c332a4b8 3929}
50b3eb4b 3930EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 3931
3932int wl1271_free_hw(struct wl1271 *wl)
3933{
3b56dd6a 3934 platform_device_unregister(wl->plat_dev);
990f5de7 3935 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 3936 free_pages((unsigned long)wl->aggr_buf,
3937 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 3938 kfree(wl->plat_dev);
c332a4b8
TP		 3939
3940 wl1271_debugfs_exit(wl);
3941
c332a4b8
TP		 3942 vfree(wl->fw);
3943 wl->fw = NULL;
3944 kfree(wl->nvs);
3945 wl->nvs = NULL;
3946
3947 kfree(wl->fw_status);
3948 kfree(wl->tx_res_if);
3949
3950 ieee80211_free_hw(wl->hw);
3951
3952 return 0;
3953}
50b3eb4b
TP		 3954EXPORT_SYMBOL_GPL(wl1271_free_hw);
3955
491bbd6b 3956u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 3957EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 3958module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 3959MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
3960
50b3eb4b 3961MODULE_LICENSE("GPL");
b1a48cab 3962MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 3963MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)