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