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