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