projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: fix session counter
[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:
1975 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
04e8079c 1976 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
b78b47eb 1977
13026dec
JO		 1978 /*
1979 * this must be before the cancel_work calls below, so that the work
1980 * functions don't perform further work.
1981 */
f5fc0f86
LC		 1982 wl->state = WL1271_STATE_OFF;
1983
f5fc0f86
LC		 1984 mutex_unlock(&wl->mutex);
1985
a620865e
IY		 1986 wl1271_disable_interrupts(wl);
1987 wl1271_flush_deferred_work(wl);
78abd320 1988 cancel_delayed_work_sync(&wl->scan_complete_work);
a620865e 1989 cancel_work_sync(&wl->netstack_work);
f5fc0f86 1990 cancel_work_sync(&wl->tx_work);
77ddaa10
EP		 1991 del_timer_sync(&wl->rx_streaming_timer);
1992 cancel_work_sync(&wl->rx_streaming_enable_work);
1993 cancel_work_sync(&wl->rx_streaming_disable_work);
90494a90 1994 cancel_delayed_work_sync(&wl->pspoll_work);
8c7f4f31 1995 cancel_delayed_work_sync(&wl->elp_work);
f5fc0f86
LC		 1996
1997 mutex_lock(&wl->mutex);
1998
1999 /* let's notify MAC80211 about the remaining pending TX frames */
7dece1c8 2000 wl1271_tx_reset(wl, reset_tx_queues);
f5fc0f86
LC		 2001 wl1271_power_off(wl);
2002
2003 memset(wl->bssid, 0, ETH_ALEN);
3b40c040 2004 memset(wl->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
f5fc0f86 2005 wl->ssid_len = 0;
f5fc0f86 2006 wl->bss_type = MAX_BSS_TYPE;
5da11dcd 2007 wl->set_bss_type = MAX_BSS_TYPE;
8a5a37a6 2008 wl->band = IEEE80211_BAND_2GHZ;
f5fc0f86
LC		 2009
2010 wl->rx_counter = 0;
19ad0715 2011 wl->psm_entry_retry = 0;
f5fc0f86
LC		 2012 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
2013 wl->tx_blocks_available = 0;
7bb5d6ce 2014 wl->tx_allocated_blocks = 0;
f5fc0f86
LC		 2015 wl->tx_results_count = 0;
2016 wl->tx_packets_count = 0;
2017 wl->time_offset = 0;
2018 wl->session_counter = 0;
830fb67b 2019 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
1b72aecd 2020 wl->vif = NULL;
7f179b46 2021 wl1271_free_ap_keys(wl);
f84f7d78 2022 memset(wl->ap_hlid_map, 0, sizeof(wl->ap_hlid_map));
b622d992
AN		 2023 wl->ap_fw_ps_map = 0;
2024 wl->ap_ps_map = 0;
33c2c06c 2025 wl->sched_scanning = false;
7f097988 2026 wl->role_id = WL12XX_INVALID_ROLE_ID;
04e8079c 2027 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
c690ec81
EP		 2028 memset(wl->roles_map, 0, sizeof(wl->roles_map));
2029 memset(wl->links_map, 0, sizeof(wl->links_map));
251c177f 2030 memset(wl->roc_map, 0, sizeof(wl->roc_map));
d6e19d13 2031
f4df1bd5
EP		 2032 /* The system link is always allocated */
2033 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
2034
13026dec
JO		 2035 /*
2036 * this is performed after the cancel_work calls and the associated
2037 * mutex_lock, so that wl1271_op_add_interface does not accidentally
2038 * get executed before all these vars have been reset.
2039 */
2040 wl->flags = 0;
2041
4d56ad9c 2042 wl->tx_blocks_freed = 0;
f5fc0f86
LC		 2043
2044 wl1271_debugfs_reset(wl);
bd9dc49c
JO		 2045
2046 kfree(wl->fw_status);
2047 wl->fw_status = NULL;
2048 kfree(wl->tx_res_if);
2049 wl->tx_res_if = NULL;
2050 kfree(wl->target_mem_map);
2051 wl->target_mem_map = NULL;
52a2a375 2052}
bd9dc49c 2053
52a2a375
JO		 2054static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2055 struct ieee80211_vif *vif)
2056{
2057 struct wl1271 *wl = hw->priv;
2058
2059 mutex_lock(&wl->mutex);
67353299
JO		 2060 /*
2061 * wl->vif can be null here if someone shuts down the interface
2062 * just when hardware recovery has been started.
2063 */
2064 if (wl->vif) {
2065 WARN_ON(wl->vif != vif);
7dece1c8 2066 __wl1271_op_remove_interface(wl, true);
67353299 2067 }
52b0e7a6 2068
67353299 2069 mutex_unlock(&wl->mutex);
52b0e7a6 2070 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 2071}
2072
69e5434c 2073static int wl1271_join(struct wl1271 *wl, bool set_assoc)
82429d32
JO		 2074{
2075 int ret;
2076
69e5434c
JO		 2077 /*
2078 * One of the side effects of the JOIN command is that is clears
2079 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2080 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2081 * Currently the only valid scenario for JOIN during association
2082 * is on roaming, in which case we will also be given new keys.
2083 * Keep the below message for now, unless it starts bothering
2084 * users who really like to roam a lot :)
69e5434c
JO		 2085 */
2086 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2087 wl1271_info("JOIN while associated.");
2088
2089 if (set_assoc)
2090 set_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags);
2091
c690ec81 2092 ret = wl12xx_cmd_role_start_sta(wl);
82429d32
JO		 2093 if (ret < 0)
2094 goto out;
2095
82429d32
JO		 2096 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2097 goto out;
2098
2099 /*
2100 * The join command disable the keep-alive mode, shut down its process,
2101 * and also clear the template config, so we need to reset it all after
2102 * the join. The acx_aid starts the keep-alive process, and the order
2103 * of the commands below is relevant.
2104 */
2105 ret = wl1271_acx_keep_alive_mode(wl, true);
2106 if (ret < 0)
2107 goto out;
2108
2109 ret = wl1271_acx_aid(wl, wl->aid);
2110 if (ret < 0)
2111 goto out;
2112
2113 ret = wl1271_cmd_build_klv_null_data(wl);
2114 if (ret < 0)
2115 goto out;
2116
2117 ret = wl1271_acx_keep_alive_config(wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2118 ACX_KEEP_ALIVE_TPL_VALID);
2119 if (ret < 0)
2120 goto out;
2121
2122out:
2123 return ret;
2124}
2125
2126static int wl1271_unjoin(struct wl1271 *wl)
c7f43e45
LC		 2127{
2128 int ret;
2129
2130 /* to stop listening to a channel, we disconnect */
c690ec81 2131 ret = wl12xx_cmd_role_stop_sta(wl);
c7f43e45
LC		 2132 if (ret < 0)
2133 goto out;
2134
c7f43e45 2135 memset(wl->bssid, 0, ETH_ALEN);
14b228a0 2136
b992c682
OK		 2137 /* reset TX security counters on a clean disconnect */
2138 wl->tx_security_last_seq_lsb = 0;
2139 wl->tx_security_seq = 0;
2140
c7f43e45
LC		 2141out:
2142 return ret;
2143}
2144
ebba60c6
JO		 2145static void wl1271_set_band_rate(struct wl1271 *wl)
2146{
2147 if (wl->band == IEEE80211_BAND_2GHZ)
2148 wl->basic_rate_set = wl->conf.tx.basic_rate;
2149 else
2150 wl->basic_rate_set = wl->conf.tx.basic_rate_5;
2151}
2152
251c177f
EP		 2153static bool wl12xx_is_roc(struct wl1271 *wl)
2154{
2155 u8 role_id;
2156
2157 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2158 if (role_id >= WL12XX_MAX_ROLES)
2159 return false;
2160
2161 return true;
2162}
2163
bee0ffec 2164static int wl1271_sta_handle_idle(struct wl1271 *wl, bool idle)
0d58cbff
JO		 2165{
2166 int ret;
2167
2168 if (idle) {
251c177f
EP		 2169 /* no need to croc if we weren't busy (e.g. during boot) */
2170 if (wl12xx_is_roc(wl)) {
2171 ret = wl12xx_croc(wl, wl->dev_role_id);
2172 if (ret < 0)
2173 goto out;
2174
2175 ret = wl12xx_cmd_role_stop_dev(wl);
0d58cbff
JO		 2176 if (ret < 0)
2177 goto out;
2178 }
e0fe371b 2179 wl->rate_set = wl1271_tx_min_rate_get(wl);
79b223f4 2180 ret = wl1271_acx_sta_rate_policies(wl);
0d58cbff
JO		 2181 if (ret < 0)
2182 goto out;
2183 ret = wl1271_acx_keep_alive_config(
2184 wl, CMD_TEMPL_KLV_IDX_NULL_DATA,
2185 ACX_KEEP_ALIVE_TPL_INVALID);
2186 if (ret < 0)
2187 goto out;
2188 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2189 } else {
33c2c06c
LC		 2190 /* The current firmware only supports sched_scan in idle */
2191 if (wl->sched_scanning) {
2192 wl1271_scan_sched_scan_stop(wl);
2193 ieee80211_sched_scan_stopped(wl->hw);
2194 }
2195
251c177f
EP		 2196 ret = wl12xx_cmd_role_start_dev(wl);
2197 if (ret < 0)
2198 goto out;
2199
2200 ret = wl12xx_roc(wl, wl->dev_role_id);
0d58cbff
JO		 2201 if (ret < 0)
2202 goto out;
2203 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2204 }
2205
2206out:
2207 return ret;
2208}
2209
f5fc0f86
LC		 2210static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
2211{
2212 struct wl1271 *wl = hw->priv;
2213 struct ieee80211_conf *conf = &hw->conf;
2214 int channel, ret = 0;
bee0ffec 2215 bool is_ap;
f5fc0f86
LC		 2216
2217 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2218
bee0ffec
AN		 2219 wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
2220 " changed 0x%x",
f5fc0f86
LC		 2221 channel,
2222 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
c7f43e45 2223 conf->power_level,
bee0ffec
AN		 2224 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
2225 changed);
f5fc0f86 2226
781608c4
JO		 2227 /*
2228 * mac80211 will go to idle nearly immediately after transmitting some
2229 * frames, such as the deauth. To make sure those frames reach the air,
2230 * wait here until the TX queue is fully flushed.
2231 */
2232 if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
2233 (conf->flags & IEEE80211_CONF_IDLE))
2234 wl1271_tx_flush(wl);
2235
f5fc0f86
LC		 2236 mutex_lock(&wl->mutex);
2237
f8d9802f 2238 if (unlikely(wl->state == WL1271_STATE_OFF)) {
17e672d6
AN		 2239 /* we support configuring the channel and band while off */
2240 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
2241 wl->band = conf->channel->band;
2242 wl->channel = channel;
2243 }
2244
097f8821
AN		 2245 if ((changed & IEEE80211_CONF_CHANGE_POWER))
2246 wl->power_level = conf->power_level;
2247
2c10bb9c 2248 goto out;
f8d9802f 2249 }
8a5a37a6 2250
bee0ffec
AN		 2251 is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2252
a620865e 2253 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2254 if (ret < 0)
2255 goto out;
2256
ebba60c6 2257 /* if the channel changes while joined, join again */
69e5434c
JO		 2258 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
2259 ((wl->band != conf->channel->band) ||
2260 (wl->channel != channel))) {
ebba60c6
JO		 2261 wl->band = conf->channel->band;
2262 wl->channel = channel;
2263
bee0ffec
AN		 2264 if (!is_ap) {
2265 /*
2266 * FIXME: the mac80211 should really provide a fixed
2267 * rate to use here. for now, just use the smallest
2268 * possible rate for the band as a fixed rate for
2269 * association frames and other control messages.
2270 */
2271 if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags))
2272 wl1271_set_band_rate(wl);
2273
2274 wl->basic_rate = wl1271_tx_min_rate_get(wl);
2275 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 2276 if (ret < 0)
bee0ffec 2277 wl1271_warning("rate policy for channel "
ebba60c6 2278 "failed %d", ret);
bee0ffec 2279
251c177f
EP		 2280 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2281 if (wl12xx_is_roc(wl)) {
2282 /* roaming */
2283 ret = wl12xx_croc(wl, wl->dev_role_id);
2284 if (ret < 0)
2285 goto out_sleep;
2286 }
bee0ffec
AN		 2287 ret = wl1271_join(wl, false);
2288 if (ret < 0)
2289 wl1271_warning("cmd join on channel "
2290 "failed %d", ret);
251c177f
EP		 2291 } else {
2292 /*
2293 * change the ROC channel. do it only if we are
2294 * not idle. otherwise, CROC will be called
2295 * anyway.
2296 */
2297 if (wl12xx_is_roc(wl) &&
2298 !(conf->flags & IEEE80211_CONF_IDLE)) {
2299 ret = wl12xx_croc(wl, wl->dev_role_id);
2300 if (ret < 0)
2301 goto out_sleep;
2302
2303 ret = wl12xx_roc(wl, wl->dev_role_id);
2304 if (ret < 0)
2305 wl1271_warning("roc failed %d",
2306 ret);
2307 }
bee0ffec 2308 }
ebba60c6
JO		 2309 }
2310 }
2311
bee0ffec
AN		 2312 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
2313 ret = wl1271_sta_handle_idle(wl,
2314 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 2315 if (ret < 0)
2316 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 2317 }
2318
90494a90
JO		 2319 /*
2320 * if mac80211 changes the PSM mode, make sure the mode is not
2321 * incorrectly changed after the pspoll failure active window.
2322 */
2323 if (changed & IEEE80211_CONF_CHANGE_PS)
2324 clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags);
2325
71449f8d
JO		 2326 if (conf->flags & IEEE80211_CONF_PS &&
2327 !test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
2328 set_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86
LC		 2329
2330 /*
2331 * We enter PSM only if we're already associated.
2332 * If we're not, we'll enter it when joining an SSID,
2333 * through the bss_info_changed() hook.
2334 */
830fb67b 2335 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
18f8d468 2336 wl1271_debug(DEBUG_PSM, "psm enabled");
d8c42c0c 2337 ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE,
8eab7b47 2338 wl->basic_rate, true);
af5e084b 2339 }
f5fc0f86 2340 } else if (!(conf->flags & IEEE80211_CONF_PS) &&
71449f8d 2341 test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags)) {
18f8d468 2342 wl1271_debug(DEBUG_PSM, "psm disabled");
f5fc0f86 2343
71449f8d 2344 clear_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags);
f5fc0f86 2345
71449f8d 2346 if (test_bit(WL1271_FLAG_PSM, &wl->flags))
d8c42c0c 2347 ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE,
8eab7b47 2348 wl->basic_rate, true);
f5fc0f86
LC		 2349 }
2350
2351 if (conf->power_level != wl->power_level) {
2352 ret = wl1271_acx_tx_power(wl, conf->power_level);
2353 if (ret < 0)
c6317a54 2354 goto out_sleep;
f5fc0f86
LC		 2355
2356 wl->power_level = conf->power_level;
2357 }
2358
2359out_sleep:
2360 wl1271_ps_elp_sleep(wl);
2361
2362out:
2363 mutex_unlock(&wl->mutex);
2364
2365 return ret;
2366}
2367
b54853f1
JO		 2368struct wl1271_filter_params {
2369 bool enabled;
2370 int mc_list_length;
2371 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
2372};
2373
22bedad3
JP		 2374static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
2375 struct netdev_hw_addr_list *mc_list)
c87dec9f 2376{
c87dec9f 2377 struct wl1271_filter_params *fp;
22bedad3 2378 struct netdev_hw_addr *ha;
2c10bb9c 2379 struct wl1271 *wl = hw->priv;
c87dec9f 2380
2c10bb9c
SD		 2381 if (unlikely(wl->state == WL1271_STATE_OFF))
2382 return 0;
c87dec9f 2383
74441130 2384 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 2385 if (!fp) {
2386 wl1271_error("Out of memory setting filters.");
2387 return 0;
2388 }
2389
2390 /* update multicast filtering parameters */
c87dec9f 2391 fp->mc_list_length = 0;
22bedad3
JP		 2392 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
2393 fp->enabled = false;
2394 } else {
2395 fp->enabled = true;
2396 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 2397 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 2398 ha->addr, ETH_ALEN);
c87dec9f 2399 fp->mc_list_length++;
22bedad3 2400 }
c87dec9f
JO		 2401 }
2402
b54853f1 2403 return (u64)(unsigned long)fp;
c87dec9f 2404}
f5fc0f86 2405
b54853f1
JO		 2406#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
2407 FIF_ALLMULTI | \
2408 FIF_FCSFAIL | \
2409 FIF_BCN_PRBRESP_PROMISC | \
2410 FIF_CONTROL | \
2411 FIF_OTHER_BSS)
2412
f5fc0f86
LC		 2413static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
2414 unsigned int changed,
c87dec9f 2415 unsigned int *total, u64 multicast)
f5fc0f86 2416{
b54853f1 2417 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 2418 struct wl1271 *wl = hw->priv;
b54853f1 2419 int ret;
f5fc0f86 2420
7d057869
AN		 2421 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
2422 " total %x", changed, *total);
f5fc0f86 2423
b54853f1
JO		 2424 mutex_lock(&wl->mutex);
2425
2c10bb9c
SD		 2426 *total &= WL1271_SUPPORTED_FILTERS;
2427 changed &= WL1271_SUPPORTED_FILTERS;
2428
2429 if (unlikely(wl->state == WL1271_STATE_OFF))
b54853f1
JO		 2430 goto out;
2431
a620865e 2432 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 2433 if (ret < 0)
2434 goto out;
2435
7d057869
AN		 2436 if (wl->bss_type != BSS_TYPE_AP_BSS) {
2437 if (*total & FIF_ALLMULTI)
2438 ret = wl1271_acx_group_address_tbl(wl, false, NULL, 0);
2439 else if (fp)
2440 ret = wl1271_acx_group_address_tbl(wl, fp->enabled,
2441 fp->mc_list,
2442 fp->mc_list_length);
2443 if (ret < 0)
2444 goto out_sleep;
2445 }
f5fc0f86 2446
08c1d1c7
EP		 2447 /*
2448 * the fw doesn't provide an api to configure the filters. instead,
2449 * the filters configuration is based on the active roles / ROC
2450 * state.
2451 */
b54853f1
JO		 2452
2453out_sleep:
2454 wl1271_ps_elp_sleep(wl);
2455
2456out:
2457 mutex_unlock(&wl->mutex);
14b228a0 2458 kfree(fp);
f5fc0f86
LC		 2459}
2460
7f179b46
AN		 2461static int wl1271_record_ap_key(struct wl1271 *wl, u8 id, u8 key_type,
2462 u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
2463 u16 tx_seq_16)
2464{
2465 struct wl1271_ap_key *ap_key;
2466 int i;
2467
2468 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
2469
2470 if (key_size > MAX_KEY_SIZE)
2471 return -EINVAL;
2472
2473 /*
2474 * Find next free entry in ap_keys. Also check we are not replacing
2475 * an existing key.
2476 */
2477 for (i = 0; i < MAX_NUM_KEYS; i++) {
2478 if (wl->recorded_ap_keys[i] == NULL)
2479 break;
2480
2481 if (wl->recorded_ap_keys[i]->id == id) {
2482 wl1271_warning("trying to record key replacement");
2483 return -EINVAL;
2484 }
2485 }
2486
2487 if (i == MAX_NUM_KEYS)
2488 return -EBUSY;
2489
2490 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
2491 if (!ap_key)
2492 return -ENOMEM;
2493
2494 ap_key->id = id;
2495 ap_key->key_type = key_type;
2496 ap_key->key_size = key_size;
2497 memcpy(ap_key->key, key, key_size);
2498 ap_key->hlid = hlid;
2499 ap_key->tx_seq_32 = tx_seq_32;
2500 ap_key->tx_seq_16 = tx_seq_16;
2501
2502 wl->recorded_ap_keys[i] = ap_key;
2503 return 0;
2504}
2505
2506static void wl1271_free_ap_keys(struct wl1271 *wl)
2507{
2508 int i;
2509
2510 for (i = 0; i < MAX_NUM_KEYS; i++) {
2511 kfree(wl->recorded_ap_keys[i]);
2512 wl->recorded_ap_keys[i] = NULL;
2513 }
2514}
2515
2516static int wl1271_ap_init_hwenc(struct wl1271 *wl)
2517{
2518 int i, ret = 0;
2519 struct wl1271_ap_key *key;
2520 bool wep_key_added = false;
2521
2522 for (i = 0; i < MAX_NUM_KEYS; i++) {
2523 if (wl->recorded_ap_keys[i] == NULL)
2524 break;
2525
2526 key = wl->recorded_ap_keys[i];
2527 ret = wl1271_cmd_set_ap_key(wl, KEY_ADD_OR_REPLACE,
2528 key->id, key->key_type,
2529 key->key_size, key->key,
2530 key->hlid, key->tx_seq_32,
2531 key->tx_seq_16);
2532 if (ret < 0)
2533 goto out;
2534
2535 if (key->key_type == KEY_WEP)
2536 wep_key_added = true;
2537 }
2538
2539 if (wep_key_added) {
c690ec81
EP		 2540 ret = wl12xx_cmd_set_default_wep_key(wl, wl->default_key,
2541 WL1271_AP_BROADCAST_HLID);
7f179b46
AN		 2542 if (ret < 0)
2543 goto out;
2544 }
2545
2546out:
2547 wl1271_free_ap_keys(wl);
2548 return ret;
2549}
2550
2551static int wl1271_set_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
2552 u8 key_size, const u8 *key, u32 tx_seq_32,
2553 u16 tx_seq_16, struct ieee80211_sta *sta)
2554{
2555 int ret;
2556 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2557
2558 if (is_ap) {
2559 struct wl1271_station *wl_sta;
2560 u8 hlid;
2561
2562 if (sta) {
2563 wl_sta = (struct wl1271_station *)sta->drv_priv;
2564 hlid = wl_sta->hlid;
2565 } else {
2566 hlid = WL1271_AP_BROADCAST_HLID;
2567 }
2568
2569 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
2570 /*
2571 * We do not support removing keys after AP shutdown.
2572 * Pretend we do to make mac80211 happy.
2573 */
2574 if (action != KEY_ADD_OR_REPLACE)
2575 return 0;
2576
2577 ret = wl1271_record_ap_key(wl, id,
2578 key_type, key_size,
2579 key, hlid, tx_seq_32,
2580 tx_seq_16);
2581 } else {
2582 ret = wl1271_cmd_set_ap_key(wl, action,
2583 id, key_type, key_size,
2584 key, hlid, tx_seq_32,
2585 tx_seq_16);
2586 }
2587
2588 if (ret < 0)
2589 return ret;
2590 } else {
2591 const u8 *addr;
2592 static const u8 bcast_addr[ETH_ALEN] = {
2593 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2594 };
2595
2596 addr = sta ? sta->addr : bcast_addr;
2597
2598 if (is_zero_ether_addr(addr)) {
2599 /* We dont support TX only encryption */
2600 return -EOPNOTSUPP;
2601 }
2602
2603 /* The wl1271 does not allow to remove unicast keys - they
2604 will be cleared automatically on next CMD_JOIN. Ignore the
2605 request silently, as we dont want the mac80211 to emit
2606 an error message. */
2607 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
2608 return 0;
2609
2610 ret = wl1271_cmd_set_sta_key(wl, action,
2611 id, key_type, key_size,
2612 key, addr, tx_seq_32,
2613 tx_seq_16);
2614 if (ret < 0)
2615 return ret;
2616
2617 /* the default WEP key needs to be configured at least once */
2618 if (key_type == KEY_WEP) {
c690ec81
EP		 2619 ret = wl12xx_cmd_set_default_wep_key(wl,
2620 wl->default_key,
2621 wl->sta_hlid);
7f179b46
AN		 2622 if (ret < 0)
2623 return ret;
2624 }
2625 }
2626
2627 return 0;
2628}
2629
f5fc0f86
LC		 2630static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2631 struct ieee80211_vif *vif,
2632 struct ieee80211_sta *sta,
2633 struct ieee80211_key_conf *key_conf)
2634{
2635 struct wl1271 *wl = hw->priv;
f5fc0f86 2636 int ret;
ac4e4ce5
JO		 2637 u32 tx_seq_32 = 0;
2638 u16 tx_seq_16 = 0;
f5fc0f86
LC		 2639 u8 key_type;
2640
f5fc0f86
LC		 2641 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
2642
7f179b46 2643 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 2644 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 2645 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 2646 key_conf->keylen, key_conf->flags);
2647 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
2648
f5fc0f86
LC		 2649 mutex_lock(&wl->mutex);
2650
f8d9802f
JO		 2651 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2652 ret = -EAGAIN;
2653 goto out_unlock;
2654 }
2655
a620865e 2656 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2657 if (ret < 0)
2658 goto out_unlock;
2659
97359d12
JB		 2660 switch (key_conf->cipher) {
2661 case WLAN_CIPHER_SUITE_WEP40:
2662 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 2663 key_type = KEY_WEP;
2664
2665 key_conf->hw_key_idx = key_conf->keyidx;
2666 break;
97359d12 2667 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86
LC		 2668 key_type = KEY_TKIP;
2669
2670 key_conf->hw_key_idx = key_conf->keyidx;
04e36fc5
JO		 2671 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2672 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2673 break;
97359d12 2674 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86
LC		 2675 key_type = KEY_AES;
2676
2677 key_conf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
04e36fc5
JO		 2678 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2679 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
f5fc0f86 2680 break;
7a55724e
JO		 2681 case WL1271_CIPHER_SUITE_GEM:
2682 key_type = KEY_GEM;
2683 tx_seq_32 = WL1271_TX_SECURITY_HI32(wl->tx_security_seq);
2684 tx_seq_16 = WL1271_TX_SECURITY_LO16(wl->tx_security_seq);
2685 break;
f5fc0f86 2686 default:
97359d12 2687 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86
LC		 2688
2689 ret = -EOPNOTSUPP;
2690 goto out_sleep;
2691 }
2692
2693 switch (cmd) {
2694 case SET_KEY:
7f179b46
AN		 2695 ret = wl1271_set_key(wl, KEY_ADD_OR_REPLACE,
2696 key_conf->keyidx, key_type,
2697 key_conf->keylen, key_conf->key,
2698 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 2699 if (ret < 0) {
2700 wl1271_error("Could not add or replace key");
2701 goto out_sleep;
2702 }
2703 break;
2704
2705 case DISABLE_KEY:
7f179b46
AN		 2706 ret = wl1271_set_key(wl, KEY_REMOVE,
2707 key_conf->keyidx, key_type,
2708 key_conf->keylen, key_conf->key,
2709 0, 0, sta);
f5fc0f86
LC		 2710 if (ret < 0) {
2711 wl1271_error("Could not remove key");
2712 goto out_sleep;
2713 }
2714 break;
2715
2716 default:
2717 wl1271_error("Unsupported key cmd 0x%x", cmd);
2718 ret = -EOPNOTSUPP;
f5fc0f86
LC		 2719 break;
2720 }
2721
2722out_sleep:
2723 wl1271_ps_elp_sleep(wl);
2724
2725out_unlock:
2726 mutex_unlock(&wl->mutex);
2727
f5fc0f86
LC		 2728 return ret;
2729}
2730
2731static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 2732 struct ieee80211_vif *vif,
f5fc0f86
LC		 2733 struct cfg80211_scan_request *req)
2734{
2735 struct wl1271 *wl = hw->priv;
2736 int ret;
2737 u8 *ssid = NULL;
abb0b3bf 2738 size_t len = 0;
f5fc0f86
LC		 2739
2740 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
2741
2742 if (req->n_ssids) {
2743 ssid = req->ssids[0].ssid;
abb0b3bf 2744 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 2745 }
2746
2747 mutex_lock(&wl->mutex);
2748
b739a42c
JO		 2749 if (wl->state == WL1271_STATE_OFF) {
2750 /*
2751 * We cannot return -EBUSY here because cfg80211 will expect
2752 * a call to ieee80211_scan_completed if we do - in this case
2753 * there won't be any call.
2754 */
2755 ret = -EAGAIN;
2756 goto out;
2757 }
2758
a620865e 2759 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2760 if (ret < 0)
2761 goto out;
2762
251c177f
EP		 2763 /* cancel ROC before scanning */
2764 if (wl12xx_is_roc(wl)) {
2765 if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
2766 /* don't allow scanning right now */
2767 ret = -EBUSY;
2768 goto out_sleep;
2769 }
2770 wl12xx_croc(wl, wl->dev_role_id);
2771 wl12xx_cmd_role_stop_dev(wl);
2772 }
f5fc0f86 2773
251c177f
EP		 2774 ret = wl1271_scan(hw->priv, ssid, len, req);
2775out_sleep:
f5fc0f86 2776 wl1271_ps_elp_sleep(wl);
f5fc0f86
LC		 2777out:
2778 mutex_unlock(&wl->mutex);
2779
2780 return ret;
2781}
2782
73ecce31
EP		 2783static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
2784 struct ieee80211_vif *vif)
2785{
2786 struct wl1271 *wl = hw->priv;
2787 int ret;
2788
2789 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
2790
2791 mutex_lock(&wl->mutex);
2792
2793 if (wl->state == WL1271_STATE_OFF)
2794 goto out;
2795
2796 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
2797 goto out;
2798
2799 ret = wl1271_ps_elp_wakeup(wl);
2800 if (ret < 0)
2801 goto out;
2802
2803 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
2804 ret = wl1271_scan_stop(wl);
2805 if (ret < 0)
2806 goto out_sleep;
2807 }
2808 wl->scan.state = WL1271_SCAN_STATE_IDLE;
2809 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2810 wl->scan.req = NULL;
2811 ieee80211_scan_completed(wl->hw, true);
2812
2813out_sleep:
2814 wl1271_ps_elp_sleep(wl);
2815out:
2816 mutex_unlock(&wl->mutex);
2817
2818 cancel_delayed_work_sync(&wl->scan_complete_work);
2819}
2820
33c2c06c
LC		 2821static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
2822 struct ieee80211_vif *vif,
2823 struct cfg80211_sched_scan_request *req,
2824 struct ieee80211_sched_scan_ies *ies)
2825{
2826 struct wl1271 *wl = hw->priv;
2827 int ret;
2828
2829 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
2830
2831 mutex_lock(&wl->mutex);
2832
2833 ret = wl1271_ps_elp_wakeup(wl);
2834 if (ret < 0)
2835 goto out;
2836
2837 ret = wl1271_scan_sched_scan_config(wl, req, ies);
2838 if (ret < 0)
2839 goto out_sleep;
2840
2841 ret = wl1271_scan_sched_scan_start(wl);
2842 if (ret < 0)
2843 goto out_sleep;
2844
2845 wl->sched_scanning = true;
2846
2847out_sleep:
2848 wl1271_ps_elp_sleep(wl);
2849out:
2850 mutex_unlock(&wl->mutex);
2851 return ret;
2852}
2853
2854static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
2855 struct ieee80211_vif *vif)
2856{
2857 struct wl1271 *wl = hw->priv;
2858 int ret;
2859
2860 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
2861
2862 mutex_lock(&wl->mutex);
2863
2864 ret = wl1271_ps_elp_wakeup(wl);
2865 if (ret < 0)
2866 goto out;
2867
2868 wl1271_scan_sched_scan_stop(wl);
2869
2870 wl1271_ps_elp_sleep(wl);
2871out:
2872 mutex_unlock(&wl->mutex);
2873}
2874
68d069c4
AN		 2875static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2876{
2877 struct wl1271 *wl = hw->priv;
2878 int ret = 0;
2879
2880 mutex_lock(&wl->mutex);
2881
2882 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2883 ret = -EAGAIN;
2884 goto out;
2885 }
2886
a620865e 2887 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 2888 if (ret < 0)
2889 goto out;
2890
5f704d18 2891 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 2892 if (ret < 0)
2893 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
2894
2895 wl1271_ps_elp_sleep(wl);
2896
2897out:
2898 mutex_unlock(&wl->mutex);
2899
2900 return ret;
2901}
2902
f5fc0f86
LC		 2903static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2904{
2905 struct wl1271 *wl = hw->priv;
aecb0565 2906 int ret = 0;
f5fc0f86
LC		 2907
2908 mutex_lock(&wl->mutex);
2909
f8d9802f
JO		 2910 if (unlikely(wl->state == WL1271_STATE_OFF)) {
2911 ret = -EAGAIN;
aecb0565 2912 goto out;
f8d9802f 2913 }
aecb0565 2914
a620865e 2915 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 2916 if (ret < 0)
2917 goto out;
2918
5f704d18 2919 ret = wl1271_acx_rts_threshold(wl, value);
f5fc0f86
LC		 2920 if (ret < 0)
2921 wl1271_warning("wl1271_op_set_rts_threshold failed: %d", ret);
2922
2923 wl1271_ps_elp_sleep(wl);
2924
2925out:
2926 mutex_unlock(&wl->mutex);
2927
2928 return ret;
2929}
2930
e78a287a 2931static int wl1271_ssid_set(struct wl1271 *wl, struct sk_buff *skb,
2f6724b2 2932 int offset)
30240fc7 2933{
889cb360
EP		 2934 u8 ssid_len;
2935 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2936 skb->len - offset);
30240fc7 2937
889cb360
EP		 2938 if (!ptr) {
2939 wl1271_error("No SSID in IEs!");
2940 return -ENOENT;
2941 }
2942
2943 ssid_len = ptr[1];
2944 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2945 wl1271_error("SSID is too long!");
2946 return -EINVAL;
30240fc7 2947 }
e78a287a 2948
889cb360
EP		 2949 wl->ssid_len = ssid_len;
2950 memcpy(wl->ssid, ptr+2, ssid_len);
2951 return 0;
30240fc7
JO		 2952}
2953
e78a287a 2954static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
f5fc0f86
LC		 2955 struct ieee80211_bss_conf *bss_conf,
2956 u32 changed)
2957{
e78a287a 2958 int ret = 0;
f5fc0f86 2959
e78a287a
AN		 2960 if (changed & BSS_CHANGED_ERP_SLOT) {
2961 if (bss_conf->use_short_slot)
2962 ret = wl1271_acx_slot(wl, SLOT_TIME_SHORT);
2963 else
2964 ret = wl1271_acx_slot(wl, SLOT_TIME_LONG);
2965 if (ret < 0) {
2966 wl1271_warning("Set slot time failed %d", ret);
2967 goto out;
2968 }
2969 }
f5fc0f86 2970
e78a287a
AN		 2971 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2972 if (bss_conf->use_short_preamble)
2973 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_SHORT);
2974 else
2975 wl1271_acx_set_preamble(wl, ACX_PREAMBLE_LONG);
2976 }
f5fc0f86 2977
e78a287a
AN		 2978 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2979 if (bss_conf->use_cts_prot)
2980 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_ENABLE);
2981 else
2982 ret = wl1271_acx_cts_protect(wl, CTSPROTECT_DISABLE);
2983 if (ret < 0) {
2984 wl1271_warning("Set ctsprotect failed %d", ret);
2985 goto out;
2986 }
2987 }
f8d9802f 2988
e78a287a
AN		 2989out:
2990 return ret;
2991}
f5fc0f86 2992
e78a287a
AN		 2993static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
2994 struct ieee80211_vif *vif,
2995 struct ieee80211_bss_conf *bss_conf,
2996 u32 changed)
2997{
2998 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
2999 int ret = 0;
3000
3001 if ((changed & BSS_CHANGED_BEACON_INT)) {
3002 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 3003 bss_conf->beacon_int);
3004
3005 wl->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 3006 }
3007
e78a287a
AN		 3008 if ((changed & BSS_CHANGED_BEACON)) {
3009 struct ieee80211_hdr *hdr;
3010 int ieoffset = offsetof(struct ieee80211_mgmt,
3011 u.beacon.variable);
3012 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3013 u16 tmpl_id;
3014
3015 if (!beacon)
3016 goto out;
3017
3018 wl1271_debug(DEBUG_MASTER, "beacon updated");
3019
3020 ret = wl1271_ssid_set(wl, beacon, ieoffset);
3021 if (ret < 0) {
3022 dev_kfree_skb(beacon);
3023 goto out;
3024 }
3025 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3026 CMD_TEMPL_BEACON;
3027 ret = wl1271_cmd_template_set(wl, tmpl_id,
3028 beacon->data,
3029 beacon->len, 0,
3030 wl1271_tx_min_rate_get(wl));
3031 if (ret < 0) {
3032 dev_kfree_skb(beacon);
3033 goto out;
3034 }
3035
3036 hdr = (struct ieee80211_hdr *) beacon->data;
3037 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3038 IEEE80211_STYPE_PROBE_RESP);
3039
3040 tmpl_id = is_ap ? CMD_TEMPL_AP_PROBE_RESPONSE :
3041 CMD_TEMPL_PROBE_RESPONSE;
3042 ret = wl1271_cmd_template_set(wl,
3043 tmpl_id,
3044 beacon->data,
3045 beacon->len, 0,
3046 wl1271_tx_min_rate_get(wl));
3047 dev_kfree_skb(beacon);
3048 if (ret < 0)
3049 goto out;
3050 }
3051
3052out:
3053 return ret;
3054}
3055
3056/* AP mode changes */
3057static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3058 struct ieee80211_vif *vif,
3059 struct ieee80211_bss_conf *bss_conf,
3060 u32 changed)
3061{
3062 int ret = 0;
e0d8bbf0 3063
e78a287a
AN		 3064 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3065 u32 rates = bss_conf->basic_rates;
5da11dcd 3066
e78a287a
AN		 3067 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates);
3068 wl->basic_rate = wl1271_tx_min_rate_get(wl);
70f47424
AN		 3069
3070 ret = wl1271_init_ap_rates(wl);
e78a287a 3071 if (ret < 0) {
70f47424 3072 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 3073 goto out;
3074 }
c45a85b5
AN		 3075
3076 ret = wl1271_ap_init_templates(wl);
3077 if (ret < 0)
3078 goto out;
e78a287a 3079 }
2f6724b2 3080
e78a287a
AN		 3081 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3082 if (ret < 0)
3083 goto out;
30240fc7 3084
e78a287a
AN		 3085 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3086 if (bss_conf->enable_beacon) {
3087 if (!test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
c690ec81 3088 ret = wl12xx_cmd_role_start_ap(wl);
e78a287a
AN		 3089 if (ret < 0)
3090 goto out;
e0d8bbf0 3091
e78a287a
AN		 3092 set_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3093 wl1271_debug(DEBUG_AP, "started AP");
7f179b46
AN		 3094
3095 ret = wl1271_ap_init_hwenc(wl);
3096 if (ret < 0)
3097 goto out;
e0d8bbf0 3098 }
e78a287a
AN		 3099 } else {
3100 if (test_bit(WL1271_FLAG_AP_STARTED, &wl->flags)) {
c690ec81 3101 ret = wl12xx_cmd_role_stop_ap(wl);
e78a287a
AN		 3102 if (ret < 0)
3103 goto out;
e0d8bbf0 3104
e78a287a
AN		 3105 clear_bit(WL1271_FLAG_AP_STARTED, &wl->flags);
3106 wl1271_debug(DEBUG_AP, "stopped AP");
3107 }
3108 }
3109 }
e0d8bbf0 3110
e78a287a
AN		 3111 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3112 if (ret < 0)
3113 goto out;
3114out:
3115 return;
3116}
8bf29b0e 3117
e78a287a
AN		 3118/* STA/IBSS mode changes */
3119static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3120 struct ieee80211_vif *vif,
3121 struct ieee80211_bss_conf *bss_conf,
3122 u32 changed)
3123{
3124 bool do_join = false, set_assoc = false;
3125 bool is_ibss = (wl->bss_type == BSS_TYPE_IBSS);
72c2d9e5 3126 u32 sta_rate_set = 0;
e78a287a 3127 int ret;
2d6e4e76 3128 struct ieee80211_sta *sta;
a100885d
AN		 3129 bool sta_exists = false;
3130 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 3131
3132 if (is_ibss) {
3133 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3134 changed);
3135 if (ret < 0)
3136 goto out;
e0d8bbf0
JO		 3137 }
3138
e78a287a
AN		 3139 if ((changed & BSS_CHANGED_BEACON_INT) && is_ibss)
3140 do_join = true;
3141
3142 /* Need to update the SSID (for filtering etc) */
3143 if ((changed & BSS_CHANGED_BEACON) && is_ibss)
3144 do_join = true;
3145
3146 if ((changed & BSS_CHANGED_BEACON_ENABLED) && is_ibss) {
5da11dcd
JO		 3147 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3148 bss_conf->enable_beacon ? "enabled" : "disabled");
3149
3150 if (bss_conf->enable_beacon)
3151 wl->set_bss_type = BSS_TYPE_IBSS;
3152 else
3153 wl->set_bss_type = BSS_TYPE_STA_BSS;
3154 do_join = true;
3155 }
3156
e78a287a 3157 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 3158 bool enable = false;
3159 if (bss_conf->cqm_rssi_thold)
3160 enable = true;
3161 ret = wl1271_acx_rssi_snr_trigger(wl, enable,
3162 bss_conf->cqm_rssi_thold,
3163 bss_conf->cqm_rssi_hyst);
3164 if (ret < 0)
3165 goto out;
3166 wl->rssi_thold = bss_conf->cqm_rssi_thold;
3167 }
3168
30240fc7
JO		 3169 if ((changed & BSS_CHANGED_BSSID) &&
3170 /*
3171 * Now we know the correct bssid, so we send a new join command
3172 * and enable the BSSID filter
3173 */
3174 memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) {
e78a287a 3175 memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN);
a0cb7be4 3176
fa287b8f
EP		 3177 if (!is_zero_ether_addr(wl->bssid)) {
3178 ret = wl1271_cmd_build_null_data(wl);
3179 if (ret < 0)
3180 goto out;
30240fc7 3181
fa287b8f
EP		 3182 ret = wl1271_build_qos_null_data(wl);
3183 if (ret < 0)
3184 goto out;
30240fc7 3185
fa287b8f
EP		 3186 /* Need to update the BSSID (for filtering etc) */
3187 do_join = true;
3188 }
30240fc7
JO		 3189 }
3190
72c2d9e5
EP		 3191 rcu_read_lock();
3192 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3193 if (sta) {
3194 /* save the supp_rates of the ap */
3195 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3196 if (sta->ht_cap.ht_supported)
3197 sta_rate_set |=
3198 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 3199 sta_ht_cap = sta->ht_cap;
3200 sta_exists = true;
3201 }
3202 rcu_read_unlock();
72c2d9e5 3203
a100885d 3204 if (sta_exists) {
72c2d9e5
EP		 3205 /* handle new association with HT and HT information change */
3206 if ((changed & BSS_CHANGED_HT) &&
3207 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
a100885d 3208 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 3209 true);
3210 if (ret < 0) {
3211 wl1271_warning("Set ht cap true failed %d",
3212 ret);
72c2d9e5
EP		 3213 goto out;
3214 }
3215 ret = wl1271_acx_set_ht_information(wl,
3216 bss_conf->ht_operation_mode);
3217 if (ret < 0) {
3218 wl1271_warning("Set ht information failed %d",
3219 ret);
72c2d9e5
EP		 3220 goto out;
3221 }
3222 }
3223 /* handle new association without HT and disassociation */
3224 else if (changed & BSS_CHANGED_ASSOC) {
a100885d 3225 ret = wl1271_acx_set_ht_capabilities(wl, &sta_ht_cap,
72c2d9e5
EP		 3226 false);
3227 if (ret < 0) {
3228 wl1271_warning("Set ht cap false failed %d",
3229 ret);
72c2d9e5
EP		 3230 goto out;
3231 }
3232 }
3233 }
72c2d9e5 3234
e78a287a 3235 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 3236 if (bss_conf->assoc) {
ebba60c6 3237 u32 rates;
2f6724b2 3238 int ieoffset;
f5fc0f86 3239 wl->aid = bss_conf->aid;
69e5434c 3240 set_assoc = true;
f5fc0f86 3241
90494a90
JO		 3242 wl->ps_poll_failures = 0;
3243
ebba60c6
JO		 3244 /*
3245 * use basic rates from AP, and determine lowest rate
3246 * to use with control frames.
3247 */
3248 rates = bss_conf->basic_rates;
3249 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3250 rates);
e0fe371b 3251 wl->basic_rate = wl1271_tx_min_rate_get(wl);
72c2d9e5
EP		 3252 if (sta_rate_set)
3253 wl->rate_set = wl1271_tx_enabled_rates_get(wl,
3254 sta_rate_set);
79b223f4 3255 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3256 if (ret < 0)
e78a287a 3257 goto out;
ebba60c6 3258
ae751bab
LC		 3259 /*
3260 * with wl1271, we don't need to update the
3261 * beacon_int and dtim_period, because the firmware
3262 * updates it by itself when the first beacon is
3263 * received after a join.
3264 */
f5fc0f86
LC		 3265 ret = wl1271_cmd_build_ps_poll(wl, wl->aid);
3266 if (ret < 0)
e78a287a 3267 goto out;
f5fc0f86 3268
c2b2d99b 3269 /*
2f6724b2 3270 * Get a template for hardware connection maintenance
c2b2d99b 3271 */
2f6724b2
JO		 3272 dev_kfree_skb(wl->probereq);
3273 wl->probereq = wl1271_cmd_build_ap_probe_req(wl, NULL);
3274 ieoffset = offsetof(struct ieee80211_mgmt,
3275 u.probe_req.variable);
3276 wl1271_ssid_set(wl, wl->probereq, ieoffset);
c2b2d99b 3277
6ccbb92e
JO		 3278 /* enable the connection monitoring feature */
3279 ret = wl1271_acx_conn_monit_params(wl, true);
f5fc0f86 3280 if (ret < 0)
e78a287a 3281 goto out;
f5fc0f86
LC		 3282
3283 /* If we want to go in PSM but we're not there yet */
71449f8d
JO		 3284 if (test_bit(WL1271_FLAG_PSM_REQUESTED, &wl->flags) &&
3285 !test_bit(WL1271_FLAG_PSM, &wl->flags)) {
e78a287a
AN		 3286 enum wl1271_cmd_ps_mode mode;
3287
f5fc0f86 3288 mode = STATION_POWER_SAVE_MODE;
65cddbf1 3289 ret = wl1271_ps_set_mode(wl, mode,
8eab7b47 3290 wl->basic_rate,
65cddbf1 3291 true);
f5fc0f86 3292 if (ret < 0)
e78a287a 3293 goto out;
f5fc0f86 3294 }
d94cd297
JO		 3295 } else {
3296 /* use defaults when not associated */
30df14d0
EP		 3297 bool was_assoc =
3298 !!test_and_clear_bit(WL1271_FLAG_STA_ASSOCIATED,
3299 &wl->flags);
251c177f
EP		 3300 bool was_ifup =
3301 !!test_and_clear_bit(WL1271_FLAG_STA_STATE_SENT,
3302 &wl->flags);
d94cd297 3303 wl->aid = 0;
6ccbb92e 3304
2f6724b2
JO		 3305 /* free probe-request template */
3306 dev_kfree_skb(wl->probereq);
3307 wl->probereq = NULL;
3308
8d2ef7bd 3309 /* re-enable dynamic ps - just in case */
f532be6d 3310 ieee80211_enable_dyn_ps(wl->vif);
8d2ef7bd 3311
ebba60c6
JO		 3312 /* revert back to minimum rates for the current band */
3313 wl1271_set_band_rate(wl);
e0fe371b 3314 wl->basic_rate = wl1271_tx_min_rate_get(wl);
79b223f4 3315 ret = wl1271_acx_sta_rate_policies(wl);
ebba60c6 3316 if (ret < 0)
e78a287a 3317 goto out;
ebba60c6 3318
6ccbb92e
JO		 3319 /* disable connection monitor features */
3320 ret = wl1271_acx_conn_monit_params(wl, false);
c1899554
JO		 3321
3322 /* Disable the keep-alive feature */
3323 ret = wl1271_acx_keep_alive_mode(wl, false);
6ccbb92e 3324 if (ret < 0)
e78a287a 3325 goto out;
b84a7d3d
JO		 3326
3327 /* restore the bssid filter and go to dummy bssid */
30df14d0 3328 if (was_assoc) {
251c177f
EP		 3329 u32 conf_flags = wl->hw->conf.flags;
3330 /*
3331 * we might have to disable roc, if there was
3332 * no IF_OPER_UP notification.
3333 */
3334 if (!was_ifup) {
3335 ret = wl12xx_croc(wl, wl->role_id);
3336 if (ret < 0)
3337 goto out;
3338 }
3339 /*
3340 * (we also need to disable roc in case of
3341 * roaming on the same channel. until we will
3342 * have a better flow...)
3343 */
3344 if (test_bit(wl->dev_role_id, wl->roc_map)) {
3345 ret = wl12xx_croc(wl, wl->dev_role_id);
3346 if (ret < 0)
3347 goto out;
3348 }
3349
30df14d0 3350 wl1271_unjoin(wl);
251c177f
EP		 3351 if (!(conf_flags & IEEE80211_CONF_IDLE)) {
3352 wl12xx_cmd_role_start_dev(wl);
3353 wl12xx_roc(wl, wl->dev_role_id);
3354 }
30df14d0 3355 }
f5fc0f86 3356 }
f5fc0f86
LC		 3357 }
3358
d192d268
EP		 3359 if (changed & BSS_CHANGED_IBSS) {
3360 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3361 bss_conf->ibss_joined);
3362
3363 if (bss_conf->ibss_joined) {
3364 u32 rates = bss_conf->basic_rates;
3365 wl->basic_rate_set = wl1271_tx_enabled_rates_get(wl,
3366 rates);
3367 wl->basic_rate = wl1271_tx_min_rate_get(wl);
3368
3369 /* by default, use 11b rates */
3370 wl->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3371 ret = wl1271_acx_sta_rate_policies(wl);
3372 if (ret < 0)
3373 goto out;
3374 }
3375 }
3376
e78a287a
AN		 3377 ret = wl1271_bss_erp_info_changed(wl, bss_conf, changed);
3378 if (ret < 0)
3379 goto out;
f5fc0f86 3380
ca52a5eb
JO		 3381 if (changed & BSS_CHANGED_ARP_FILTER) {
3382 __be32 addr = bss_conf->arp_addr_list[0];
3383 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3384
c5312772
EP		 3385 if (bss_conf->arp_addr_cnt == 1 &&
3386 bss_conf->arp_filter_enabled) {
3387 /*
3388 * The template should have been configured only upon
3389 * association. however, it seems that the correct ip
3390 * isn't being set (when sending), so we have to
3391 * reconfigure the template upon every ip change.
3392 */
3393 ret = wl1271_cmd_build_arp_rsp(wl, addr);
3394 if (ret < 0) {
3395 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 3396 goto out;
c5312772
EP		 3397 }
3398
3399 ret = wl1271_acx_arp_ip_filter(wl,
e5e2f24b 3400 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 3401 addr);
3402 } else
3403 ret = wl1271_acx_arp_ip_filter(wl, 0, addr);
ca52a5eb
JO		 3404
3405 if (ret < 0)
e78a287a 3406 goto out;
ca52a5eb
JO		 3407 }
3408
8bf29b0e 3409 if (do_join) {
69e5434c 3410 ret = wl1271_join(wl, set_assoc);
8bf29b0e
JO		 3411 if (ret < 0) {
3412 wl1271_warning("cmd join failed %d", ret);
e78a287a 3413 goto out;
8bf29b0e 3414 }
251c177f
EP		 3415
3416 /* ROC until connected (after EAPOL exchange) */
3417 if (!is_ibss) {
3418 ret = wl12xx_roc(wl, wl->role_id);
3419 if (ret < 0)
3420 goto out;
3421
3422 wl1271_check_operstate(wl,
3423 ieee80211_get_operstate(vif));
3424 }
3425 /*
3426 * stop device role if started (we might already be in
3427 * STA role). TODO: make it better.
3428 */
3429 if (wl->dev_role_id != WL12XX_INVALID_ROLE_ID) {
3430 ret = wl12xx_croc(wl, wl->dev_role_id);
3431 if (ret < 0)
3432 goto out;
3433
3434 ret = wl12xx_cmd_role_stop_dev(wl);
3435 if (ret < 0)
3436 goto out;
3437 }
c1899554
JO		 3438 }
3439
e78a287a
AN		 3440out:
3441 return;
3442}
3443
3444static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3445 struct ieee80211_vif *vif,
3446 struct ieee80211_bss_conf *bss_conf,
3447 u32 changed)
3448{
3449 struct wl1271 *wl = hw->priv;
3450 bool is_ap = (wl->bss_type == BSS_TYPE_AP_BSS);
3451 int ret;
3452
3453 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3454 (int)changed);
3455
3456 mutex_lock(&wl->mutex);
3457
3458 if (unlikely(wl->state == WL1271_STATE_OFF))
3459 goto out;
3460
a620865e 3461 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3462 if (ret < 0)
3463 goto out;
3464
3465 if (is_ap)
3466 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3467 else
3468 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3469
f5fc0f86
LC		 3470 wl1271_ps_elp_sleep(wl);
3471
3472out:
3473 mutex_unlock(&wl->mutex);
3474}
3475
c6999d83
KV		 3476static int wl1271_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
3477 const struct ieee80211_tx_queue_params *params)
3478{
3479 struct wl1271 *wl = hw->priv;
4695dc91 3480 u8 ps_scheme;
488fc540 3481 int ret = 0;
c6999d83
KV		 3482
3483 mutex_lock(&wl->mutex);
3484
3485 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3486
4695dc91
KV		 3487 if (params->uapsd)
3488 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3489 else
3490 ps_scheme = CONF_PS_SCHEME_LEGACY;
3491
488fc540
AN		 3492 if (wl->state == WL1271_STATE_OFF) {
3493 /*
3494 * If the state is off, the parameters will be recorded and
3495 * configured on init. This happens in AP-mode.
3496 */
3497 struct conf_tx_ac_category *conf_ac =
3498 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3499 struct conf_tx_tid *conf_tid =
3500 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3501
3502 conf_ac->ac = wl1271_tx_get_queue(queue);
3503 conf_ac->cw_min = (u8)params->cw_min;
3504 conf_ac->cw_max = params->cw_max;
3505 conf_ac->aifsn = params->aifs;
3506 conf_ac->tx_op_limit = params->txop << 5;
3507
3508 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3509 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3510 conf_tid->tsid = wl1271_tx_get_queue(queue);
3511 conf_tid->ps_scheme = ps_scheme;
3512 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3513 conf_tid->apsd_conf[0] = 0;
3514 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3515 goto out;
3516 }
488fc540 3517
c1b193eb
EP		 3518 ret = wl1271_ps_elp_wakeup(wl);
3519 if (ret < 0)
3520 goto out;
488fc540 3521
c1b193eb
EP		 3522 /*
3523 * the txop is confed in units of 32us by the mac80211,
3524 * we need us
3525 */
3526 ret = wl1271_acx_ac_cfg(wl, wl1271_tx_get_queue(queue),
3527 params->cw_min, params->cw_max,
3528 params->aifs, params->txop << 5);
3529 if (ret < 0)
3530 goto out_sleep;
3531
3532 ret = wl1271_acx_tid_cfg(wl, wl1271_tx_get_queue(queue),
3533 CONF_CHANNEL_TYPE_EDCF,
3534 wl1271_tx_get_queue(queue),
3535 ps_scheme, CONF_ACK_POLICY_LEGACY,
3536 0, 0);
c82c1dde
KV		 3537
3538out_sleep:
c1b193eb 3539 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 3540
3541out:
3542 mutex_unlock(&wl->mutex);
3543
3544 return ret;
3545}
3546
bbbb538e
JO		 3547static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw)
3548{
3549
3550 struct wl1271 *wl = hw->priv;
3551 u64 mactime = ULLONG_MAX;
3552 int ret;
3553
3554 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
3555
3556 mutex_lock(&wl->mutex);
3557
f8d9802f
JO		 3558 if (unlikely(wl->state == WL1271_STATE_OFF))
3559 goto out;
3560
a620865e 3561 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 3562 if (ret < 0)
3563 goto out;
3564
3565 ret = wl1271_acx_tsf_info(wl, &mactime);
3566 if (ret < 0)
3567 goto out_sleep;
3568
3569out_sleep:
3570 wl1271_ps_elp_sleep(wl);
3571
3572out:
3573 mutex_unlock(&wl->mutex);
3574 return mactime;
3575}
f5fc0f86 3576
ece550d0
JL		 3577static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
3578 struct survey_info *survey)
3579{
3580 struct wl1271 *wl = hw->priv;
3581 struct ieee80211_conf *conf = &hw->conf;
b739a42c 3582
ece550d0
JL		 3583 if (idx != 0)
3584 return -ENOENT;
b739a42c 3585
ece550d0
JL		 3586 survey->channel = conf->channel;
3587 survey->filled = SURVEY_INFO_NOISE_DBM;
3588 survey->noise = wl->noise;
b739a42c 3589
ece550d0
JL		 3590 return 0;
3591}
3592
409622ec 3593static int wl1271_allocate_sta(struct wl1271 *wl,
f84f7d78
AN		 3594 struct ieee80211_sta *sta,
3595 u8 *hlid)
3596{
3597 struct wl1271_station *wl_sta;
3598 int id;
3599
3600 id = find_first_zero_bit(wl->ap_hlid_map, AP_MAX_STATIONS);
3601 if (id >= AP_MAX_STATIONS) {
3602 wl1271_warning("could not allocate HLID - too much stations");
3603 return -EBUSY;
3604 }
3605
3606 wl_sta = (struct wl1271_station *)sta->drv_priv;
f84f7d78
AN		 3607 __set_bit(id, wl->ap_hlid_map);
3608 wl_sta->hlid = WL1271_AP_STA_HLID_START + id;
3609 *hlid = wl_sta->hlid;
b622d992 3610 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
f84f7d78
AN		 3611 return 0;
3612}
3613
409622ec 3614static void wl1271_free_sta(struct wl1271 *wl, u8 hlid)
f84f7d78
AN		 3615{
3616 int id = hlid - WL1271_AP_STA_HLID_START;
3617
409622ec
AN		 3618 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3619 return;
3620
f84f7d78 3621 __clear_bit(id, wl->ap_hlid_map);
b622d992 3622 memset(wl->links[hlid].addr, 0, ETH_ALEN);
a8c0ddb5 3623 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 3624 __clear_bit(hlid, &wl->ap_ps_map);
3625 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
f84f7d78
AN		 3626}
3627
3618f30f
AN		 3628bool wl1271_is_active_sta(struct wl1271 *wl, u8 hlid)
3629{
3630 int id = hlid - WL1271_AP_STA_HLID_START;
3631 return test_bit(id, wl->ap_hlid_map);
3632}
3633
f84f7d78
AN		 3634static int wl1271_op_sta_add(struct ieee80211_hw *hw,
3635 struct ieee80211_vif *vif,
3636 struct ieee80211_sta *sta)
3637{
3638 struct wl1271 *wl = hw->priv;
3639 int ret = 0;
3640 u8 hlid;
3641
3642 mutex_lock(&wl->mutex);
3643
3644 if (unlikely(wl->state == WL1271_STATE_OFF))
3645 goto out;
3646
3647 if (wl->bss_type != BSS_TYPE_AP_BSS)
3648 goto out;
3649
3650 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
3651
409622ec 3652 ret = wl1271_allocate_sta(wl, sta, &hlid);
f84f7d78
AN		 3653 if (ret < 0)
3654 goto out;
3655
a620865e 3656 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 3657 if (ret < 0)
409622ec 3658 goto out_free_sta;
f84f7d78 3659
c690ec81 3660 ret = wl12xx_cmd_add_peer(wl, sta, hlid);
f84f7d78
AN		 3661 if (ret < 0)
3662 goto out_sleep;
3663
3664out_sleep:
3665 wl1271_ps_elp_sleep(wl);
3666
409622ec
AN		 3667out_free_sta:
3668 if (ret < 0)
3669 wl1271_free_sta(wl, hlid);
3670
f84f7d78
AN		 3671out:
3672 mutex_unlock(&wl->mutex);
3673 return ret;
3674}
3675
3676static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
3677 struct ieee80211_vif *vif,
3678 struct ieee80211_sta *sta)
3679{
3680 struct wl1271 *wl = hw->priv;
3681 struct wl1271_station *wl_sta;
3682 int ret = 0, id;
3683
3684 mutex_lock(&wl->mutex);
3685
3686 if (unlikely(wl->state == WL1271_STATE_OFF))
3687 goto out;
3688
3689 if (wl->bss_type != BSS_TYPE_AP_BSS)
3690 goto out;
3691
3692 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
3693
3694 wl_sta = (struct wl1271_station *)sta->drv_priv;
3695 id = wl_sta->hlid - WL1271_AP_STA_HLID_START;
3696 if (WARN_ON(!test_bit(id, wl->ap_hlid_map)))
3697 goto out;
3698
a620865e 3699 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 3700 if (ret < 0)
3701 goto out;
3702
c690ec81 3703 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
f84f7d78
AN		 3704 if (ret < 0)
3705 goto out_sleep;
3706
409622ec 3707 wl1271_free_sta(wl, wl_sta->hlid);
f84f7d78
AN		 3708
3709out_sleep:
3710 wl1271_ps_elp_sleep(wl);
3711
3712out:
3713 mutex_unlock(&wl->mutex);
3714 return ret;
3715}
3716
4623ec7d
LC		 3717static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
3718 struct ieee80211_vif *vif,
3719 enum ieee80211_ampdu_mlme_action action,
3720 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
3721 u8 buf_size)
bbba3e68
LS		 3722{
3723 struct wl1271 *wl = hw->priv;
3724 int ret;
3725
3726 mutex_lock(&wl->mutex);
3727
3728 if (unlikely(wl->state == WL1271_STATE_OFF)) {
3729 ret = -EAGAIN;
3730 goto out;
3731 }
3732
a620865e 3733 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 3734 if (ret < 0)
3735 goto out;
3736
70559a06
SL		 3737 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
3738 tid, action);
3739
bbba3e68
LS		 3740 switch (action) {
3741 case IEEE80211_AMPDU_RX_START:
70559a06 3742 if ((wl->ba_support) && (wl->ba_allowed)) {
bbba3e68
LS		 3743 ret = wl1271_acx_set_ba_receiver_session(wl, tid, *ssn,
3744 true);
3745 if (!ret)
3746 wl->ba_rx_bitmap |= BIT(tid);
3747 } else {
3748 ret = -ENOTSUPP;
3749 }
3750 break;
3751
3752 case IEEE80211_AMPDU_RX_STOP:
3753 ret = wl1271_acx_set_ba_receiver_session(wl, tid, 0, false);
3754 if (!ret)
3755 wl->ba_rx_bitmap &= ~BIT(tid);
3756 break;
3757
3758 /*
3759 * The BA initiator session management in FW independently.
3760 * Falling break here on purpose for all TX APDU commands.
3761 */
3762 case IEEE80211_AMPDU_TX_START:
3763 case IEEE80211_AMPDU_TX_STOP:
3764 case IEEE80211_AMPDU_TX_OPERATIONAL:
3765 ret = -EINVAL;
3766 break;
3767
3768 default:
3769 wl1271_error("Incorrect ampdu action id=%x\n", action);
3770 ret = -EINVAL;
3771 }
3772
3773 wl1271_ps_elp_sleep(wl);
3774
3775out:
3776 mutex_unlock(&wl->mutex);
3777
3778 return ret;
3779}
3780
33437893
AN		 3781static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
3782{
3783 struct wl1271 *wl = hw->priv;
3784 bool ret = false;
3785
3786 mutex_lock(&wl->mutex);
3787
3788 if (unlikely(wl->state == WL1271_STATE_OFF))
3789 goto out;
3790
3791 /* packets are considered pending if in the TX queue or the FW */
f1a46384 3792 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 3793
3794 /* the above is appropriate for STA mode for PS purposes */
3795 WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS);
3796
3797out:
3798 mutex_unlock(&wl->mutex);
3799
3800 return ret;
3801}
3802
f5fc0f86
LC		 3803/* can't be const, mac80211 writes to this */
3804static struct ieee80211_rate wl1271_rates[] = {
3805 { .bitrate = 10,
2b60100b
JO		 3806 .hw_value = CONF_HW_BIT_RATE_1MBPS,
3807 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 3808 { .bitrate = 20,
2b60100b
JO		 3809 .hw_value = CONF_HW_BIT_RATE_2MBPS,
3810 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 3811 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3812 { .bitrate = 55,
2b60100b
JO		 3813 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
3814 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 3815 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3816 { .bitrate = 110,
2b60100b
JO		 3817 .hw_value = CONF_HW_BIT_RATE_11MBPS,
3818 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 3819 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
3820 { .bitrate = 60,
2b60100b
JO		 3821 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3822 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 3823 { .bitrate = 90,
2b60100b
JO		 3824 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3825 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 3826 { .bitrate = 120,
2b60100b
JO		 3827 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3828 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 3829 { .bitrate = 180,
2b60100b
JO		 3830 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3831 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 3832 { .bitrate = 240,
2b60100b
JO		 3833 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3834 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 3835 { .bitrate = 360,
2b60100b
JO		 3836 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3837 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 3838 { .bitrate = 480,
2b60100b
JO		 3839 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3840 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 3841 { .bitrate = 540,
2b60100b
JO		 3842 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3843 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 3844};
3845
fa97f46b 3846/* can't be const, mac80211 writes to this */
f5fc0f86 3847static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 3848 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 3849 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 3850 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
3851 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
3852 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 3853 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 3854 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
3855 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
3856 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 3857 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 3858 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
3859 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
3860 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 3861 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 3862};
3863
f876bb9a 3864/* mapping to indexes for wl1271_rates */
a0ea9493 3865static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 3866 /* MCS rates are used only with 11n */
18357850
SL		 3867 7, /* CONF_HW_RXTX_RATE_MCS7 */
3868 6, /* CONF_HW_RXTX_RATE_MCS6 */
3869 5, /* CONF_HW_RXTX_RATE_MCS5 */
3870 4, /* CONF_HW_RXTX_RATE_MCS4 */
3871 3, /* CONF_HW_RXTX_RATE_MCS3 */
3872 2, /* CONF_HW_RXTX_RATE_MCS2 */
3873 1, /* CONF_HW_RXTX_RATE_MCS1 */
3874 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 3875
3876 11, /* CONF_HW_RXTX_RATE_54 */
3877 10, /* CONF_HW_RXTX_RATE_48 */
3878 9, /* CONF_HW_RXTX_RATE_36 */
3879 8, /* CONF_HW_RXTX_RATE_24 */
3880
3881 /* TI-specific rate */
3882 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
3883
3884 7, /* CONF_HW_RXTX_RATE_18 */
3885 6, /* CONF_HW_RXTX_RATE_12 */
3886 3, /* CONF_HW_RXTX_RATE_11 */
3887 5, /* CONF_HW_RXTX_RATE_9 */
3888 4, /* CONF_HW_RXTX_RATE_6 */
3889 2, /* CONF_HW_RXTX_RATE_5_5 */
3890 1, /* CONF_HW_RXTX_RATE_2 */
3891 0 /* CONF_HW_RXTX_RATE_1 */
3892};
3893
e8b03a2b
SL		 3894/* 11n STA capabilities */
3895#define HW_RX_HIGHEST_RATE 72
3896
00d20100
SL		 3897#ifdef CONFIG_WL12XX_HT
3898#define WL12XX_HT_CAP { \
871d0c3b
SL		 3899 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
3900 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 3901 .ht_supported = true, \
3902 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
3903 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
3904 .mcs = { \
3905 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
3906 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
3907 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
3908 }, \
3909}
18357850 3910#else
00d20100 3911#define WL12XX_HT_CAP { \
18357850
SL		 3912 .ht_supported = false, \
3913}
3914#endif
e8b03a2b 3915
f5fc0f86
LC		 3916/* can't be const, mac80211 writes to this */
3917static struct ieee80211_supported_band wl1271_band_2ghz = {
3918 .channels = wl1271_channels,
3919 .n_channels = ARRAY_SIZE(wl1271_channels),
3920 .bitrates = wl1271_rates,
3921 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 3922 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 3923};
3924
1ebec3d7
TP		 3925/* 5 GHz data rates for WL1273 */
3926static struct ieee80211_rate wl1271_rates_5ghz[] = {
3927 { .bitrate = 60,
3928 .hw_value = CONF_HW_BIT_RATE_6MBPS,
3929 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
3930 { .bitrate = 90,
3931 .hw_value = CONF_HW_BIT_RATE_9MBPS,
3932 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
3933 { .bitrate = 120,
3934 .hw_value = CONF_HW_BIT_RATE_12MBPS,
3935 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
3936 { .bitrate = 180,
3937 .hw_value = CONF_HW_BIT_RATE_18MBPS,
3938 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
3939 { .bitrate = 240,
3940 .hw_value = CONF_HW_BIT_RATE_24MBPS,
3941 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
3942 { .bitrate = 360,
3943 .hw_value = CONF_HW_BIT_RATE_36MBPS,
3944 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
3945 { .bitrate = 480,
3946 .hw_value = CONF_HW_BIT_RATE_48MBPS,
3947 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
3948 { .bitrate = 540,
3949 .hw_value = CONF_HW_BIT_RATE_54MBPS,
3950 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
3951};
3952
fa97f46b 3953/* 5 GHz band channels for WL1273 */
1ebec3d7 3954static struct ieee80211_channel wl1271_channels_5ghz[] = {
6cfa5cff
AN		 3955 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
3956 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
3957 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
3958 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
3959 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
3960 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
3961 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
3962 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
3963 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
3964 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
3965 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
3966 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
3967 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
3968 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
3969 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
3970 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
3971 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
3972 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
3973 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
3974 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
3975 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
3976 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
3977 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
3978 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
3979 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
3980 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
3981 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
3982 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
3983 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
3984 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
3985 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
3986 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
3987 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
3988 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
1ebec3d7
TP		 3989};
3990
f876bb9a 3991/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 3992static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 3993 /* MCS rates are used only with 11n */
18357850
SL		 3994 7, /* CONF_HW_RXTX_RATE_MCS7 */
3995 6, /* CONF_HW_RXTX_RATE_MCS6 */
3996 5, /* CONF_HW_RXTX_RATE_MCS5 */
3997 4, /* CONF_HW_RXTX_RATE_MCS4 */
3998 3, /* CONF_HW_RXTX_RATE_MCS3 */
3999 2, /* CONF_HW_RXTX_RATE_MCS2 */
4000 1, /* CONF_HW_RXTX_RATE_MCS1 */
4001 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4002
4003 7, /* CONF_HW_RXTX_RATE_54 */
4004 6, /* CONF_HW_RXTX_RATE_48 */
4005 5, /* CONF_HW_RXTX_RATE_36 */
4006 4, /* CONF_HW_RXTX_RATE_24 */
4007
4008 /* TI-specific rate */
4009 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4010
4011 3, /* CONF_HW_RXTX_RATE_18 */
4012 2, /* CONF_HW_RXTX_RATE_12 */
4013 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4014 1, /* CONF_HW_RXTX_RATE_9 */
4015 0, /* CONF_HW_RXTX_RATE_6 */
4016 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4017 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4018 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4019};
1ebec3d7
TP		 4020
4021static struct ieee80211_supported_band wl1271_band_5ghz = {
4022 .channels = wl1271_channels_5ghz,
4023 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4024 .bitrates = wl1271_rates_5ghz,
4025 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 4026 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 4027};
4028
a0ea9493 4029static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 4030 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4031 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4032};
4033
f5fc0f86
LC		 4034static const struct ieee80211_ops wl1271_ops = {
4035 .start = wl1271_op_start,
4036 .stop = wl1271_op_stop,
4037 .add_interface = wl1271_op_add_interface,
4038 .remove_interface = wl1271_op_remove_interface,
f634a4e7 4039#ifdef CONFIG_PM
402e4861
EP		 4040 .suspend = wl1271_op_suspend,
4041 .resume = wl1271_op_resume,
f634a4e7 4042#endif
f5fc0f86 4043 .config = wl1271_op_config,
c87dec9f 4044 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 4045 .configure_filter = wl1271_op_configure_filter,
4046 .tx = wl1271_op_tx,
4047 .set_key = wl1271_op_set_key,
4048 .hw_scan = wl1271_op_hw_scan,
73ecce31 4049 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 4050 .sched_scan_start = wl1271_op_sched_scan_start,
4051 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 4052 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 4053 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 4054 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 4055 .conf_tx = wl1271_op_conf_tx,
bbbb538e 4056 .get_tsf = wl1271_op_get_tsf,
ece550d0 4057 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 4058 .sta_add = wl1271_op_sta_add,
4059 .sta_remove = wl1271_op_sta_remove,
bbba3e68 4060 .ampdu_action = wl1271_op_ampdu_action,
33437893 4061 .tx_frames_pending = wl1271_tx_frames_pending,
c8c90873 4062 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 4063};
4064
f876bb9a 4065
6a2de93b 4066u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 4067{
4068 u8 idx;
4069
6a2de93b 4070 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 4071
4072 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4073 wl1271_error("Illegal RX rate from HW: %d", rate);
4074 return 0;
4075 }
4076
6a2de93b 4077 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 4078 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4079 wl1271_error("Unsupported RX rate from HW: %d", rate);
4080 return 0;
4081 }
4082
4083 return idx;
4084}
4085
7fc3a864
JO		 4086static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4087 struct device_attribute *attr,
4088 char *buf)
4089{
4090 struct wl1271 *wl = dev_get_drvdata(dev);
4091 ssize_t len;
4092
2f63b011 4093 len = PAGE_SIZE;
7fc3a864
JO		 4094
4095 mutex_lock(&wl->mutex);
4096 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4097 wl->sg_enabled);
4098 mutex_unlock(&wl->mutex);
4099
4100 return len;
4101
4102}
4103
4104static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4105 struct device_attribute *attr,
4106 const char *buf, size_t count)
4107{
4108 struct wl1271 *wl = dev_get_drvdata(dev);
4109 unsigned long res;
4110 int ret;
4111
6277ed65 4112 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 4113 if (ret < 0) {
4114 wl1271_warning("incorrect value written to bt_coex_mode");
4115 return count;
4116 }
4117
4118 mutex_lock(&wl->mutex);
4119
4120 res = !!res;
4121
4122 if (res == wl->sg_enabled)
4123 goto out;
4124
4125 wl->sg_enabled = res;
4126
4127 if (wl->state == WL1271_STATE_OFF)
4128 goto out;
4129
a620865e 4130 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 4131 if (ret < 0)
4132 goto out;
4133
4134 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4135 wl1271_ps_elp_sleep(wl);
4136
4137 out:
4138 mutex_unlock(&wl->mutex);
4139 return count;
4140}
4141
4142static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4143 wl1271_sysfs_show_bt_coex_state,
4144 wl1271_sysfs_store_bt_coex_state);
4145
d717fd61
JO		 4146static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4147 struct device_attribute *attr,
4148 char *buf)
4149{
4150 struct wl1271 *wl = dev_get_drvdata(dev);
4151 ssize_t len;
4152
2f63b011 4153 len = PAGE_SIZE;
d717fd61
JO		 4154
4155 mutex_lock(&wl->mutex);
4156 if (wl->hw_pg_ver >= 0)
4157 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4158 else
4159 len = snprintf(buf, len, "n/a\n");
4160 mutex_unlock(&wl->mutex);
4161
4162 return len;
4163}
4164
6f07b72a 4165static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
d717fd61
JO		 4166 wl1271_sysfs_show_hw_pg_ver, NULL);
4167
95dac04f
IY		 4168static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4169 struct bin_attribute *bin_attr,
4170 char *buffer, loff_t pos, size_t count)
4171{
4172 struct device *dev = container_of(kobj, struct device, kobj);
4173 struct wl1271 *wl = dev_get_drvdata(dev);
4174 ssize_t len;
4175 int ret;
4176
4177 ret = mutex_lock_interruptible(&wl->mutex);
4178 if (ret < 0)
4179 return -ERESTARTSYS;
4180
4181 /* Let only one thread read the log at a time, blocking others */
4182 while (wl->fwlog_size == 0) {
4183 DEFINE_WAIT(wait);
4184
4185 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4186 &wait,
4187 TASK_INTERRUPTIBLE);
4188
4189 if (wl->fwlog_size != 0) {
4190 finish_wait(&wl->fwlog_waitq, &wait);
4191 break;
4192 }
4193
4194 mutex_unlock(&wl->mutex);
4195
4196 schedule();
4197 finish_wait(&wl->fwlog_waitq, &wait);
4198
4199 if (signal_pending(current))
4200 return -ERESTARTSYS;
4201
4202 ret = mutex_lock_interruptible(&wl->mutex);
4203 if (ret < 0)
4204 return -ERESTARTSYS;
4205 }
4206
4207 /* Check if the fwlog is still valid */
4208 if (wl->fwlog_size < 0) {
4209 mutex_unlock(&wl->mutex);
4210 return 0;
4211 }
4212
4213 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4214 len = min(count, (size_t)wl->fwlog_size);
4215 wl->fwlog_size -= len;
4216 memcpy(buffer, wl->fwlog, len);
4217
4218 /* Make room for new messages */
4219 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4220
4221 mutex_unlock(&wl->mutex);
4222
4223 return len;
4224}
4225
4226static struct bin_attribute fwlog_attr = {
4227 .attr = {.name = "fwlog", .mode = S_IRUSR},
4228 .read = wl1271_sysfs_read_fwlog,
4229};
4230
2d5e82b8 4231int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 4232{
4233 int ret;
4234
4235 if (wl->mac80211_registered)
4236 return 0;
4237
31d26ec6
AN		 4238 ret = wl1271_fetch_nvs(wl);
4239 if (ret == 0) {
bc765bf3
SL		 4240 /* NOTE: The wl->nvs->nvs element must be first, in
4241 * order to simplify the casting, we assume it is at
4242 * the beginning of the wl->nvs structure.
4243 */
4244 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 4245
4246 wl->mac_addr[0] = nvs_ptr[11];
4247 wl->mac_addr[1] = nvs_ptr[10];
4248 wl->mac_addr[2] = nvs_ptr[6];
4249 wl->mac_addr[3] = nvs_ptr[5];
4250 wl->mac_addr[4] = nvs_ptr[4];
4251 wl->mac_addr[5] = nvs_ptr[3];
4252 }
4253
f5fc0f86
LC		 4254 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4255
4256 ret = ieee80211_register_hw(wl->hw);
4257 if (ret < 0) {
4258 wl1271_error("unable to register mac80211 hw: %d", ret);
4259 return ret;
4260 }
4261
4262 wl->mac80211_registered = true;
4263
d60080ae
EP		 4264 wl1271_debugfs_init(wl);
4265
c2c192ac
JO		 4266 register_netdevice_notifier(&wl1271_dev_notifier);
4267
f5fc0f86
LC		 4268 wl1271_notice("loaded");
4269
4270 return 0;
4271}
50b3eb4b 4272EXPORT_SYMBOL_GPL(wl1271_register_hw);
f5fc0f86 4273
3b56dd6a
TP		 4274void wl1271_unregister_hw(struct wl1271 *wl)
4275{
4ae3fa87
JO		 4276 if (wl->state == WL1271_STATE_PLT)
4277 __wl1271_plt_stop(wl);
4278
c2c192ac 4279 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 4280 ieee80211_unregister_hw(wl->hw);
4281 wl->mac80211_registered = false;
4282
4283}
4284EXPORT_SYMBOL_GPL(wl1271_unregister_hw);
4285
2d5e82b8 4286int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 4287{
7a55724e
JO		 4288 static const u32 cipher_suites[] = {
4289 WLAN_CIPHER_SUITE_WEP40,
4290 WLAN_CIPHER_SUITE_WEP104,
4291 WLAN_CIPHER_SUITE_TKIP,
4292 WLAN_CIPHER_SUITE_CCMP,
4293 WL1271_CIPHER_SUITE_GEM,
4294 };
4295
1e2b7976
JO		 4296 /* The tx descriptor buffer and the TKIP space. */
4297 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4298 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 4299
4300 /* unit us */
4301 /* FIXME: find a proper value */
4302 wl->hw->channel_change_time = 10000;
50c500ad 4303 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 4304
4305 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 4306 IEEE80211_HW_BEACON_FILTER |
0a34332f 4307 IEEE80211_HW_SUPPORTS_PS |
4695dc91 4308 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 4309 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 4310 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 4311 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 4312 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 4313 IEEE80211_HW_SPECTRUM_MGMT |
ba7c082a 4314 IEEE80211_HW_AP_LINK_PS;
f5fc0f86 4315
7a55724e
JO		 4316 wl->hw->wiphy->cipher_suites = cipher_suites;
4317 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4318
e0d8bbf0 4319 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
038d925b 4320 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
f5fc0f86 4321 wl->hw->wiphy->max_scan_ssids = 1;
ea559b46
GE		 4322 /*
4323 * Maximum length of elements in scanning probe request templates
4324 * should be the maximum length possible for a template, without
4325 * the IEEE80211 header of the template
4326 */
154037d1 4327 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
ea559b46 4328 sizeof(struct ieee80211_header);
a8aaaf53 4329
4a31c11c
LC		 4330 /* make sure all our channels fit in the scanned_ch bitmask */
4331 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4332 ARRAY_SIZE(wl1271_channels_5ghz) >
4333 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 4334 /*
4335 * We keep local copies of the band structs because we need to
4336 * modify them on a per-device basis.
4337 */
4338 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4339 sizeof(wl1271_band_2ghz));
4340 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4341 sizeof(wl1271_band_5ghz));
4342
4343 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4344 &wl->bands[IEEE80211_BAND_2GHZ];
4345 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4346 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 4347
12bd8949 4348 wl->hw->queues = 4;
31627dc5 4349 wl->hw->max_rates = 1;
12bd8949 4350
b7417d93
JO		 4351 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4352
8197b711 4353 SET_IEEE80211_DEV(wl->hw, wl1271_wl_to_dev(wl));
f5fc0f86 4354
f84f7d78
AN		 4355 wl->hw->sta_data_size = sizeof(struct wl1271_station);
4356
4c9cfa78
LC		 4357 wl->hw->max_rx_aggregation_subframes = 8;
4358
f5fc0f86
LC		 4359 return 0;
4360}
50b3eb4b 4361EXPORT_SYMBOL_GPL(wl1271_init_ieee80211);
f5fc0f86 4362
f5fc0f86 4363#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 4364
2d5e82b8 4365struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 4366{
f5fc0f86 4367 struct ieee80211_hw *hw;
3b56dd6a 4368 struct platform_device *plat_dev = NULL;
f5fc0f86 4369 struct wl1271 *wl;
a8c0ddb5 4370 int i, j, ret;
1f37cbc9 4371 unsigned int order;
f5fc0f86
LC		 4372
4373 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4374 if (!hw) {
4375 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 4376 ret = -ENOMEM;
3b56dd6a
TP		 4377 goto err_hw_alloc;
4378 }
4379
929ebd30 4380 plat_dev = kmemdup(&wl1271_device, sizeof(wl1271_device), GFP_KERNEL);
3b56dd6a
TP		 4381 if (!plat_dev) {
4382 wl1271_error("could not allocate platform_device");
4383 ret = -ENOMEM;
4384 goto err_plat_alloc;
f5fc0f86
LC		 4385 }
4386
4387 wl = hw->priv;
4388 memset(wl, 0, sizeof(*wl));
4389
01c09162
JO		 4390 INIT_LIST_HEAD(&wl->list);
4391
f5fc0f86 4392 wl->hw = hw;
3b56dd6a 4393 wl->plat_dev = plat_dev;
f5fc0f86 4394
6742f554
JO		 4395 for (i = 0; i < NUM_TX_QUEUES; i++)
4396 skb_queue_head_init(&wl->tx_queue[i]);
f5fc0f86 4397
a8c0ddb5
AN		 4398 for (i = 0; i < NUM_TX_QUEUES; i++)
4399 for (j = 0; j < AP_MAX_LINKS; j++)
4400 skb_queue_head_init(&wl->links[j].tx_queue[i]);
4401
a620865e
IY		 4402 skb_queue_head_init(&wl->deferred_rx_queue);
4403 skb_queue_head_init(&wl->deferred_tx_queue);
4404
37b70a81 4405 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
90494a90 4406 INIT_DELAYED_WORK(&wl->pspoll_work, wl1271_pspoll_work);
a620865e 4407 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 4408 INIT_WORK(&wl->tx_work, wl1271_tx_work);
4409 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
4410 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
77ddaa10
EP		 4411 INIT_WORK(&wl->rx_streaming_enable_work,
4412 wl1271_rx_streaming_enable_work);
4413 INIT_WORK(&wl->rx_streaming_disable_work,
4414 wl1271_rx_streaming_disable_work);
4415
92ef8960
EP		 4416 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
4417 if (!wl->freezable_wq) {
4418 ret = -ENOMEM;
4419 goto err_hw;
4420 }
4421
f5fc0f86 4422 wl->channel = WL1271_DEFAULT_CHANNEL;
60e84c2e 4423 wl->beacon_int = WL1271_DEFAULT_BEACON_INT;
f5fc0f86 4424 wl->default_key = 0;
f5fc0f86 4425 wl->rx_counter = 0;
19ad0715 4426 wl->psm_entry_retry = 0;
f5fc0f86 4427 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
a6fe2313 4428 wl->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
ebba60c6 4429 wl->basic_rate = CONF_TX_RATE_MASK_BASIC;
830fb67b 4430 wl->rate_set = CONF_TX_RATE_MASK_BASIC;
8a5a37a6 4431 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 4432 wl->vif = NULL;
830fb67b 4433 wl->flags = 0;
7fc3a864 4434 wl->sg_enabled = true;
d717fd61 4435 wl->hw_pg_ver = -1;
166d504e
AN		 4436 wl->bss_type = MAX_BSS_TYPE;
4437 wl->set_bss_type = MAX_BSS_TYPE;
a8c0ddb5 4438 wl->last_tx_hlid = 0;
b622d992
AN		 4439 wl->ap_ps_map = 0;
4440 wl->ap_fw_ps_map = 0;
606ea9fa 4441 wl->quirks = 0;
341b7cde 4442 wl->platform_quirks = 0;
33c2c06c 4443 wl->sched_scanning = false;
b992c682
OK		 4444 wl->tx_security_seq = 0;
4445 wl->tx_security_last_seq_lsb = 0;
7f097988 4446 wl->role_id = WL12XX_INVALID_ROLE_ID;
f4df1bd5 4447 wl->system_hlid = WL12XX_SYSTEM_HLID;
7f097988 4448 wl->sta_hlid = WL12XX_INVALID_LINK_ID;
04e8079c
EP		 4449 wl->dev_role_id = WL12XX_INVALID_ROLE_ID;
4450 wl->dev_hlid = WL12XX_INVALID_LINK_ID;
712e9bf7 4451 wl->session_counter = 0;
77ddaa10
EP		 4452 setup_timer(&wl->rx_streaming_timer, wl1271_rx_streaming_timer,
4453 (unsigned long) wl);
95dac04f
IY		 4454 wl->fwlog_size = 0;
4455 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 4456
f4df1bd5
EP		 4457 /* The system link is always allocated */
4458 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
4459
25eeb9e3 4460 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 4461 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 4462 wl->tx_frames[i] = NULL;
4463
4464 spin_lock_init(&wl->wl_lock);
4465
f5fc0f86
LC		 4466 wl->state = WL1271_STATE_OFF;
4467 mutex_init(&wl->mutex);
4468
c332a4b8
TP		 4469 /* Apply default driver configuration. */
4470 wl1271_conf_init(wl);
4471
1f37cbc9
IY		 4472 order = get_order(WL1271_AGGR_BUFFER_SIZE);
4473 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
4474 if (!wl->aggr_buf) {
4475 ret = -ENOMEM;
92ef8960 4476 goto err_wq;
1f37cbc9
IY		 4477 }
4478
990f5de7
IY		 4479 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
4480 if (!wl->dummy_packet) {
4481 ret = -ENOMEM;
4482 goto err_aggr;
4483 }
4484
95dac04f
IY		 4485 /* Allocate one page for the FW log */
4486 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
4487 if (!wl->fwlog) {
4488 ret = -ENOMEM;
4489 goto err_dummy_packet;
4490 }
4491
a1dd8187 4492 /* Register platform device */
3b56dd6a 4493 ret = platform_device_register(wl->plat_dev);
a1dd8187
JO		 4494 if (ret) {
4495 wl1271_error("couldn't register platform device");
95dac04f 4496 goto err_fwlog;
a1dd8187 4497 }
3b56dd6a 4498 dev_set_drvdata(&wl->plat_dev->dev, wl);
a1dd8187 4499
7fc3a864 4500 /* Create sysfs file to control bt coex state */
3b56dd6a 4501 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
7fc3a864
JO		 4502 if (ret < 0) {
4503 wl1271_error("failed to create sysfs file bt_coex_state");
4504 goto err_platform;
4505 }
a1dd8187 4506
d717fd61
JO		 4507 /* Create sysfs file to get HW PG version */
4508 ret = device_create_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4509 if (ret < 0) {
4510 wl1271_error("failed to create sysfs file hw_pg_ver");
4511 goto err_bt_coex_state;
4512 }
4513
95dac04f
IY		 4514 /* Create sysfs file for the FW log */
4515 ret = device_create_bin_file(&wl->plat_dev->dev, &fwlog_attr);
4516 if (ret < 0) {
4517 wl1271_error("failed to create sysfs file fwlog");
4518 goto err_hw_pg_ver;
4519 }
4520
c332a4b8 4521 return hw;
a1dd8187 4522
95dac04f
IY		 4523err_hw_pg_ver:
4524 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4525
d717fd61
JO		 4526err_bt_coex_state:
4527 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
4528
7fc3a864 4529err_platform:
3b56dd6a 4530 platform_device_unregister(wl->plat_dev);
7fc3a864 4531
95dac04f
IY		 4532err_fwlog:
4533 free_page((unsigned long)wl->fwlog);
4534
990f5de7
IY		 4535err_dummy_packet:
4536 dev_kfree_skb(wl->dummy_packet);
4537
1f37cbc9
IY		 4538err_aggr:
4539 free_pages((unsigned long)wl->aggr_buf, order);
4540
92ef8960
EP		 4541err_wq:
4542 destroy_workqueue(wl->freezable_wq);
4543
a1dd8187 4544err_hw:
3b56dd6a
TP		 4545 wl1271_debugfs_exit(wl);
4546 kfree(plat_dev);
4547
4548err_plat_alloc:
4549 ieee80211_free_hw(hw);
4550
4551err_hw_alloc:
a1dd8187 4552
a1dd8187 4553 return ERR_PTR(ret);
c332a4b8 4554}
50b3eb4b 4555EXPORT_SYMBOL_GPL(wl1271_alloc_hw);
c332a4b8
TP		 4556
4557int wl1271_free_hw(struct wl1271 *wl)
4558{
95dac04f
IY		 4559 /* Unblock any fwlog readers */
4560 mutex_lock(&wl->mutex);
4561 wl->fwlog_size = -1;
4562 wake_up_interruptible_all(&wl->fwlog_waitq);
4563 mutex_unlock(&wl->mutex);
4564
4565 device_remove_bin_file(&wl->plat_dev->dev, &fwlog_attr);
6f07b72a
GK		 4566
4567 device_remove_file(&wl->plat_dev->dev, &dev_attr_hw_pg_ver);
4568
4569 device_remove_file(&wl->plat_dev->dev, &dev_attr_bt_coex_state);
3b56dd6a 4570 platform_device_unregister(wl->plat_dev);
95dac04f 4571 free_page((unsigned long)wl->fwlog);
990f5de7 4572 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 4573 free_pages((unsigned long)wl->aggr_buf,
4574 get_order(WL1271_AGGR_BUFFER_SIZE));
3b56dd6a 4575 kfree(wl->plat_dev);
c332a4b8
TP		 4576
4577 wl1271_debugfs_exit(wl);
4578
c332a4b8
TP		 4579 vfree(wl->fw);
4580 wl->fw = NULL;
4581 kfree(wl->nvs);
4582 wl->nvs = NULL;
4583
4584 kfree(wl->fw_status);
4585 kfree(wl->tx_res_if);
92ef8960 4586 destroy_workqueue(wl->freezable_wq);
c332a4b8
TP		 4587
4588 ieee80211_free_hw(wl->hw);
4589
4590 return 0;
4591}
50b3eb4b
TP		 4592EXPORT_SYMBOL_GPL(wl1271_free_hw);
4593
491bbd6b 4594u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 4595EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 4596module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 4597MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
4598
95dac04f
IY		 4599module_param_named(fwlog, fwlog_param, charp, 0);
4600MODULE_PARM_DESC(keymap,
4601 "FW logger options: continuous, ondemand, dbgpins or disable");
4602
50b3eb4b 4603MODULE_LICENSE("GPL");
b1a48cab 4604MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 4605MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
Linux kernel - Deliverables
This page took 0.678055 seconds and 5 git commands to generate.