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