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