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