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