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