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