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