projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: prevent scheduling while suspending (WoW enabled)
[deliverable/linux.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;
f44e5868
EP		 1359 if (wl->wow_enabled) {
1360 /* flush any remaining work */
1361 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1362 flush_delayed_work(&wl->scan_complete_work);
1363
1364 /*
1365 * disable and re-enable interrupts in order to flush
1366 * the threaded_irq
1367 */
1368 wl1271_disable_interrupts(wl);
1369
1370 /*
1371 * set suspended flag to avoid triggering a new threaded_irq
1372 * work. no need for spinlock as interrupts are disabled.
1373 */
1374 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1375
1376 wl1271_enable_interrupts(wl);
1377 flush_work(&wl->tx_work);
1378 flush_delayed_work(&wl->pspoll_work);
1379 flush_delayed_work(&wl->elp_work);
1380 }
402e4861
EP		 1381 return 0;
1382}
1383
1384static int wl1271_op_resume(struct ieee80211_hw *hw)
1385{
1386 struct wl1271 *wl = hw->priv;
1387 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1388 wl->wow_enabled);
f44e5868
EP		 1389
1390 /*
1391 * re-enable irq_work enqueuing, and call irq_work directly if
1392 * there is a pending work.
1393 */
1394 if (wl->wow_enabled) {
1395 struct wl1271 *wl = hw->priv;
1396 unsigned long flags;
1397 bool run_irq_work = false;
1398
1399 spin_lock_irqsave(&wl->wl_lock, flags);
1400 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1401 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1402 run_irq_work = true;
1403 spin_unlock_irqrestore(&wl->wl_lock, flags);
1404
1405 if (run_irq_work) {
1406 wl1271_debug(DEBUG_MAC80211,
1407 "run postponed irq_work directly");
1408 wl1271_irq(0, wl);
1409 wl1271_enable_interrupts(wl);
1410 }
1411 }
1412
402e4861
EP		 1413 return 0;
1414}
1415
f5fc0f86 1416static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1417{
1418 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1419
1420 /*
1421 * We have to delay the booting of the hardware because
1422 * we need to know the local MAC address before downloading and
1423 * initializing the firmware. The MAC address cannot be changed
1424 * after boot, and without the proper MAC address, the firmware
1425 * will not function properly.
1426 *
1427 * The MAC address is first known when the corresponding interface
1428 * is added. That is where we will initialize the hardware.
166d504e
AN		 1429 *
1430 * In addition, we currently have different firmwares for AP and managed
1431 * operation. We will know which to boot according to interface type.
1b72aecd
JO		 1432 */
1433
1434 return 0;
1435}
1436
1437static void wl1271_op_stop(struct ieee80211_hw *hw)
1438{
1439 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1440}
1441
1442static int wl1271_op_add_interface(struct ieee80211_hw *hw,
1443 struct ieee80211_vif *vif)
f5fc0f86
LC		 1444{
1445 struct wl1271 *wl = hw->priv;
ac01e948 1446 struct wiphy *wiphy = hw->wiphy;
9ccd9217 1447 int retries = WL1271_BOOT_RETRIES;
f5fc0f86 1448 int ret = 0;
71125abd 1449 bool booted = false;
f5fc0f86 1450
1b72aecd
JO		 1451 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
1452 vif->type, vif->addr);
f5fc0f86
LC		 1453
1454 mutex_lock(&wl->mutex);
1b72aecd 1455 if (wl->vif) {
71125abd
EP		 1456 wl1271_debug(DEBUG_MAC80211,
1457 "multiple vifs are not supported yet");
1b72aecd
JO		 1458 ret = -EBUSY;
1459 goto out;
1460 }
1461
13026dec
JO		 1462 /*
1463 * in some very corner case HW recovery scenarios its possible to
1464 * get here before __wl1271_op_remove_interface is complete, so
1465 * opt out if that is the case.
1466 */
1467 if (test_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags)) {
1468 ret = -EBUSY;
1469 goto out;
1470 }
1471
1b72aecd
JO		 1472 switch (vif->type) {
1473 case NL80211_IFTYPE_STATION:
1474 wl->bss_type = BSS_TYPE_STA_BSS;
5da11dcd 1475 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd
JO		 1476 break;
1477 case NL80211_IFTYPE_ADHOC:
1478 wl->bss_type = BSS_TYPE_IBSS;
5da11dcd 1479 wl->set_bss_type = BSS_TYPE_STA_BSS;
1b72aecd 1480 break;
038d925b
AN		 1481 case NL80211_IFTYPE_AP:
1482 wl->bss_type = BSS_TYPE_AP_BSS;
1483 break;
1b72aecd
JO		 1484 default:
1485 ret = -EOPNOTSUPP;
1486 goto out;
1487 }
1488
1489 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
f5fc0f86
LC		 1490
1491 if (wl->state != WL1271_STATE_OFF) {
1492 wl1271_error("cannot start because not in off state: %d",
1493 wl->state);
1494 ret = -EBUSY;
1495 goto out;
1496 }
1497
9ccd9217
JO		 1498 while (retries) {
1499 retries--;
1500 ret = wl1271_chip_wakeup(wl);
1501 if (ret < 0)
1502 goto power_off;
f5fc0f86 1503
9ccd9217
JO		 1504 ret = wl1271_boot(wl);
1505 if (ret < 0)
1506 goto power_off;
f5fc0f86 1507
9ccd9217
JO		 1508 ret = wl1271_hw_init(wl);
1509 if (ret < 0)
1510 goto irq_disable;
f5fc0f86 1511
71125abd
EP		 1512 booted = true;
1513 break;
eb5b28d0 1514
9ccd9217 1515irq_disable:
9ccd9217
JO		 1516 mutex_unlock(&wl->mutex);
1517 /* Unlocking the mutex in the middle of handling is
1518 inherently unsafe. In this case we deem it safe to do,
1519 because we need to let any possibly pending IRQ out of
1520 the system (and while we are WL1271_STATE_OFF the IRQ
1521 work function will not do anything.) Also, any other
1522 possible concurrent operations will fail due to the
1523 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 1524 wl1271_disable_interrupts(wl);
1525 wl1271_flush_deferred_work(wl);
1526 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 1527 mutex_lock(&wl->mutex);
1528power_off:
1529 wl1271_power_off(wl);
1530 }
eb5b28d0 1531
71125abd
EP		 1532 if (!booted) {
1533 wl1271_error("firmware boot failed despite %d retries",
1534 WL1271_BOOT_RETRIES);
1535 goto out;
1536 }
1537
1538 wl->vif = vif;
1539 wl->state = WL1271_STATE_ON;
13026dec 1540 set_bit(WL1271_FLAG_IF_INITIALIZED, &wl->flags);
4b7fac77 1541 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 1542
1543 /* update hw/fw version info in wiphy struct */
1544 wiphy->hw_version = wl->chip.id;
4b7fac77 1545 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 1546 sizeof(wiphy->fw_version));
1547
e7ddf549
LC		 1548 /* Check if any quirks are needed with older fw versions */
1549 wl->quirks |= wl1271_get_fw_ver_quirks(wl);
1550
fb6a6819
LC		 1551 /*
1552 * Now we know if 11a is supported (info from the NVS), so disable
1553 * 11a channels if not supported
1554 */
1555 if (!wl->enable_11a)
1556 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
1557
1558 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
1559 wl->enable_11a ? "" : "not ");
1560
eb5b28d0 1561out:
f5fc0f86
LC		 1562 mutex_unlock(&wl->mutex);
1563
f9f774c1 1564 mutex_lock(&wl_list_mutex);
eb887dfd 1565 if (!ret)
01c09162 1566 list_add(&wl->list, &wl_list);
f9f774c1 1567 mutex_unlock(&wl_list_mutex);
01c09162 1568
f5fc0f86
LC		 1569 return ret;
1570}
1571
7dece1c8
AN		 1572static void __wl1271_op_remove_interface(struct wl1271 *wl,
1573 bool reset_tx_queues)
f5fc0f86 1574{
f5fc0f86
LC		 1575 int i;
1576
1b72aecd 1577 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 1578
13026dec
JO		 1579 /* because of hardware recovery, we may get here twice */
1580 if (wl->state != WL1271_STATE_ON)
1581 return;
1582
1b72aecd 1583 wl1271_info("down");
f5fc0f86 1584
f9f774c1 1585 mutex_lock(&wl_list_mutex);
01c09162 1586 list_del(&wl->list);
f9f774c1 1587 mutex_unlock(&wl_list_mutex);
01c09162 1588
8d2ef7bd 1589 /* enable dyn ps just in case (if left on due to fw crash etc) */
9a547bf9 1590 if (wl->bss_type == BSS_TYPE_STA_BSS)
f532be6d 1591 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 1592
08688d6b 1593 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
08688d6b 1594 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 1595 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
b739a42c 1596 wl->scan.req = NULL;
76a029fb 1597 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 1598 }
1599
13026dec
JO		 1600 /*
1601 * this must be before the cancel_work calls below, so that the work
1602 * functions don't perform further work.
1603 */
f5fc0f86
LC		 1604 wl->state = WL1271_STATE_OFF;
1605
f5fc0f86
LC		 1606 mutex_unlock(&wl->mutex);
1607
a620865e
IY		 1608 wl1271_disable_interrupts(wl);
1609 wl1271_flush_deferred_work(wl);
78abd320 1610 cancel_delayed_work_sync(&wl->scan_complete_work);
a620865e 1611 cancel_work_sync(&wl->netstack_work);
f5fc0f86 1612 cancel_work_sync(&wl->tx_work);
90494a90 1613 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1614 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1615
1616 mutex_lock(&wl->mutex);
1617
1618 /* let's notify MAC80211 about the remaining pending TX frames */
7dece1c8 1619 wl1271_tx_reset(wl, reset_tx_queues);
f5fc0f86
LC		 1620 wl1271_power_off(wl);
1621
1622 memset(wl->bssid, 0, ETH_ALEN);
1623 memset(wl->ssid, 0, IW_ESSID_MAX_SIZE + 1);
1624 wl->ssid_len = 0;
f5fc0f86 1625 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 1626 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 1627 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 1628
1629 wl->rx_counter = 0;
19ad0715 1630 wl->psm_entry_retry = 0;
f5fc0f86
LC		 1631 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1632 wl->tx_blocks_available = 0;
d2f4d47d 1633 wl->tx_allocated_blocks = 0;
f5fc0f86
LC		 1634 wl->tx_results_count = 0;
1635 wl->tx_packets_count = 0;
ac4e4ce5 1636 wl->tx_security_last_seq = 0;
04e36fc5 1637 wl->tx_security_seq = 0;
f5fc0f86
LC		 1638 wl->time_offset = 0;
1639 wl->session_counter = 0;
830fb67b 1640 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1b72aecd 1641 wl->vif = NULL;
14b228a0 1642 wl->filters = 0;
7f179b46 1643 wl1271_free_ap_keys(wl);
f84f7d78 1644 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
b622d992
AN		 1645 wl->ap_fw_ps_map = 0;
1646 wl->ap_ps_map = 0;
33c2c06c 1647 wl->sched_scanning = false;
d6e19d13 1648
13026dec
JO		 1649 /*
1650 * this is performed after the cancel_work calls and the associated
1651 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1652 * get executed before all these vars have been reset.
1653 */
1654 wl->flags = 0;
1655
f5fc0f86
LC		 1656 for (i = 0; i < NUM_TX_QUEUES; i++)
1657 wl->tx_blocks_freed[i] = 0;
1658
1659 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 1660
1661 kfree(wl->fw_status);
1662 wl->fw_status = NULL;
1663 kfree(wl->tx_res_if);
1664 wl->tx_res_if = NULL;
1665 kfree(wl->target_mem_map);
1666 wl->target_mem_map = NULL;
52a2a375 1667}
bd9dc49c 1668
52a2a375
JO		 1669static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
1670 struct ieee80211_vif *vif)
1671{
1672 struct wl1271 *wl = hw->priv;
1673
1674 mutex_lock(&wl->mutex);
67353299
JO		 1675 /*
1676 * wl->vif can be null here if someone shuts down the interface
1677 * just when hardware recovery has been started.
1678 */
1679 if (wl->vif) {
1680 WARN_ON(wl->vif != vif);
7dece1c8 1681 __wl1271_op_remove_interface(wl, true);
67353299 1682 }
52b0e7a6 1683
67353299 1684 mutex_unlock(&wl->mutex);
52b0e7a6 1685 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 1686}
1687
c5745187 1688void wl1271_configure_filters(struct wl1271 *wl, unsigned int filters)
14b228a0 1689{
ae113b57 1690 wl1271_set_default_filters(wl);
14b228a0
JO		 1691
1692 /* combine requested filters with current filter config */
1693 filters = wl->filters | filters;
1694
1695 wl1271_debug(DEBUG_FILTERS, "RX filters set: ");
1696
1697 if (filters & FIF_PROMISC_IN_BSS) {
1698 wl1271_debug(DEBUG_FILTERS, " - FIF_PROMISC_IN_BSS");
1699 wl->rx_config &= ~CFG_UNI_FILTER_EN;
1700 wl->rx_config |= CFG_BSSID_FILTER_EN;
1701 }
1702 if (filters & FIF_BCN_PRBRESP_PROMISC) {
1703 wl1271_debug(DEBUG_FILTERS, " - FIF_BCN_PRBRESP_PROMISC");
1704 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1705 wl->rx_config &= ~CFG_SSID_FILTER_EN;
1706 }
1707 if (filters & FIF_OTHER_BSS) {
1708 wl1271_debug(DEBUG_FILTERS, " - FIF_OTHER_BSS");
1709 wl->rx_config &= ~CFG_BSSID_FILTER_EN;
1710 }
1711 if (filters & FIF_CONTROL) {
1712 wl1271_debug(DEBUG_FILTERS, " - FIF_CONTROL");
1713 wl->rx_filter |= CFG_RX_CTL_EN;
1714 }
1715 if (filters & FIF_FCSFAIL) {
1716 wl1271_debug(DEBUG_FILTERS, " - FIF_FCSFAIL");
1717 wl->rx_filter |= CFG_RX_FCS_ERROR;
1718 }
1719}
1720
82429d32 1721static int wl1271_dummy_join(struct wl1271 *wl)
c7f43e45 1722{
e0d8bbf0 1723 int ret = 0;
c7f43e45
LC		 1724 /* we need to use a dummy BSSID for now */
1725 static const u8 dummy_bssid[ETH_ALEN] = { 0x0b, 0xad, 0xde,
1726 0xad, 0xbe, 0xef };
1727
c7f43e45
LC		 1728 memcpy(wl->bssid, dummy_bssid, ETH_ALEN);
1729
14b228a0
JO		 1730 /* pass through frames from all BSS */
1731 wl1271_configure_filters(wl, FIF_OTHER_BSS);
1732
5da11dcd 1733 ret = wl1271_cmd_join(wl, wl->set_bss_type);
c7f43e45
LC		 1734 if (ret < 0)
1735 goto out;
1736
71449f8d 1737 set_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45
LC		 1738
1739out:
1740 return ret;
1741}
1742
69e5434c 1743static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 1744{
1745 int ret;
1746
69e5434c
JO		 1747 /*
1748 * One of the side effects of the JOIN command is that is clears
1749 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
1750 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 1751 * Currently the only valid scenario for JOIN during association
1752 * is on roaming, in which case we will also be given new keys.
1753 * Keep the below message for now, unless it starts bothering
1754 * users who really like to roam a lot :)
69e5434c
JO		 1755 */
1756 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1757 wl1271_info("JOIN while associated.");
1758
1759 if (set_assoc)
1760 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
1761
82429d32
JO		 1762 ret = wl1271_cmd_join(wl, wl->set_bss_type);
1763 if (ret < 0)
1764 goto out;
1765
1766 set_bit(WL1271_FLAG_JOINED, &wl->flags);
1767
1768 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1769 goto out;
1770
1771 /*
1772 * The join command disable the keep-alive mode, shut down its process,
1773 * and also clear the template config, so we need to reset it all after
1774 * the join. The acx_aid starts the keep-alive process, and the order
1775 * of the commands below is relevant.
1776 */
1777 ret = wl1271_acx_keep_alive_mode(wl, true);
1778 if (ret < 0)
1779 goto out;
1780
1781 ret = wl1271_acx_aid(wl, wl->aid);
1782 if (ret < 0)
1783 goto out;
1784
1785 ret = wl1271_cmd_build_klv_null_data(wl);
1786 if (ret < 0)
1787 goto out;
1788
1789 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1790 ACX_KEEP_ALIVE_TPL_VALID);
1791 if (ret < 0)
1792 goto out;
1793
1794out:
1795 return ret;
1796}
1797
1798static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 1799{
1800 int ret;
1801
1802 /* to stop listening to a channel, we disconnect */
1803 ret = wl1271_cmd_disconnect(wl);
1804 if (ret < 0)
1805 goto out;
1806
71449f8d 1807 clear_bit(WL1271_FLAG_JOINED, &wl->flags);
c7f43e45 1808 memset(wl->bssid, 0, ETH_ALEN);
14b228a0 1809
c5745187 1810 /* stop filtering packets based on bssid */
14b228a0 1811 wl1271_configure_filters(wl, FIF_OTHER_BSS);
c7f43e45
LC		 1812
1813out:
1814 return ret;
1815}
1816
ebba60c6
JO		 1817static void wl1271_set_band_rate(struct wl1271 *wl)
1818{
1819 if (wl->band == IEEE80211_BAND_2GHZ)
1820 wl->basic_rate_set = wl->conf.tx.basic_rate;
1821 else
1822 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
1823}
1824
bee0ffec 1825static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 1826{
1827 int ret;
1828
1829 if (idle) {
1830 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1831 ret = wl1271_unjoin(wl);
1832 if (ret < 0)
1833 goto out;
1834 }
e0fe371b 1835 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 1836 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 1837 if (ret < 0)
1838 goto out;
1839 ret = wl1271_acx_keep_alive_config(
1840 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
1841 ACX_KEEP_ALIVE_TPL_INVALID);
1842 if (ret < 0)
1843 goto out;
1844 set_bit(WL1271_FLAG_IDLE, &wl->flags);
1845 } else {
1846 /* increment the session counter */
1847 wl->session_counter++;
1848 if (wl->session_counter >= SESSION_COUNTER_MAX)
1849 wl->session_counter = 0;
33c2c06c
LC		 1850
1851 /* The current firmware only supports sched_scan in idle */
1852 if (wl->sched_scanning) {
1853 wl1271_scan_sched_scan_stop(wl);
1854 ieee80211_sched_scan_stopped(wl->hw);
1855 }
1856
0d58cbff
JO		 1857 ret = wl1271_dummy_join(wl);
1858 if (ret < 0)
1859 goto out;
1860 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
1861 }
1862
1863out:
1864 return ret;
1865}
1866
f5fc0f86
LC		 1867static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
1868{
1869 struct wl1271 *wl = hw->priv;
1870 struct ieee80211_conf *conf = &hw->conf;
1871 int channel, ret = 0;
bee0ffec 1872 bool is_ap;
f5fc0f86
LC		 1873
1874 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
1875
bee0ffec
AN		 1876 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
1877 " changed 0x%x",
f5fc0f86
LC		 1878 channel,
1879 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 1880 conf->power_level,
bee0ffec
AN		 1881 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
1882 changed);
f5fc0f86 1883
781608c4
JO		 1884 /*
1885 * mac80211 will go to idle nearly immediately after transmitting some
1886 * frames, such as the deauth. To make sure those frames reach the air,
1887 * wait here until the TX queue is fully flushed.
1888 */
1889 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
1890 (conf->flags & IEEE80211_CONF_IDLE))
1891 wl1271_tx_flush(wl);
1892
f5fc0f86
LC		 1893 mutex_lock(&wl->mutex);
1894
f8d9802f 1895 if (unlikely(wl->state == WL1271_STATE_OFF)) {
17e672d6
AN		 1896 /* we support configuring the channel and band while off */
1897 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
1898 wl->band = conf->channel->band;
1899 wl->channel = channel;
1900 }
1901
2c10bb9c 1902 goto out;
f8d9802f 1903 }
8a5a37a6 1904
bee0ffec
AN		 1905 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
1906
a620865e 1907 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 1908 if (ret < 0)
1909 goto out;
1910
ebba60c6 1911 /* if the channel changes while joined, join again */
69e5434c
JO		 1912 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1913 ((wl->band != conf->channel->band) ||
1914 (wl->channel != channel))) {
ebba60c6
JO		 1915 wl->band = conf->channel->band;
1916 wl->channel = channel;
1917
bee0ffec
AN		 1918 if (!is_ap) {
1919 /*
1920 * FIXME: the mac80211 should really provide a fixed
1921 * rate to use here. for now, just use the smallest
1922 * possible rate for the band as a fixed rate for
1923 * association frames and other control messages.
1924 */
1925 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
1926 wl1271_set_band_rate(wl);
1927
1928 wl->basic_rate = wl1271_tx_min_rate_get(wl);
1929 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 1930 if (ret < 0)
bee0ffec 1931 wl1271_warning("rate policy for channel "
ebba60c6 1932 "failed %d", ret);
bee0ffec
AN		 1933
1934 if (test_bit(WL1271_FLAG_JOINED, &wl->flags)) {
1935 ret = wl1271_join(wl, false);
1936 if (ret < 0)
1937 wl1271_warning("cmd join on channel "
1938 "failed %d", ret);
1939 }
ebba60c6
JO		 1940 }
1941 }
1942
bee0ffec
AN		 1943 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
1944 ret = wl1271_sta_handle_idle(wl,
1945 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 1946 if (ret < 0)
1947 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 1948 }
1949
90494a90
JO		 1950 /*
1951 * if mac80211 changes the PSM mode, make sure the mode is not
1952 * incorrectly changed after the pspoll failure active window.
1953 */
1954 if (changed & IEEE80211_CONF_CHANGE_PS)
1955 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
1956
71449f8d
JO		 1957 if (conf->flags & IEEE80211_CONF_PS &&
1958 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
1959 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 1960
1961 /*
1962 * We enter PSM only if we're already associated.
1963 * If we're not, we'll enter it when joining an SSID,
1964 * through the bss_info_changed() hook.
1965 */
830fb67b 1966 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 1967 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 1968 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 1969 wl->basic_rate, true);
af5e084b 1970 }
f5fc0f86 1971 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 1972 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 1973 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 1974
71449f8d 1975 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 1976
71449f8d 1977 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 1978 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 1979 wl->basic_rate, true);
f5fc0f86
LC		 1980 }
1981
1982 if (conf->power_level != wl->power_level) {
1983 ret = wl1271_acx_tx_power(wl, conf->power_level);
1984 if (ret < 0)
c6317a54 1985 goto out_sleep;
f5fc0f86
LC		 1986
1987 wl->power_level = conf->power_level;
1988 }
1989
1990out_sleep:
1991 wl1271_ps_elp_sleep(wl);
1992
1993out:
1994 mutex_unlock(&wl->mutex);
1995
1996 return ret;
1997}
1998
b54853f1
JO		 1999struct wl1271_filter_params {
2000 bool enabled;
2001 int mc_list_length;
2002 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2003};
2004
22bedad3
JP		 2005static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2006 struct netdev_hw_addr_list *mc_list)
c87dec9f 2007{
c87dec9f 2008 struct wl1271_filter_params *fp;
22bedad3 2009 struct netdev_hw_addr *ha;
2c10bb9c 2010 struct wl1271 *wl = hw->priv;
c87dec9f 2011
2c10bb9c
SD		 2012 if (unlikely(wl->state == WL1271_STATE_OFF))
2013 return 0;
c87dec9f 2014
74441130 2015 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 2016 if (!fp) {
2017 wl1271_error("Out of memory setting filters.");
2018 return 0;
2019 }
2020
2021 /* update multicast filtering parameters */
c87dec9f 2022 fp->mc_list_length = 0;
22bedad3
JP		 2023 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2024 fp->enabled = false;
2025 } else {
2026 fp->enabled = true;
2027 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 2028 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 2029 ha->addr, ETH_ALEN);
c87dec9f 2030 fp->mc_list_length++;
22bedad3 2031 }
c87dec9f
JO		 2032 }
2033
b54853f1 2034 return (u64)(unsigned long)fp;
c87dec9f 2035}
f5fc0f86 2036
b54853f1
JO		 2037#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2038 FIF_ALLMULTI | \
2039 FIF_FCSFAIL | \
2040 FIF_BCN_PRBRESP_PROMISC | \
2041 FIF_CONTROL | \
2042 FIF_OTHER_BSS)
2043
f5fc0f86
LC		 2044static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2045 unsigned int changed,
c87dec9f 2046 unsigned int *total, u64 multicast)
f5fc0f86 2047{
b54853f1 2048 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2049 struct wl1271 *wl = hw->priv;
b54853f1 2050 int ret;
f5fc0f86 2051
7d057869
AN		 2052 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2053 " total %x", changed, *total);
f5fc0f86 2054
b54853f1
JO		 2055 mutex_lock(&wl->mutex);
2056
2c10bb9c
SD		 2057 *total &= WL1271_SUPPORTED_FILTERS;
2058 changed &= WL1271_SUPPORTED_FILTERS;
2059
2060 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2061 goto out;
2062
a620865e 2063 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2064 if (ret < 0)
2065 goto out;
2066
7d057869
AN		 2067 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2068 if (*total & FIF_ALLMULTI)
2069 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2070 else if (fp)
2071 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2072 fp->mc_list,
2073 fp->mc_list_length);
2074 if (ret < 0)
2075 goto out_sleep;
2076 }
f5fc0f86 2077
b54853f1
JO		 2078 /* determine, whether supported filter values have changed */
2079 if (changed == 0)
2080 goto out_sleep;
c87dec9f 2081
14b228a0
JO		 2082 /* configure filters */
2083 wl->filters = *total;
2084 wl1271_configure_filters(wl, 0);
2085
b54853f1
JO		 2086 /* apply configured filters */
2087 ret = wl1271_acx_rx_config(wl, wl->rx_config, wl->rx_filter);
2088 if (ret < 0)
2089 goto out_sleep;
2090
2091out_sleep:
2092 wl1271_ps_elp_sleep(wl);
2093
2094out:
2095 mutex_unlock(&wl->mutex);
14b228a0 2096 kfree(fp);
f5fc0f86
LC		 2097}
2098
7f179b46
AN		 2099static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2100 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2101 u16 tx_seq_16)
2102{
2103 struct wl1271_ap_key *ap_key;
2104 int i;
2105
2106 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2107
2108 if (key_size > MAX_KEY_SIZE)
2109 return -EINVAL;
2110
2111 /*
2112 * Find next free entry in ap_keys. Also check we are not replacing
2113 * an existing key.
2114 */
2115 for (i = 0; i < MAX_NUM_KEYS; i++) {
2116 if (wl->recorded_ap_keys[i] == NULL)
2117 break;
2118
2119 if (wl->recorded_ap_keys[i]->id == id) {
2120 wl1271_warning("trying to record key replacement");
2121 return -EINVAL;
2122 }
2123 }
2124
2125 if (i == MAX_NUM_KEYS)
2126 return -EBUSY;
2127
2128 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2129 if (!ap_key)
2130 return -ENOMEM;
2131
2132 ap_key->id = id;
2133 ap_key->key_type = key_type;
2134 ap_key->key_size = key_size;
2135 memcpy(ap_key->key, key, key_size);
2136 ap_key->hlid = hlid;
2137 ap_key->tx_seq_32 = tx_seq_32;
2138 ap_key->tx_seq_16 = tx_seq_16;
2139
2140 wl->recorded_ap_keys[i] = ap_key;
2141 return 0;
2142}
2143
2144static void wl1271_free_ap_keys(struct wl1271 *wl)
2145{
2146 int i;
2147
2148 for (i = 0; i < MAX_NUM_KEYS; i++) {
2149 kfree(wl->recorded_ap_keys[i]);
2150 wl->recorded_ap_keys[i] = NULL;
2151 }
2152}
2153
2154static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2155{
2156 int i, ret = 0;
2157 struct wl1271_ap_key *key;
2158 bool wep_key_added = false;
2159
2160 for (i = 0; i < MAX_NUM_KEYS; i++) {
2161 if (wl->recorded_ap_keys[i] == NULL)
2162 break;
2163
2164 key = wl->recorded_ap_keys[i];
2165 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2166 key->id, key->key_type,
2167 key->key_size, key->key,
2168 key->hlid, key->tx_seq_32,
2169 key->tx_seq_16);
2170 if (ret < 0)
2171 goto out;
2172
2173 if (key->key_type == KEY_WEP)
2174 wep_key_added = true;
2175 }
2176
2177 if (wep_key_added) {
2178 ret = wl1271_cmd_set_ap_default_wep_key(wl, wl->default_key);
2179 if (ret < 0)
2180 goto out;
2181 }
2182
2183out:
2184 wl1271_free_ap_keys(wl);
2185 return ret;
2186}
2187
2188static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2189 u8 key_size, const u8 *key, u32 tx_seq_32,
2190 u16 tx_seq_16, struct ieee80211_sta *sta)
2191{
2192 int ret;
2193 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2194
2195 if (is_ap) {
2196 struct wl1271_station *wl_sta;
2197 u8 hlid;
2198
2199 if (sta) {
2200 wl_sta = (struct wl1271_station *)sta->drv_priv;
2201 hlid = wl_sta->hlid;
2202 } else {
2203 hlid = WL1271_AP_BROADCAST_HLID;
2204 }
2205
2206 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2207 /*
2208 * We do not support removing keys after AP shutdown.
2209 * Pretend we do to make mac80211 happy.
2210 */
2211 if (action != KEY_ADD_OR_REPLACE)
2212 return 0;
2213
2214 ret = wl1271_record_ap_key(wl, id,
2215 key_type, key_size,
2216 key, hlid, tx_seq_32,
2217 tx_seq_16);
2218 } else {
2219 ret = wl1271_cmd_set_ap_key(wl, action,
2220 id, key_type, key_size,
2221 key, hlid, tx_seq_32,
2222 tx_seq_16);
2223 }
2224
2225 if (ret < 0)
2226 return ret;
2227 } else {
2228 const u8 *addr;
2229 static const u8 bcast_addr[ETH_ALEN] = {
2230 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2231 };
2232
2233 addr = sta ? sta->addr : bcast_addr;
2234
2235 if (is_zero_ether_addr(addr)) {
2236 /* We dont support TX only encryption */
2237 return -EOPNOTSUPP;
2238 }
2239
2240 /* The wl1271 does not allow to remove unicast keys - they
2241 will be cleared automatically on next CMD_JOIN. Ignore the
2242 request silently, as we dont want the mac80211 to emit
2243 an error message. */
2244 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2245 return 0;
2246
2247 ret = wl1271_cmd_set_sta_key(wl, action,
2248 id, key_type, key_size,
2249 key, addr, tx_seq_32,
2250 tx_seq_16);
2251 if (ret < 0)
2252 return ret;
2253
2254 /* the default WEP key needs to be configured at least once */
2255 if (key_type == KEY_WEP) {
2256 ret = wl1271_cmd_set_sta_default_wep_key(wl,
2257 wl->default_key);
2258 if (ret < 0)
2259 return ret;
2260 }
2261 }
2262
2263 return 0;
2264}
2265
f5fc0f86
LC		 2266static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2267 struct ieee80211_vif *vif,
2268 struct ieee80211_sta *sta,
2269 struct ieee80211_key_conf *key_conf)
2270{
2271 struct wl1271 *wl = hw->priv;
f5fc0f86 2272 int ret;
ac4e4ce5
JO		 2273 u32 tx_seq_32 = 0;
2274 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2275 u8 key_type;
2276
f5fc0f86
LC		 2277 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2278
7f179b46 2279 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2280 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2281 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2282 key_conf->keylen, key_conf->flags);
2283 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2284
f5fc0f86
LC		 2285 mutex_lock(&wl->mutex);
2286
f8d9802f
JO		 2287 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2288 ret = -EAGAIN;
2289 goto out_unlock;
2290 }
2291
a620865e 2292 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2293 if (ret < 0)
2294 goto out_unlock;
2295
97359d12
JB		 2296 switch (key_conf->cipher) {
2297 case WLAN_CIPHER_SUITE_WEP40:
2298 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2299 key_type = KEY_WEP;
2300
2301 key_conf->hw_key_idx = key_conf->keyidx;
2302 break;
97359d12 2303 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2304 key_type = KEY_TKIP;
2305
2306 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 2307 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2308 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2309 break;
97359d12 2310 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 2311 key_type = KEY_AES;
2312
2313 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 2314 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2315 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2316 break;
7a55724e
JO		 2317 case WL1271_CIPHER_SUITE_GEM:
2318 key_type = KEY_GEM;
2319 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2320 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2321 break;
f5fc0f86 2322 default:
97359d12 2323 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 2324
2325 ret = -EOPNOTSUPP;
2326 goto out_sleep;
2327 }
2328
2329 switch (cmd) {
2330 case SET_KEY:
7f179b46
AN		 2331 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2332 key_conf->keyidx, key_type,
2333 key_conf->keylen, key_conf->key,
2334 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 2335 if (ret < 0) {
2336 wl1271_error("Could not add or replace key");
2337 goto out_sleep;
2338 }
2339 break;
2340
2341 case DISABLE_KEY:
7f179b46
AN		 2342 ret = wl1271_set_key(wl, KEY_REMOVE,
2343 key_conf->keyidx, key_type,
2344 key_conf->keylen, key_conf->key,
2345 0, 0, sta);
f5fc0f86
LC		 2346 if (ret < 0) {
2347 wl1271_error("Could not remove key");
2348 goto out_sleep;
2349 }
2350 break;
2351
2352 default:
2353 wl1271_error("Unsupported key cmd 0x%x", cmd);
2354 ret = -EOPNOTSUPP;
f5fc0f86
LC		 2355 break;
2356 }
2357
2358out_sleep:
2359 wl1271_ps_elp_sleep(wl);
2360
2361out_unlock:
2362 mutex_unlock(&wl->mutex);
2363
f5fc0f86
LC		 2364 return ret;
2365}
2366
2367static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 2368 struct ieee80211_vif *vif,
f5fc0f86
LC		 2369 struct cfg80211_scan_request *req)
2370{
2371 struct wl1271 *wl = hw->priv;
2372 int ret;
2373 u8 *ssid = NULL;
abb0b3bf 2374 size_t len = 0;
f5fc0f86
LC		 2375
2376 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2377
2378 if (req->n_ssids) {
2379 ssid = req->ssids[0].ssid;
abb0b3bf 2380 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 2381 }
2382
2383 mutex_lock(&wl->mutex);
2384
b739a42c
JO		 2385 if (wl->state == WL1271_STATE_OFF) {
2386 /*
2387 * We cannot return -EBUSY here because cfg80211 will expect
2388 * a call to ieee80211_scan_completed if we do - in this case
2389 * there won't be any call.
2390 */
2391 ret = -EAGAIN;
2392 goto out;
2393 }
2394
a620865e 2395 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2396 if (ret < 0)
2397 goto out;
2398
5924f89d 2399 ret = wl1271_scan(hw->priv, ssid, len, req);
f5fc0f86
LC		 2400
2401 wl1271_ps_elp_sleep(wl);
2402
2403out:
2404 mutex_unlock(&wl->mutex);
2405
2406 return ret;
2407}
2408
33c2c06c
LC		 2409static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2410 struct ieee80211_vif *vif,
2411 struct cfg80211_sched_scan_request *req,
2412 struct ieee80211_sched_scan_ies *ies)
2413{
2414 struct wl1271 *wl = hw->priv;
2415 int ret;
2416
2417 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2418
2419 mutex_lock(&wl->mutex);
2420
2421 ret = wl1271_ps_elp_wakeup(wl);
2422 if (ret < 0)
2423 goto out;
2424
2425 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2426 if (ret < 0)
2427 goto out_sleep;
2428
2429 ret = wl1271_scan_sched_scan_start(wl);
2430 if (ret < 0)
2431 goto out_sleep;
2432
2433 wl->sched_scanning = true;
2434
2435out_sleep:
2436 wl1271_ps_elp_sleep(wl);
2437out:
2438 mutex_unlock(&wl->mutex);
2439 return ret;
2440}
2441
2442static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2443 struct ieee80211_vif *vif)
2444{
2445 struct wl1271 *wl = hw->priv;
2446 int ret;
2447
2448 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2449
2450 mutex_lock(&wl->mutex);
2451
2452 ret = wl1271_ps_elp_wakeup(wl);
2453 if (ret < 0)
2454 goto out;
2455
2456 wl1271_scan_sched_scan_stop(wl);
2457
2458 wl1271_ps_elp_sleep(wl);
2459out:
2460 mutex_unlock(&wl->mutex);
2461}
2462
68d069c4
AN		 2463static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2464{
2465 struct wl1271 *wl = hw->priv;
2466 int ret = 0;
2467
2468 mutex_lock(&wl->mutex);
2469
2470 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2471 ret = -EAGAIN;
2472 goto out;
2473 }
2474
a620865e 2475 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 2476 if (ret < 0)
2477 goto out;
2478
5f704d18 2479 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 2480 if (ret < 0)
2481 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2482
2483 wl1271_ps_elp_sleep(wl);
2484
2485out:
2486 mutex_unlock(&wl->mutex);
2487
2488 return ret;
2489}
2490
f5fc0f86
LC		 2491static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2492{
2493 struct wl1271 *wl = hw->priv;
aecb0565 2494 int ret = 0;
f5fc0f86
LC		 2495
2496 mutex_lock(&wl->mutex);
2497
f8d9802f
JO		 2498 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2499 ret = -EAGAIN;
aecb0565 2500 goto out;
f8d9802f 2501 }
aecb0565 2502
a620865e 2503 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2504 if (ret < 0)
2505 goto out;
2506
5f704d18 2507 ret = wl1271_acx_rts_threshold(wl, value);
f5fc0f86
LC		 2508 if (ret < 0)
2509 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2510
2511 wl1271_ps_elp_sleep(wl);
2512
2513out:
2514 mutex_unlock(&wl->mutex);
2515
2516 return ret;
2517}
2518
e78a287a 2519static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2520 int offset)
30240fc7 2521{
889cb360
EP		 2522 u8 ssid_len;
2523 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2524 skb->len - offset);
30240fc7 2525
889cb360
EP		 2526 if (!ptr) {
2527 wl1271_error("No SSID in IEs!");
2528 return -ENOENT;
2529 }
2530
2531 ssid_len = ptr[1];
2532 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2533 wl1271_error("SSID is too long!");
2534 return -EINVAL;
30240fc7 2535 }
e78a287a 2536
889cb360
EP		 2537 wl->ssid_len = ssid_len;
2538 memcpy(wl->ssid, ptr+2, ssid_len);
2539 return 0;
30240fc7
JO		 2540}
2541
e78a287a 2542static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2543 struct ieee80211_bss_conf *bss_conf,
2544 u32 changed)
2545{
e78a287a 2546 int ret = 0;
f5fc0f86 2547
e78a287a
AN		 2548 if (changed & BSS_CHANGED_ERP_SLOT) {
2549 if (bss_conf->use_short_slot)
2550 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2551 else
2552 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2553 if (ret < 0) {
2554 wl1271_warning("Set slot time failed %d", ret);
2555 goto out;
2556 }
2557 }
f5fc0f86 2558
e78a287a
AN		 2559 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2560 if (bss_conf->use_short_preamble)
2561 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2562 else
2563 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2564 }
f5fc0f86 2565
e78a287a
AN		 2566 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2567 if (bss_conf->use_cts_prot)
2568 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2569 else
2570 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2571 if (ret < 0) {
2572 wl1271_warning("Set ctsprotect failed %d", ret);
2573 goto out;
2574 }
2575 }
f8d9802f 2576
e78a287a
AN		 2577out:
2578 return ret;
2579}
f5fc0f86 2580
e78a287a
AN		 2581static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2582 struct ieee80211_vif *vif,
2583 struct ieee80211_bss_conf *bss_conf,
2584 u32 changed)
2585{
2586 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2587 int ret = 0;
2588
2589 if ((changed & BSS_CHANGED_BEACON_INT)) {
2590 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 2591 bss_conf->beacon_int);
2592
2593 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 2594 }
2595
e78a287a
AN		 2596 if ((changed & BSS_CHANGED_BEACON)) {
2597 struct ieee80211_hdr *hdr;
2598 int ieoffset = offsetof(struct ieee80211_mgmt,
2599 u.beacon.variable);
2600 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
2601 u16 tmpl_id;
2602
2603 if (!beacon)
2604 goto out;
2605
2606 wl1271_debug(DEBUG_MASTER, "beacon updated");
2607
2608 ret = wl1271_ssid_set(wl, beacon, ieoffset);
2609 if (ret < 0) {
2610 dev_kfree_skb(beacon);
2611 goto out;
2612 }
2613 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
2614 CMD_TEMPL_BEACON;
2615 ret = wl1271_cmd_template_set(wl, tmpl_id,
2616 beacon->data,
2617 beacon->len, 0,
2618 wl1271_tx_min_rate_get(wl));
2619 if (ret < 0) {
2620 dev_kfree_skb(beacon);
2621 goto out;
2622 }
2623
2624 hdr = (struct ieee80211_hdr *) beacon->data;
2625 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2626 IEEE80211_STYPE_PROBE_RESP);
2627
2628 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
2629 CMD_TEMPL_PROBE_RESPONSE;
2630 ret = wl1271_cmd_template_set(wl,
2631 tmpl_id,
2632 beacon->data,
2633 beacon->len, 0,
2634 wl1271_tx_min_rate_get(wl));
2635 dev_kfree_skb(beacon);
2636 if (ret < 0)
2637 goto out;
2638 }
2639
2640out:
2641 return ret;
2642}
2643
2644/* AP mode changes */
2645static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
2646 struct ieee80211_vif *vif,
2647 struct ieee80211_bss_conf *bss_conf,
2648 u32 changed)
2649{
2650 int ret = 0;
e0d8bbf0 2651
e78a287a
AN		 2652 if ((changed & BSS_CHANGED_BASIC_RATES)) {
2653 u32 rates = bss_conf->basic_rates;
5da11dcd 2654
e78a287a
AN		 2655 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
2656 wl->basic_rate = wl1271_tx_min_rate_get(wl);
70f47424
AN		 2657
2658 ret = wl1271_init_ap_rates(wl);
e78a287a 2659 if (ret < 0) {
70f47424 2660 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 2661 goto out;
2662 }
c45a85b5
AN		 2663
2664 ret = wl1271_ap_init_templates(wl);
2665 if (ret < 0)
2666 goto out;
e78a287a 2667 }
2f6724b2 2668
e78a287a
AN		 2669 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
2670 if (ret < 0)
2671 goto out;
30240fc7 2672
e78a287a
AN		 2673 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
2674 if (bss_conf->enable_beacon) {
2675 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2676 ret = wl1271_cmd_start_bss(wl);
2677 if (ret < 0)
2678 goto out;
e0d8bbf0 2679
e78a287a
AN		 2680 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2681 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 2682
2683 ret = wl1271_ap_init_hwenc(wl);
2684 if (ret < 0)
2685 goto out;
e0d8bbf0 2686 }
e78a287a
AN		 2687 } else {
2688 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2689 ret = wl1271_cmd_stop_bss(wl);
2690 if (ret < 0)
2691 goto out;
e0d8bbf0 2692
e78a287a
AN		 2693 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
2694 wl1271_debug(DEBUG_AP, "stopped AP");
2695 }
2696 }
2697 }
e0d8bbf0 2698
cb5ae053
EP		 2699 if (changed & BSS_CHANGED_IBSS) {
2700 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
2701 bss_conf->ibss_joined);
2702
2703 if (bss_conf->ibss_joined) {
2704 u32 rates = bss_conf->basic_rates;
2705 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2706 rates);
2707 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2708
2709 /* by default, use 11b rates */
2710 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
2711 ret = wl1271_acx_sta_rate_policies(wl);
2712 if (ret < 0)
2713 goto out;
2714 }
2715 }
2716
e78a287a
AN		 2717 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2718 if (ret < 0)
2719 goto out;
2720out:
2721 return;
2722}
8bf29b0e 2723
e78a287a
AN		 2724/* STA/IBSS mode changes */
2725static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
2726 struct ieee80211_vif *vif,
2727 struct ieee80211_bss_conf *bss_conf,
2728 u32 changed)
2729{
2730 bool do_join = false, set_assoc = false;
2731 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 2732 u32 sta_rate_set = 0;
e78a287a 2733 int ret;
2d6e4e76 2734 struct ieee80211_sta *sta;
a100885d
AN		 2735 bool sta_exists = false;
2736 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 2737
2738 if (is_ibss) {
2739 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
2740 changed);
2741 if (ret < 0)
2742 goto out;
e0d8bbf0
JO		 2743 }
2744
e78a287a
AN		 2745 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
2746 do_join = true;
2747
2748 /* Need to update the SSID (for filtering etc) */
2749 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
2750 do_join = true;
2751
2752 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 2753 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
2754 bss_conf->enable_beacon ? "enabled" : "disabled");
2755
2756 if (bss_conf->enable_beacon)
2757 wl->set_bss_type = BSS_TYPE_IBSS;
2758 else
2759 wl->set_bss_type = BSS_TYPE_STA_BSS;
2760 do_join = true;
2761 }
2762
e78a287a 2763 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 2764 bool enable = false;
2765 if (bss_conf->cqm_rssi_thold)
2766 enable = true;
2767 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
2768 bss_conf->cqm_rssi_thold,
2769 bss_conf->cqm_rssi_hyst);
2770 if (ret < 0)
2771 goto out;
2772 wl->rssi_thold = bss_conf->cqm_rssi_thold;
2773 }
2774
30240fc7
JO		 2775 if ((changed & BSS_CHANGED_BSSID) &&
2776 /*
2777 * Now we know the correct bssid, so we send a new join command
2778 * and enable the BSSID filter
2779 */
2780 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 2781 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 2782
fa287b8f
EP		 2783 if (!is_zero_ether_addr(wl->bssid)) {
2784 ret = wl1271_cmd_build_null_data(wl);
2785 if (ret < 0)
2786 goto out;
30240fc7 2787
fa287b8f
EP		 2788 ret = wl1271_build_qos_null_data(wl);
2789 if (ret < 0)
2790 goto out;
30240fc7 2791
fa287b8f
EP		 2792 /* filter out all packets not from this BSSID */
2793 wl1271_configure_filters(wl, 0);
14b228a0 2794
fa287b8f
EP		 2795 /* Need to update the BSSID (for filtering etc) */
2796 do_join = true;
2797 }
30240fc7
JO		 2798 }
2799
72c2d9e5
EP		 2800 rcu_read_lock();
2801 sta = ieee80211_find_sta(vif, bss_conf->bssid);
2802 if (sta) {
2803 /* save the supp_rates of the ap */
2804 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
2805 if (sta->ht_cap.ht_supported)
2806 sta_rate_set |=
2807 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 2808 sta_ht_cap = sta->ht_cap;
2809 sta_exists = true;
2810 }
2811 rcu_read_unlock();
72c2d9e5 2812
a100885d 2813 if (sta_exists) {
72c2d9e5
EP		 2814 /* handle new association with HT and HT information change */
2815 if ((changed & BSS_CHANGED_HT) &&
2816 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 2817 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2818 true);
2819 if (ret < 0) {
2820 wl1271_warning("Set ht cap true failed %d",
2821 ret);
72c2d9e5
EP		 2822 goto out;
2823 }
2824 ret = wl1271_acx_set_ht_information(wl,
2825 bss_conf->ht_operation_mode);
2826 if (ret < 0) {
2827 wl1271_warning("Set ht information failed %d",
2828 ret);
72c2d9e5
EP		 2829 goto out;
2830 }
2831 }
2832 /* handle new association without HT and disassociation */
2833 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 2834 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 2835 false);
2836 if (ret < 0) {
2837 wl1271_warning("Set ht cap false failed %d",
2838 ret);
72c2d9e5
EP		 2839 goto out;
2840 }
2841 }
2842 }
72c2d9e5 2843
e78a287a 2844 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 2845 if (bss_conf->assoc) {
ebba60c6 2846 u32 rates;
2f6724b2 2847 int ieoffset;
f5fc0f86 2848 wl->aid = bss_conf->aid;
69e5434c 2849 set_assoc = true;
f5fc0f86 2850
90494a90
JO		 2851 wl->ps_poll_failures = 0;
2852
ebba60c6
JO		 2853 /*
2854 * use basic rates from AP, and determine lowest rate
2855 * to use with control frames.
2856 */
2857 rates = bss_conf->basic_rates;
2858 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
2859 rates);
e0fe371b 2860 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 2861 if (sta_rate_set)
2862 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
2863 sta_rate_set);
79b223f4 2864 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2865 if (ret < 0)
e78a287a 2866 goto out;
ebba60c6 2867
ae751bab
LC		 2868 /*
2869 * with wl1271, we don't need to update the
2870 * beacon_int and dtim_period, because the firmware
2871 * updates it by itself when the first beacon is
2872 * received after a join.
2873 */
f5fc0f86
LC		 2874 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
2875 if (ret < 0)
e78a287a 2876 goto out;
f5fc0f86 2877
c2b2d99b 2878 /*
2f6724b2 2879 * Get a template for hardware connection maintenance
c2b2d99b 2880 */
2f6724b2
JO		 2881 dev_kfree_skb(wl->probereq);
2882 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
2883 ieoffset = offsetof(struct ieee80211_mgmt,
2884 u.probe_req.variable);
2885 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 2886
6ccbb92e
JO		 2887 /* enable the connection monitoring feature */
2888 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 2889 if (ret < 0)
e78a287a 2890 goto out;
f5fc0f86
LC		 2891
2892 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 2893 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
2894 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 2895 enum wl1271_cmd_ps_mode mode;
2896
f5fc0f86 2897 mode = STATION_POWER_SAVE_MODE;
65cddbf1 2898 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 2899 wl->basic_rate,
65cddbf1 2900 true);
f5fc0f86 2901 if (ret < 0)
e78a287a 2902 goto out;
f5fc0f86 2903 }
d94cd297
JO		 2904 } else {
2905 /* use defaults when not associated */
30df14d0
EP		 2906 bool was_assoc =
2907 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
2908 &wl->flags);
c2c192ac 2909 clear_bit(WL1271_FLAG_STA_STATE_SENT, &wl->flags);
d94cd297 2910 wl->aid = 0;
6ccbb92e 2911
2f6724b2
JO		 2912 /* free probe-request template */
2913 dev_kfree_skb(wl->probereq);
2914 wl->probereq = NULL;
2915
8d2ef7bd 2916 /* re-enable dynamic ps - just in case */
f532be6d 2917 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 2918
ebba60c6
JO		 2919 /* revert back to minimum rates for the current band */
2920 wl1271_set_band_rate(wl);
e0fe371b 2921 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 2922 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2923 if (ret < 0)
e78a287a 2924 goto out;
ebba60c6 2925
6ccbb92e
JO		 2926 /* disable connection monitor features */
2927 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 2928
2929 /* Disable the keep-alive feature */
2930 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 2931 if (ret < 0)
e78a287a 2932 goto out;
b84a7d3d
JO		 2933
2934 /* restore the bssid filter and go to dummy bssid */
30df14d0
EP		 2935 if (was_assoc) {
2936 wl1271_unjoin(wl);
2937 wl1271_dummy_join(wl);
2938 }
f5fc0f86 2939 }
f5fc0f86
LC		 2940 }
2941
e78a287a
AN		 2942 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
2943 if (ret < 0)
2944 goto out;
f5fc0f86 2945
ca52a5eb
JO		 2946 if (changed & BSS_CHANGED_ARP_FILTER) {
2947 __be32 addr = bss_conf->arp_addr_list[0];
2948 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
2949
c5312772
EP		 2950 if (bss_conf->arp_addr_cnt == 1 &&
2951 bss_conf->arp_filter_enabled) {
2952 /*
2953 * The template should have been configured only upon
2954 * association. however, it seems that the correct ip
2955 * isn't being set (when sending), so we have to
2956 * reconfigure the template upon every ip change.
2957 */
2958 ret = wl1271_cmd_build_arp_rsp(wl, addr);
2959 if (ret < 0) {
2960 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 2961 goto out;
c5312772
EP		 2962 }
2963
2964 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 2965 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 2966 addr);
2967 } else
2968 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 2969
2970 if (ret < 0)
e78a287a 2971 goto out;
ca52a5eb
JO		 2972 }
2973
8bf29b0e 2974 if (do_join) {
69e5434c 2975 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 2976 if (ret < 0) {
2977 wl1271_warning("cmd join failed %d", ret);
e78a287a 2978 goto out;
8bf29b0e 2979 }
c1899554
JO		 2980 }
2981
e78a287a
AN		 2982out:
2983 return;
2984}
2985
2986static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
2987 struct ieee80211_vif *vif,
2988 struct ieee80211_bss_conf *bss_conf,
2989 u32 changed)
2990{
2991 struct wl1271 *wl = hw->priv;
2992 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2993 int ret;
2994
2995 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
2996 (int)changed);
2997
2998 mutex_lock(&wl->mutex);
2999
3000 if (unlikely(wl->state == WL1271_STATE_OFF))
3001 goto out;
3002
a620865e 3003 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3004 if (ret < 0)
3005 goto out;
3006
3007 if (is_ap)
3008 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3009 else
3010 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3011
f5fc0f86
LC		 3012 wl1271_ps_elp_sleep(wl);
3013
3014out:
3015 mutex_unlock(&wl->mutex);
3016}
3017
c6999d83
KV		 3018static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3019 const struct ieee80211_tx_queue_params *params)
3020{
3021 struct wl1271 *wl = hw->priv;
4695dc91 3022 u8 ps_scheme;
488fc540 3023 int ret = 0;
c6999d83
KV		 3024
3025 mutex_lock(&wl->mutex);
3026
3027 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3028
4695dc91
KV		 3029 if (params->uapsd)
3030 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3031 else
3032 ps_scheme = CONF_PS_SCHEME_LEGACY;
3033
488fc540
AN		 3034 if (wl->state == WL1271_STATE_OFF) {
3035 /*
3036 * If the state is off, the parameters will be recorded and
3037 * configured on init. This happens in AP-mode.
3038 */
3039 struct conf_tx_ac_category *conf_ac =
3040 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3041 struct conf_tx_tid *conf_tid =
3042 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3043
3044 conf_ac->ac = wl1271_tx_get_queue(queue);
3045 conf_ac->cw_min = (u8)params->cw_min;
3046 conf_ac->cw_max = params->cw_max;
3047 conf_ac->aifsn = params->aifs;
3048 conf_ac->tx_op_limit = params->txop << 5;
3049
3050 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3051 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3052 conf_tid->tsid = wl1271_tx_get_queue(queue);
3053 conf_tid->ps_scheme = ps_scheme;
3054 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3055 conf_tid->apsd_conf[0] = 0;
3056 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3057 goto out;
3058 }
488fc540 3059
c1b193eb
EP		 3060 ret = wl1271_ps_elp_wakeup(wl);
3061 if (ret < 0)
3062 goto out;
488fc540 3063
c1b193eb
EP		 3064 /*
3065 * the txop is confed in units of 32us by the mac80211,
3066 * we need us
3067 */
3068 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3069 params->cw_min, params->cw_max,
3070 params->aifs, params->txop << 5);
3071 if (ret < 0)
3072 goto out_sleep;
3073
3074 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3075 CONF_CHANNEL_TYPE_EDCF,
3076 wl1271_tx_get_queue(queue),
3077 ps_scheme, CONF_ACK_POLICY_LEGACY,
3078 0, 0);
c82c1dde
KV		 3079
3080out_sleep:
c1b193eb 3081 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 3082
3083out:
3084 mutex_unlock(&wl->mutex);
3085
3086 return ret;
3087}
3088
bbbb538e
JO		 3089static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3090{
3091
3092 struct wl1271 *wl = hw->priv;
3093 u64 mactime = ULLONG_MAX;
3094 int ret;
3095
3096 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3097
3098 mutex_lock(&wl->mutex);
3099
f8d9802f
JO		 3100 if (unlikely(wl->state == WL1271_STATE_OFF))
3101 goto out;
3102
a620865e 3103 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 3104 if (ret < 0)
3105 goto out;
3106
3107 ret = wl1271_acx_tsf_info(wl, &mactime);
3108 if (ret < 0)
3109 goto out_sleep;
3110
3111out_sleep:
3112 wl1271_ps_elp_sleep(wl);
3113
3114out:
3115 mutex_unlock(&wl->mutex);
3116 return mactime;
3117}
f5fc0f86 3118
ece550d0
JL		 3119static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3120 struct survey_info *survey)
3121{
3122 struct wl1271 *wl = hw->priv;
3123 struct ieee80211_conf *conf = &hw->conf;
b739a42c 3124
ece550d0
JL		 3125 if (idx != 0)
3126 return -ENOENT;
b739a42c 3127
ece550d0
JL		 3128 survey->channel = conf->channel;
3129 survey->filled = SURVEY_INFO_NOISE_DBM;
3130 survey->noise = wl->noise;
b739a42c 3131
ece550d0
JL		 3132 return 0;
3133}
3134
409622ec 3135static int wl1271_allocate_sta(struct wl1271 *wl,
f84f7d78
AN		 3136 struct ieee80211_sta *sta,
3137 u8 *hlid)
3138{
3139 struct wl1271_station *wl_sta;
3140 int id;
3141
3142 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3143 if (id >= AP_MAX_STATIONS) {
3144 wl1271_warning("could not allocate HLID - too much stations");
3145 return -EBUSY;
3146 }
3147
3148 wl_sta = (struct wl1271_station *)sta->drv_priv;
f84f7d78
AN		 3149 __set_bit(id, wl->ap_hlid_map);
3150 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3151 *hlid = wl_sta->hlid;
b622d992 3152 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
f84f7d78
AN		 3153 return 0;
3154}
3155
409622ec 3156static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
f84f7d78
AN		 3157{
3158 int id = hlid - WL1271_AP_STA_HLID_START;
3159
409622ec
AN		 3160 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3161 return;
3162
f84f7d78 3163 __clear_bit(id, wl->ap_hlid_map);
b622d992 3164 memset(wl->links[hlid].addr, 0, ETH_ALEN);
a8c0ddb5 3165 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 3166 __clear_bit(hlid, &wl->ap_ps_map);
3167 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
f84f7d78
AN		 3168}
3169
3170static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3171 struct ieee80211_vif *vif,
3172 struct ieee80211_sta *sta)
3173{
3174 struct wl1271 *wl = hw->priv;
3175 int ret = 0;
3176 u8 hlid;
3177
3178 mutex_lock(&wl->mutex);
3179
3180 if (unlikely(wl->state == WL1271_STATE_OFF))
3181 goto out;
3182
3183 if (wl->bss_type != BSS_TYPE_AP_BSS)
3184 goto out;
3185
3186 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3187
409622ec 3188 ret = wl1271_allocate_sta(wl, sta, &hlid);
f84f7d78
AN		 3189 if (ret < 0)
3190 goto out;
3191
a620865e 3192 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 3193 if (ret < 0)
409622ec 3194 goto out_free_sta;
f84f7d78
AN		 3195
3196 ret = wl1271_cmd_add_sta(wl, sta, hlid);
3197 if (ret < 0)
3198 goto out_sleep;
3199
3200out_sleep:
3201 wl1271_ps_elp_sleep(wl);
3202
409622ec
AN		 3203out_free_sta:
3204 if (ret < 0)
3205 wl1271_free_sta(wl, hlid);
3206
f84f7d78
AN		 3207out:
3208 mutex_unlock(&wl->mutex);
3209 return ret;
3210}
3211
3212static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3213 struct ieee80211_vif *vif,
3214 struct ieee80211_sta *sta)
3215{
3216 struct wl1271 *wl = hw->priv;
3217 struct wl1271_station *wl_sta;
3218 int ret = 0, id;
3219
3220 mutex_lock(&wl->mutex);
3221
3222 if (unlikely(wl->state == WL1271_STATE_OFF))
3223 goto out;
3224
3225 if (wl->bss_type != BSS_TYPE_AP_BSS)
3226 goto out;
3227
3228 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3229
3230 wl_sta = (struct wl1271_station *)sta->drv_priv;
3231 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3232 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3233 goto out;
3234
a620865e 3235 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 3236 if (ret < 0)
3237 goto out;
3238
3239 ret = wl1271_cmd_remove_sta(wl, wl_sta->hlid);
3240 if (ret < 0)
3241 goto out_sleep;
3242
409622ec 3243 wl1271_free_sta(wl, wl_sta->hlid);
f84f7d78
AN		 3244
3245out_sleep:
3246 wl1271_ps_elp_sleep(wl);
3247
3248out:
3249 mutex_unlock(&wl->mutex);
3250 return ret;
3251}
3252
4623ec7d
LC		 3253static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3254 struct ieee80211_vif *vif,
3255 enum ieee80211_ampdu_mlme_action action,
3256 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3257 u8 buf_size)
bbba3e68
LS		 3258{
3259 struct wl1271 *wl = hw->priv;
3260 int ret;
3261
3262 mutex_lock(&wl->mutex);
3263
3264 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3265 ret = -EAGAIN;
3266 goto out;
3267 }
3268
a620865e 3269 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 3270 if (ret < 0)
3271 goto out;
3272
3273 switch (action) {
3274 case IEEE80211_AMPDU_RX_START:
3275 if (wl->ba_support) {
3276 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3277 true);
3278 if (!ret)
3279 wl->ba_rx_bitmap |= BIT(tid);
3280 } else {
3281 ret = -ENOTSUPP;
3282 }
3283 break;
3284
3285 case IEEE80211_AMPDU_RX_STOP:
3286 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3287 if (!ret)
3288 wl->ba_rx_bitmap &= ~BIT(tid);
3289 break;
3290
3291 /*
3292 * The BA initiator session management in FW independently.
3293 * Falling break here on purpose for all TX APDU commands.
3294 */
3295 case IEEE80211_AMPDU_TX_START:
3296 case IEEE80211_AMPDU_TX_STOP:
3297 case IEEE80211_AMPDU_TX_OPERATIONAL:
3298 ret = -EINVAL;
3299 break;
3300
3301 default:
3302 wl1271_error("Incorrect ampdu action id=%x\n", action);
3303 ret = -EINVAL;
3304 }
3305
3306 wl1271_ps_elp_sleep(wl);
3307
3308out:
3309 mutex_unlock(&wl->mutex);
3310
3311 return ret;
3312}
3313
33437893
AN		 3314static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3315{
3316 struct wl1271 *wl = hw->priv;
3317 bool ret = false;
3318
3319 mutex_lock(&wl->mutex);
3320
3321 if (unlikely(wl->state == WL1271_STATE_OFF))
3322 goto out;
3323
3324 /* packets are considered pending if in the TX queue or the FW */
3325 ret = (wl->tx_queue_count > 0) || (wl->tx_frames_cnt > 0);
3326
3327 /* the above is appropriate for STA mode for PS purposes */
3328 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3329
3330out:
3331 mutex_unlock(&wl->mutex);
3332
3333 return ret;
3334}
3335
f5fc0f86
LC		 3336/* can't be const, mac80211 writes to this */
3337static struct ieee80211_rate wl1271_rates[] = {
3338 { .bitrate = 10,
2b60100b
JO		 3339 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3340 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 3341 { .bitrate = 20,
2b60100b
JO		 3342 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3343 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 3344 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3345 { .bitrate = 55,
2b60100b
JO		 3346 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3347 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 3348 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3349 { .bitrate = 110,
2b60100b
JO		 3350 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3351 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 3352 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3353 { .bitrate = 60,
2b60100b
JO		 3354 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3355 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 3356 { .bitrate = 90,
2b60100b
JO		 3357 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3358 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 3359 { .bitrate = 120,
2b60100b
JO		 3360 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3361 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 3362 { .bitrate = 180,
2b60100b
JO		 3363 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3364 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 3365 { .bitrate = 240,
2b60100b
JO		 3366 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3367 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 3368 { .bitrate = 360,
2b60100b
JO		 3369 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3370 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 3371 { .bitrate = 480,
2b60100b
JO		 3372 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3373 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 3374 { .bitrate = 540,
2b60100b
JO		 3375 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3376 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 3377};
3378
fa97f46b 3379/* can't be const, mac80211 writes to this */
f5fc0f86 3380static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 3381 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 3382 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 3383 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3384 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3385 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 3386 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 3387 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3388 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3389 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 3390 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 3391 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3392 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3393 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 3394 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 3395};
3396
f876bb9a 3397/* mapping to indexes for wl1271_rates */
a0ea9493 3398static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 3399 /* MCS rates are used only with 11n */
18357850
SL		 3400 7, /* CONF_HW_RXTX_RATE_MCS7 */
3401 6, /* CONF_HW_RXTX_RATE_MCS6 */
3402 5, /* CONF_HW_RXTX_RATE_MCS5 */
3403 4, /* CONF_HW_RXTX_RATE_MCS4 */
3404 3, /* CONF_HW_RXTX_RATE_MCS3 */
3405 2, /* CONF_HW_RXTX_RATE_MCS2 */
3406 1, /* CONF_HW_RXTX_RATE_MCS1 */
3407 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3408
3409 11, /* CONF_HW_RXTX_RATE_54 */
3410 10, /* CONF_HW_RXTX_RATE_48 */
3411 9, /* CONF_HW_RXTX_RATE_36 */
3412 8, /* CONF_HW_RXTX_RATE_24 */
3413
3414 /* TI-specific rate */
3415 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3416
3417 7, /* CONF_HW_RXTX_RATE_18 */
3418 6, /* CONF_HW_RXTX_RATE_12 */
3419 3, /* CONF_HW_RXTX_RATE_11 */
3420 5, /* CONF_HW_RXTX_RATE_9 */
3421 4, /* CONF_HW_RXTX_RATE_6 */
3422 2, /* CONF_HW_RXTX_RATE_5_5 */
3423 1, /* CONF_HW_RXTX_RATE_2 */
3424 0 /* CONF_HW_RXTX_RATE_1 */
3425};
3426
e8b03a2b
SL		 3427/* 11n STA capabilities */
3428#define HW_RX_HIGHEST_RATE 72
3429
00d20100
SL		 3430#ifdef CONFIG_WL12XX_HT
3431#define WL12XX_HT_CAP { \
871d0c3b
SL		 3432 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3433 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 3434 .ht_supported = true, \
3435 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3436 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3437 .mcs = { \
3438 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3439 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3440 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3441 }, \
3442}
18357850 3443#else
00d20100 3444#define WL12XX_HT_CAP { \
18357850
SL		 3445 .ht_supported = false, \
3446}
3447#endif
e8b03a2b 3448
f5fc0f86
LC		 3449/* can't be const, mac80211 writes to this */
3450static struct ieee80211_supported_band wl1271_band_2ghz = {
3451 .channels = wl1271_channels,
3452 .n_channels = ARRAY_SIZE(wl1271_channels),
3453 .bitrates = wl1271_rates,
3454 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 3455 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 3456};
3457
1ebec3d7
TP		 3458/* 5 GHz data rates for WL1273 */
3459static struct ieee80211_rate wl1271_rates_5ghz[] = {
3460 { .bitrate = 60,
3461 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3462 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3463 { .bitrate = 90,
3464 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3465 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3466 { .bitrate = 120,
3467 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3468 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3469 { .bitrate = 180,
3470 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3471 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3472 { .bitrate = 240,
3473 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3474 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3475 { .bitrate = 360,
3476 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3477 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3478 { .bitrate = 480,
3479 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3480 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3481 { .bitrate = 540,
3482 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3483 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3484};
3485
fa97f46b 3486/* 5 GHz band channels for WL1273 */
1ebec3d7 3487static struct ieee80211_channel wl1271_channels_5ghz[] = {
fa21c7a9 3488 { .hw_value = 7, .center_freq = 5035},
fa97f46b
JO		 3489 { .hw_value = 8, .center_freq = 5040},
3490 { .hw_value = 9, .center_freq = 5045},
3491 { .hw_value = 11, .center_freq = 5055},
3492 { .hw_value = 12, .center_freq = 5060},
fa21c7a9 3493 { .hw_value = 16, .center_freq = 5080},
fa97f46b
JO		 3494 { .hw_value = 34, .center_freq = 5170},
3495 { .hw_value = 36, .center_freq = 5180},
3496 { .hw_value = 38, .center_freq = 5190},
3497 { .hw_value = 40, .center_freq = 5200},
fa21c7a9 3498 { .hw_value = 42, .center_freq = 5210},
fa97f46b
JO		 3499 { .hw_value = 44, .center_freq = 5220},
3500 { .hw_value = 46, .center_freq = 5230},
3501 { .hw_value = 48, .center_freq = 5240},
3502 { .hw_value = 52, .center_freq = 5260},
fa21c7a9 3503 { .hw_value = 56, .center_freq = 5280},
fa97f46b
JO		 3504 { .hw_value = 60, .center_freq = 5300},
3505 { .hw_value = 64, .center_freq = 5320},
3506 { .hw_value = 100, .center_freq = 5500},
3507 { .hw_value = 104, .center_freq = 5520},
fa21c7a9 3508 { .hw_value = 108, .center_freq = 5540},
fa97f46b
JO		 3509 { .hw_value = 112, .center_freq = 5560},
3510 { .hw_value = 116, .center_freq = 5580},
3511 { .hw_value = 120, .center_freq = 5600},
3512 { .hw_value = 124, .center_freq = 5620},
fa21c7a9 3513 { .hw_value = 128, .center_freq = 5640},
fa97f46b
JO		 3514 { .hw_value = 132, .center_freq = 5660},
3515 { .hw_value = 136, .center_freq = 5680},
3516 { .hw_value = 140, .center_freq = 5700},
3517 { .hw_value = 149, .center_freq = 5745},
fa21c7a9 3518 { .hw_value = 153, .center_freq = 5765},
fa97f46b
JO		 3519 { .hw_value = 157, .center_freq = 5785},
3520 { .hw_value = 161, .center_freq = 5805},
1ebec3d7
TP		 3521 { .hw_value = 165, .center_freq = 5825},
3522};
3523
f876bb9a 3524/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 3525static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 3526 /* MCS rates are used only with 11n */
18357850
SL		 3527 7, /* CONF_HW_RXTX_RATE_MCS7 */
3528 6, /* CONF_HW_RXTX_RATE_MCS6 */
3529 5, /* CONF_HW_RXTX_RATE_MCS5 */
3530 4, /* CONF_HW_RXTX_RATE_MCS4 */
3531 3, /* CONF_HW_RXTX_RATE_MCS3 */
3532 2, /* CONF_HW_RXTX_RATE_MCS2 */
3533 1, /* CONF_HW_RXTX_RATE_MCS1 */
3534 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3535
3536 7, /* CONF_HW_RXTX_RATE_54 */
3537 6, /* CONF_HW_RXTX_RATE_48 */
3538 5, /* CONF_HW_RXTX_RATE_36 */
3539 4, /* CONF_HW_RXTX_RATE_24 */
3540
3541 /* TI-specific rate */
3542 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3543
3544 3, /* CONF_HW_RXTX_RATE_18 */
3545 2, /* CONF_HW_RXTX_RATE_12 */
3546 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
3547 1, /* CONF_HW_RXTX_RATE_9 */
3548 0, /* CONF_HW_RXTX_RATE_6 */
3549 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
3550 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
3551 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
3552};
1ebec3d7
TP		 3553
3554static struct ieee80211_supported_band wl1271_band_5ghz = {
3555 .channels = wl1271_channels_5ghz,
3556 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
3557 .bitrates = wl1271_rates_5ghz,
3558 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 3559 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 3560};
3561
a0ea9493 3562static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 3563 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
3564 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
3565};
3566
f5fc0f86
LC		 3567static const struct ieee80211_ops wl1271_ops = {
3568 .start = wl1271_op_start,
3569 .stop = wl1271_op_stop,
3570 .add_interface = wl1271_op_add_interface,
3571 .remove_interface = wl1271_op_remove_interface,
402e4861
EP		 3572 .suspend = wl1271_op_suspend,
3573 .resume = wl1271_op_resume,
f5fc0f86 3574 .config = wl1271_op_config,
c87dec9f 3575 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 3576 .configure_filter = wl1271_op_configure_filter,
3577 .tx = wl1271_op_tx,
3578 .set_key = wl1271_op_set_key,
3579 .hw_scan = wl1271_op_hw_scan,
33c2c06c
LC		 3580 .sched_scan_start = wl1271_op_sched_scan_start,
3581 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 3582 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 3583 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 3584 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 3585 .conf_tx = wl1271_op_conf_tx,
bbbb538e 3586 .get_tsf = wl1271_op_get_tsf,
ece550d0 3587 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 3588 .sta_add = wl1271_op_sta_add,
3589 .sta_remove = wl1271_op_sta_remove,
bbba3e68 3590 .ampdu_action = wl1271_op_ampdu_action,
33437893 3591 .tx_frames_pending = wl1271_tx_frames_pending,
c8c90873 3592 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 3593};
3594
f876bb9a 3595
6a2de93b 3596u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 3597{
3598 u8 idx;
3599
6a2de93b 3600 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 3601
3602 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
3603 wl1271_error("Illegal RX rate from HW: %d", rate);
3604 return 0;
3605 }
3606
6a2de93b 3607 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 3608 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
3609 wl1271_error("Unsupported RX rate from HW: %d", rate);
3610 return 0;
3611 }
3612
3613 return idx;
3614}
3615
7fc3a864
JO		 3616static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
3617 struct device_attribute *attr,
3618 char *buf)
3619{
3620 struct wl1271 *wl = dev_get_drvdata(dev);
3621 ssize_t len;
3622
2f63b011 3623 len = PAGE_SIZE;
7fc3a864
JO		 3624
3625 mutex_lock(&wl->mutex);
3626 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
3627 wl->sg_enabled);
3628 mutex_unlock(&wl->mutex);
3629
3630 return len;
3631
3632}
3633
3634static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
3635 struct device_attribute *attr,
3636 const char *buf, size_t count)
3637{
3638 struct wl1271 *wl = dev_get_drvdata(dev);
3639 unsigned long res;
3640 int ret;
3641
6277ed65 3642 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 3643 if (ret < 0) {
3644 wl1271_warning("incorrect value written to bt_coex_mode");
3645 return count;
3646 }
3647
3648 mutex_lock(&wl->mutex);
3649
3650 res = !!res;
3651
3652 if (res == wl->sg_enabled)
3653 goto out;
3654
3655 wl->sg_enabled = res;
3656
3657 if (wl->state == WL1271_STATE_OFF)
3658 goto out;
3659
a620865e 3660 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 3661 if (ret < 0)
3662 goto out;
3663
3664 wl1271_acx_sg_enable(wl, wl->sg_enabled);
3665 wl1271_ps_elp_sleep(wl);
3666
3667 out:
3668 mutex_unlock(&wl->mutex);
3669 return count;
3670}
3671
3672static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
3673 wl1271_sysfs_show_bt_coex_state,
3674 wl1271_sysfs_store_bt_coex_state);
3675
d717fd61
JO		 3676static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
3677 struct device_attribute *attr,
3678 char *buf)
3679{
3680 struct wl1271 *wl = dev_get_drvdata(dev);
3681 ssize_t len;
3682
2f63b011 3683 len = PAGE_SIZE;
d717fd61
JO		 3684
3685 mutex_lock(&wl->mutex);
3686 if (wl->hw_pg_ver >= 0)
3687 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
3688 else
3689 len = snprintf(buf, len, "n/a\n");
3690 mutex_unlock(&wl->mutex);
3691
3692 return len;
3693}
3694
3695static DEVICE_ATTR(hw_pg_ver, S_IRUGO | S_IWUSR,
3696 wl1271_sysfs_show_hw_pg_ver, NULL);
3697
2d5e82b8 3698int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 3699{
3700 int ret;
3701
3702 if (wl->mac80211_registered)
3703 return 0;
3704
31d26ec6
AN		 3705 ret = wl1271_fetch_nvs(wl);
3706 if (ret == 0) {
bc765bf3
SL		 3707 /* NOTE: The wl->nvs->nvs element must be first, in
3708 * order to simplify the casting, we assume it is at
3709 * the beginning of the wl->nvs structure.
3710 */
3711 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 3712
3713 wl->mac_addr[0] = nvs_ptr[11];
3714 wl->mac_addr[1] = nvs_ptr[10];
3715 wl->mac_addr[2] = nvs_ptr[6];
3716 wl->mac_addr[3] = nvs_ptr[5];
3717 wl->mac_addr[4] = nvs_ptr[4];
3718 wl->mac_addr[5] = nvs_ptr[3];
3719 }
3720
f5fc0f86
LC		 3721 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
3722
3723 ret = ieee80211_register_hw(wl->hw);
3724 if (ret < 0) {
3725 wl1271_error("unable to register mac80211 hw: %d", ret);
3726 return ret;
3727 }
3728
3729 wl->mac80211_registered = true;
3730
d60080ae
EP		 3731 wl1271_debugfs_init(wl);
3732
c2c192ac
JO		 3733 register_netdevice_notifier(&wl1271_dev_notifier);
3734
f5fc0f86
LC		 3735 wl1271_notice("loaded");
3736
3737 return 0;
3738}
50b3eb4b 3739EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 3740
3b56dd6a
TP		 3741void wl1271_unregister_hw(struct wl1271 *wl)
3742{
4ae3fa87
JO		 3743 if (wl->state == WL1271_STATE_PLT)
3744 __wl1271_plt_stop(wl);
3745
c2c192ac 3746 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 3747 ieee80211_unregister_hw(wl->hw);
3748 wl->mac80211_registered = false;
3749
3750}
3751EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
3752
2d5e82b8 3753int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 3754{
7a55724e
JO		 3755 static const u32 cipher_suites[] = {
3756 WLAN_CIPHER_SUITE_WEP40,
3757 WLAN_CIPHER_SUITE_WEP104,
3758 WLAN_CIPHER_SUITE_TKIP,
3759 WLAN_CIPHER_SUITE_CCMP,
3760 WL1271_CIPHER_SUITE_GEM,
3761 };
3762
1e2b7976
JO		 3763 /* The tx descriptor buffer and the TKIP space. */
3764 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
3765 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 3766
3767 /* unit us */
3768 /* FIXME: find a proper value */
3769 wl->hw->channel_change_time = 10000;
50c500ad 3770 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 3771
3772 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 3773 IEEE80211_HW_BEACON_FILTER |
0a34332f 3774 IEEE80211_HW_SUPPORTS_PS |
4695dc91 3775 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 3776 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 3777 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 3778 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 3779 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 3780 IEEE80211_HW_SPECTRUM_MGMT |
ba7c082a 3781 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 3782
7a55724e
JO		 3783 wl->hw->wiphy->cipher_suites = cipher_suites;
3784 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
3785
e0d8bbf0 3786 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 3787 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 3788 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 3789 /*
3790 * Maximum length of elements in scanning probe request templates
3791 * should be the maximum length possible for a template, without
3792 * the IEEE80211 header of the template
3793 */
3794 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
3795 sizeof(struct ieee80211_header);
a8aaaf53 3796
4a31c11c
LC		 3797 /* make sure all our channels fit in the scanned_ch bitmask */
3798 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
3799 ARRAY_SIZE(wl1271_channels_5ghz) >
3800 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 3801 /*
3802 * We keep local copies of the band structs because we need to
3803 * modify them on a per-device basis.
3804 */
3805 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
3806 sizeof(wl1271_band_2ghz));
3807 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
3808 sizeof(wl1271_band_5ghz));
3809
3810 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
3811 &wl->bands[IEEE80211_BAND_2GHZ];
3812 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
3813 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 3814
12bd8949 3815 wl->hw->queues = 4;
31627dc5 3816 wl->hw->max_rates = 1;
12bd8949 3817
b7417d93
JO		 3818 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
3819
8197b711 3820 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 3821
f84f7d78
AN		 3822 wl->hw->sta_data_size = sizeof(struct wl1271_station);
3823
4c9cfa78
LC		 3824 wl->hw->max_rx_aggregation_subframes = 8;
3825
f5fc0f86
LC		 3826 return 0;
3827}
50b3eb4b 3828EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 3829
f5fc0f86 3830#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 3831
2d5e82b8 3832struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 3833{
f5fc0f86 3834 struct ieee80211_hw *hw;
3b56dd6a 3835 struct platform_device *plat_dev = NULL;
f5fc0f86 3836 struct wl1271 *wl;
a8c0ddb5 3837 int i, j, ret;
1f37cbc9 3838 unsigned int order;
f5fc0f86
LC		 3839
3840 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
3841 if (!hw) {
3842 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 3843 ret = -ENOMEM;
3b56dd6a
TP		 3844 goto err_hw_alloc;
3845 }
3846
929ebd30 3847 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 3848 if (!plat_dev) {
3849 wl1271_error("could not allocate platform_device");
3850 ret = -ENOMEM;
3851 goto err_plat_alloc;
f5fc0f86
LC		 3852 }
3853
3854 wl = hw->priv;
3855 memset(wl, 0, sizeof(*wl));
3856
01c09162
JO		 3857 INIT_LIST_HEAD(&wl->list);
3858
f5fc0f86 3859 wl->hw = hw;
3b56dd6a 3860 wl->plat_dev = plat_dev;
f5fc0f86 3861
6742f554
JO		 3862 for (i = 0; i < NUM_TX_QUEUES; i++)
3863 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 3864
a8c0ddb5
AN		 3865 for (i = 0; i < NUM_TX_QUEUES; i++)
3866 for (j = 0; j < AP_MAX_LINKS; j++)
3867 skb_queue_head_init(&wl->links[j].tx_queue[i]);
3868
a620865e
IY		 3869 skb_queue_head_init(&wl->deferred_rx_queue);
3870 skb_queue_head_init(&wl->deferred_tx_queue);
3871
37b70a81 3872 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 3873 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
a620865e 3874 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 3875 INIT_WORK(&wl->tx_work, wl1271_tx_work);
3876 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
3877 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
f5fc0f86 3878 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 3879 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 3880 wl->default_key = 0;
f5fc0f86 3881 wl->rx_counter = 0;
ae113b57
AN		 3882 wl->rx_config = WL1271_DEFAULT_STA_RX_CONFIG;
3883 wl->rx_filter = WL1271_DEFAULT_STA_RX_FILTER;
19ad0715 3884 wl->psm_entry_retry = 0;
f5fc0f86 3885 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 3886 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 3887 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 3888 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 3889 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 3890 wl->vif = NULL;
830fb67b 3891 wl->flags = 0;
7fc3a864 3892 wl->sg_enabled = true;
d717fd61 3893 wl->hw_pg_ver = -1;
166d504e
AN		 3894 wl->bss_type = MAX_BSS_TYPE;
3895 wl->set_bss_type = MAX_BSS_TYPE;
3896 wl->fw_bss_type = MAX_BSS_TYPE;
a8c0ddb5 3897 wl->last_tx_hlid = 0;
b622d992
AN		 3898 wl->ap_ps_map = 0;
3899 wl->ap_fw_ps_map = 0;
606ea9fa 3900 wl->quirks = 0;
341b7cde 3901 wl->platform_quirks = 0;
33c2c06c 3902 wl->sched_scanning = false;
f5fc0f86 3903
25eeb9e3 3904 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 3905 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 3906 wl->tx_frames[i] = NULL;
3907
3908 spin_lock_init(&wl->wl_lock);
3909
f5fc0f86
LC		 3910 wl->state = WL1271_STATE_OFF;
3911 mutex_init(&wl->mutex);
3912
c332a4b8
TP		 3913 /* Apply default driver configuration. */
3914 wl1271_conf_init(wl);
3915
1f37cbc9
IY		 3916 order = get_order(WL1271_AGGR_BUFFER_SIZE);
3917 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
3918 if (!wl->aggr_buf) {
3919 ret = -ENOMEM;
3920 goto err_hw;
3921 }
3922
990f5de7
IY		 3923 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
3924 if (!wl->dummy_packet) {
3925 ret = -ENOMEM;
3926 goto err_aggr;
3927 }
3928
a1dd8187 3929 /* Register platform device */
3b56dd6a 3930 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 3931 if (ret) {
3932 wl1271_error("couldn't register platform device");
990f5de7 3933 goto err_dummy_packet;
a1dd8187 3934 }
3b56dd6a 3935 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 3936
7fc3a864 3937 /* Create sysfs file to control bt coex state */
3b56dd6a 3938 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 3939 if (ret < 0) {
3940 wl1271_error("failed to create sysfs file bt_coex_state");
3941 goto err_platform;
3942 }
a1dd8187 3943
d717fd61
JO		 3944 /* Create sysfs file to get HW PG version */
3945 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
3946 if (ret < 0) {
3947 wl1271_error("failed to create sysfs file hw_pg_ver");
3948 goto err_bt_coex_state;
3949 }
3950
c332a4b8 3951 return hw;
a1dd8187 3952
d717fd61
JO		 3953err_bt_coex_state:
3954 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3955
7fc3a864 3956err_platform:
3b56dd6a 3957 platform_device_unregister(wl->plat_dev);
7fc3a864 3958
990f5de7
IY		 3959err_dummy_packet:
3960 dev_kfree_skb(wl->dummy_packet);
3961
1f37cbc9
IY		 3962err_aggr:
3963 free_pages((unsigned long)wl->aggr_buf, order);
3964
a1dd8187 3965err_hw:
3b56dd6a
TP		 3966 wl1271_debugfs_exit(wl);
3967 kfree(plat_dev);
3968
3969err_plat_alloc:
3970 ieee80211_free_hw(hw);
3971
3972err_hw_alloc:
a1dd8187 3973
a1dd8187 3974 return ERR_PTR(ret);
c332a4b8 3975}
50b3eb4b 3976EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 3977
3978int wl1271_free_hw(struct wl1271 *wl)
3979{
3b56dd6a 3980 platform_device_unregister(wl->plat_dev);
990f5de7 3981 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 3982 free_pages((unsigned long)wl->aggr_buf,
3983 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 3984 kfree(wl->plat_dev);
c332a4b8
TP		 3985
3986 wl1271_debugfs_exit(wl);
3987
c332a4b8
TP		 3988 vfree(wl->fw);
3989 wl->fw = NULL;
3990 kfree(wl->nvs);
3991 wl->nvs = NULL;
3992
3993 kfree(wl->fw_status);
3994 kfree(wl->tx_res_if);
3995
3996 ieee80211_free_hw(wl->hw);
3997
3998 return 0;
3999}
50b3eb4b
TP		 4000EXPORT_SYMBOL_GPL(wl1271_free_hw);
4001
491bbd6b 4002u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 4003EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 4004module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 4005MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4006
50b3eb4b 4007MODULE_LICENSE("GPL");
b1a48cab 4008MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 4009MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.63815 seconds and 5 git commands to generate.