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