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