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