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