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