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