projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wl12xx: change blocksize alignment quirk to negative
[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) {
1058 wl1271_error("could not get firmware: %d", ret);
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) {
1096 wl1271_error("could not get nvs file: %d", ret);
1097 return ret;
1098 }
1099
bc765bf3 1100 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
f5fc0f86
LC		 1101
1102 if (!wl->nvs) {
1103 wl1271_error("could not allocate memory for the nvs file");
1104 ret = -ENOMEM;
1105 goto out;
1106 }
1107
02fabb0e
JO		 1108 wl->nvs_len = fw->size;
1109
f5fc0f86
LC		 1110out:
1111 release_firmware(fw);
1112
1113 return ret;
1114}
1115
baacb9ae
IY		 1116void wl12xx_queue_recovery_work(struct wl1271 *wl)
1117{
1118 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1119 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1120}
1121
95dac04f
IY		 1122size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
1123{
1124 size_t len = 0;
1125
1126 /* The FW log is a length-value list, find where the log end */
1127 while (len < maxlen) {
1128 if (memblock[len] == 0)
1129 break;
1130 if (len + memblock[len] + 1 > maxlen)
1131 break;
1132 len += memblock[len] + 1;
1133 }
1134
1135 /* Make sure we have enough room */
1136 len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));
1137
1138 /* Fill the FW log file, consumed by the sysfs fwlog entry */
1139 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
1140 wl->fwlog_size += len;
1141
1142 return len;
1143}
1144
1145static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
1146{
1147 u32 addr;
1148 u32 first_addr;
1149 u8 *block;
1150
1151 if ((wl->quirks & WL12XX_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
1152 (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
1153 (wl->conf.fwlog.mem_blocks == 0))
1154 return;
1155
1156 wl1271_info("Reading FW panic log");
1157
1158 block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
1159 if (!block)
1160 return;
1161
1162 /*
1163 * Make sure the chip is awake and the logger isn't active.
1164 * This might fail if the firmware hanged.
1165 */
1166 if (!wl1271_ps_elp_wakeup(wl))
1167 wl12xx_cmd_stop_fwlog(wl);
1168
1169 /* Read the first memory block address */
4d56ad9c
EP		 1170 wl12xx_fw_status(wl, wl->fw_status);
1171 first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
95dac04f
IY		 1172 if (!first_addr)
1173 goto out;
1174
1175 /* Traverse the memory blocks linked list */
1176 addr = first_addr;
1177 do {
1178 memset(block, 0, WL12XX_HW_BLOCK_SIZE);
1179 wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
1180 false);
1181
1182 /*
1183 * Memory blocks are linked to one another. The first 4 bytes
1184 * of each memory block hold the hardware address of the next
1185 * one. The last memory block points to the first one.
1186 */
4d56ad9c 1187 addr = le32_to_cpup((__le32 *)block);
95dac04f
IY		 1188 if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
1189 WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
1190 break;
1191 } while (addr && (addr != first_addr));
1192
1193 wake_up_interruptible(&wl->fwlog_waitq);
1194
1195out:
1196 kfree(block);
1197}
1198
52b0e7a6
JO		 1199static void wl1271_recovery_work(struct work_struct *work)
1200{
1201 struct wl1271 *wl =
1202 container_of(work, struct wl1271, recovery_work);
48e93e40 1203 struct wl12xx_vif *wlvif;
6e8cd331 1204 struct ieee80211_vif *vif;
52b0e7a6
JO		 1205
1206 mutex_lock(&wl->mutex);
1207
1208 if (wl->state != WL1271_STATE_ON)
f0277434 1209 goto out_unlock;
52b0e7a6 1210
baacb9ae
IY		 1211 /* Avoid a recursive recovery */
1212 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1213
95dac04f
IY		 1214 wl12xx_read_fwlog_panic(wl);
1215
52dcaf57
AN		 1216 wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
1217 wl->chip.fw_ver_str, wl1271_read32(wl, SCR_PAD4));
52b0e7a6 1218
2a5bff09
EP		 1219 BUG_ON(bug_on_recovery);
1220
b992c682
OK		 1221 /*
1222 * Advance security sequence number to overcome potential progress
1223 * in the firmware during recovery. This doens't hurt if the network is
1224 * not encrypted.
1225 */
48e93e40 1226 wl12xx_for_each_wlvif(wl, wlvif) {
ba8447f6 1227 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
53d40d0b 1228 test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
48e93e40
EP		 1229 wlvif->tx_security_seq +=
1230 WL1271_TX_SQN_POST_RECOVERY_PADDING;
1231 }
b992c682 1232
7dece1c8
AN		 1233 /* Prevent spurious TX during FW restart */
1234 ieee80211_stop_queues(wl->hw);
1235
33c2c06c
LC		 1236 if (wl->sched_scanning) {
1237 ieee80211_sched_scan_stopped(wl->hw);
1238 wl->sched_scanning = false;
1239 }
1240
52b0e7a6 1241 /* reboot the chipset */
6e8cd331
EP		 1242 while (!list_empty(&wl->wlvif_list)) {
1243 wlvif = list_first_entry(&wl->wlvif_list,
1244 struct wl12xx_vif, list);
1245 vif = wl12xx_wlvif_to_vif(wlvif);
1246 __wl1271_op_remove_interface(wl, vif, false);
1247 }
f0277434
EP		 1248 mutex_unlock(&wl->mutex);
1249 wl1271_op_stop(wl->hw);
baacb9ae
IY		 1250
1251 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
1252
52b0e7a6
JO		 1253 ieee80211_restart_hw(wl->hw);
1254
7dece1c8
AN		 1255 /*
1256 * Its safe to enable TX now - the queues are stopped after a request
1257 * to restart the HW.
1258 */
1259 ieee80211_wake_queues(wl->hw);
f0277434
EP		 1260 return;
1261out_unlock:
52b0e7a6
JO		 1262 mutex_unlock(&wl->mutex);
1263}
1264
f5fc0f86
LC		 1265static void wl1271_fw_wakeup(struct wl1271 *wl)
1266{
1267 u32 elp_reg;
1268
1269 elp_reg = ELPCTRL_WAKE_UP;
74621417 1270 wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg);
f5fc0f86
LC		 1271}
1272
1273static int wl1271_setup(struct wl1271 *wl)
1274{
1275 wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
1276 if (!wl->fw_status)
1277 return -ENOMEM;
1278
1279 wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1280 if (!wl->tx_res_if) {
1281 kfree(wl->fw_status);
1282 return -ENOMEM;
1283 }
1284
f5fc0f86
LC		 1285 return 0;
1286}
1287
1288static int wl1271_chip_wakeup(struct wl1271 *wl)
1289{
451de97a 1290 struct wl1271_partition_set partition;
f5fc0f86
LC		 1291 int ret = 0;
1292
01ac17ec 1293 msleep(WL1271_PRE_POWER_ON_SLEEP);
2cc78ff7
OBC		 1294 ret = wl1271_power_on(wl);
1295 if (ret < 0)
1296 goto out;
f5fc0f86 1297 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 1298 wl1271_io_reset(wl);
1299 wl1271_io_init(wl);
f5fc0f86
LC		 1300
1301 /* We don't need a real memory partition here, because we only want
1302 * to use the registers at this point. */
451de97a
JO		 1303 memset(&partition, 0, sizeof(partition));
1304 partition.reg.start = REGISTERS_BASE;
1305 partition.reg.size = REGISTERS_DOWN_SIZE;
1306 wl1271_set_partition(wl, &partition);
f5fc0f86
LC		 1307
1308 /* ELP module wake up */
1309 wl1271_fw_wakeup(wl);
1310
1311 /* whal_FwCtrl_BootSm() */
1312
1313 /* 0. read chip id from CHIP_ID */
7b048c52 1314 wl->chip.id = wl1271_read32(wl, CHIP_ID_B);
f5fc0f86
LC		 1315
1316 /* 1. check if chip id is valid */
1317
1318 switch (wl->chip.id) {
1319 case CHIP_ID_1271_PG10:
1320 wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
1321 wl->chip.id);
1322
1323 ret = wl1271_setup(wl);
1324 if (ret < 0)
9ccd9217 1325 goto out;
ce39defb 1326 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
f5fc0f86 1327 break;
ce39defb 1328
f5fc0f86
LC		 1329 case CHIP_ID_1271_PG20:
1330 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
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
0830ceed
SL		 1339 case CHIP_ID_1283_PG20:
1340 wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
1341 wl->chip.id);
1342
1343 ret = wl1271_setup(wl);
1344 if (ret < 0)
1345 goto out;
0c005048 1346
ce39defb
LC		 1347 if (!wl1271_set_block_size(wl))
1348 wl->quirks |= WL12XX_QUIRK_NO_BLOCKSIZE_ALIGNMENT;
0830ceed
SL		 1349 break;
1350 case CHIP_ID_1283_PG10:
f5fc0f86 1351 default:
9ccd9217 1352 wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
f5fc0f86 1353 ret = -ENODEV;
9ccd9217 1354 goto out;
f5fc0f86
LC		 1355 }
1356
c302b2c9 1357 if (wl->fw == NULL) {
f5fc0f86
LC		 1358 ret = wl1271_fetch_firmware(wl);
1359 if (ret < 0)
9ccd9217 1360 goto out;
f5fc0f86
LC		 1361 }
1362
1363 /* No NVS from netlink, try to get it from the filesystem */
1364 if (wl->nvs == NULL) {
1365 ret = wl1271_fetch_nvs(wl);
1366 if (ret < 0)
9ccd9217 1367 goto out;
f5fc0f86
LC		 1368 }
1369
1370out:
1371 return ret;
1372}
1373
f5fc0f86
LC		 1374int wl1271_plt_start(struct wl1271 *wl)
1375{
9ccd9217 1376 int retries = WL1271_BOOT_RETRIES;
6f07b72a 1377 struct wiphy *wiphy = wl->hw->wiphy;
f5fc0f86
LC		 1378 int ret;
1379
1380 mutex_lock(&wl->mutex);
1381
1382 wl1271_notice("power up");
1383
1384 if (wl->state != WL1271_STATE_OFF) {
1385 wl1271_error("cannot go into PLT state because not "
1386 "in off state: %d", wl->state);
1387 ret = -EBUSY;
1388 goto out;
1389 }
1390
9ccd9217
JO		 1391 while (retries) {
1392 retries--;
1393 ret = wl1271_chip_wakeup(wl);
1394 if (ret < 0)
1395 goto power_off;
f5fc0f86 1396
9ccd9217
JO		 1397 ret = wl1271_boot(wl);
1398 if (ret < 0)
1399 goto power_off;
eb5b28d0 1400
9ccd9217
JO		 1401 ret = wl1271_plt_init(wl);
1402 if (ret < 0)
1403 goto irq_disable;
bd5ea18f 1404
9ccd9217
JO		 1405 wl->state = WL1271_STATE_PLT;
1406 wl1271_notice("firmware booted in PLT mode (%s)",
4b7fac77 1407 wl->chip.fw_ver_str);
e7ddf549 1408
6f07b72a
GK		 1409 /* update hw/fw version info in wiphy struct */
1410 wiphy->hw_version = wl->chip.id;
1411 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1412 sizeof(wiphy->fw_version));
1413
9ccd9217 1414 goto out;
eb5b28d0 1415
9ccd9217 1416irq_disable:
9ccd9217
JO		 1417 mutex_unlock(&wl->mutex);
1418 /* Unlocking the mutex in the middle of handling is
1419 inherently unsafe. In this case we deem it safe to do,
1420 because we need to let any possibly pending IRQ out of
1421 the system (and while we are WL1271_STATE_OFF the IRQ
1422 work function will not do anything.) Also, any other
1423 possible concurrent operations will fail due to the
1424 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 1425 wl1271_disable_interrupts(wl);
1426 wl1271_flush_deferred_work(wl);
1427 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 1428 mutex_lock(&wl->mutex);
1429power_off:
1430 wl1271_power_off(wl);
1431 }
f5fc0f86 1432
9ccd9217
JO		 1433 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1434 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 1435out:
1436 mutex_unlock(&wl->mutex);
1437
1438 return ret;
1439}
1440
4623ec7d 1441static int __wl1271_plt_stop(struct wl1271 *wl)
f5fc0f86
LC		 1442{
1443 int ret = 0;
1444
f5fc0f86
LC		 1445 wl1271_notice("power down");
1446
1447 if (wl->state != WL1271_STATE_PLT) {
1448 wl1271_error("cannot power down because not in PLT "
1449 "state: %d", wl->state);
1450 ret = -EBUSY;
1451 goto out;
1452 }
1453
f5fc0f86
LC		 1454 wl1271_power_off(wl);
1455
1456 wl->state = WL1271_STATE_OFF;
bd5ea18f 1457 wl->rx_counter = 0;
f5fc0f86 1458
f5fc0f86 1459 mutex_unlock(&wl->mutex);
a620865e
IY		 1460 wl1271_disable_interrupts(wl);
1461 wl1271_flush_deferred_work(wl);
1462 cancel_work_sync(&wl->netstack_work);
52b0e7a6 1463 cancel_work_sync(&wl->recovery_work);
4ae3fa87
JO		 1464 mutex_lock(&wl->mutex);
1465out:
1466 return ret;
1467}
1468
1469int wl1271_plt_stop(struct wl1271 *wl)
1470{
1471 int ret;
8c7f4f31 1472
4ae3fa87
JO		 1473 mutex_lock(&wl->mutex);
1474 ret = __wl1271_plt_stop(wl);
1475 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 1476 return ret;
1477}
1478
7bb45683 1479static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
f5fc0f86
LC		 1480{
1481 struct wl1271 *wl = hw->priv;
a8ab39a4
EP		 1482 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1483 struct ieee80211_vif *vif = info->control.vif;
0f168014 1484 struct wl12xx_vif *wlvif = NULL;
830fb67b 1485 unsigned long flags;
708bb3cf 1486 int q, mapping;
d6a3cc2e 1487 u8 hlid;
f5fc0f86 1488
0f168014
EP		 1489 if (vif)
1490 wlvif = wl12xx_vif_to_data(vif);
1491
708bb3cf
AN		 1492 mapping = skb_get_queue_mapping(skb);
1493 q = wl1271_tx_get_queue(mapping);
b07d4037 1494
d6a3cc2e 1495 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
b07d4037 1496
830fb67b 1497 spin_lock_irqsave(&wl->wl_lock, flags);
b07d4037 1498
830fb67b 1499 /* queue the packet */
d6a3cc2e 1500 if (hlid == WL12XX_INVALID_LINK_ID ||
0f168014 1501 (wlvif && !test_bit(hlid, wlvif->links_map))) {
d6a3cc2e
EP		 1502 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1503 dev_kfree_skb(skb);
1504 goto out;
a8c0ddb5 1505 }
f5fc0f86 1506
d6a3cc2e
EP		 1507 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d", hlid, q);
1508 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1509
04b4d69c
AN		 1510 wl->tx_queue_count[q]++;
1511
1512 /*
1513 * The workqueue is slow to process the tx_queue and we need stop
1514 * the queue here, otherwise the queue will get too long.
1515 */
1516 if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
1517 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1518 ieee80211_stop_queue(wl->hw, mapping);
1519 set_bit(q, &wl->stopped_queues_map);
1520 }
1521
f5fc0f86
LC		 1522 /*
1523 * The chip specific setup must run before the first TX packet -
1524 * before that, the tx_work will not be initialized!
1525 */
1526
b07d4037
IY		 1527 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1528 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
a522550a 1529 ieee80211_queue_work(wl->hw, &wl->tx_work);
b07d4037 1530
04216da3 1531out:
b07d4037 1532 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 1533}
1534
ae47c45f
SL		 1535int wl1271_tx_dummy_packet(struct wl1271 *wl)
1536{
990f5de7 1537 unsigned long flags;
14623787
AN		 1538 int q;
1539
1540 /* no need to queue a new dummy packet if one is already pending */
1541 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1542 return 0;
1543
1544 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
990f5de7
IY		 1545
1546 spin_lock_irqsave(&wl->wl_lock, flags);
1547 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
f1a46384 1548 wl->tx_queue_count[q]++;
990f5de7
IY		 1549 spin_unlock_irqrestore(&wl->wl_lock, flags);
1550
1551 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1552 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
a32d0cdf 1553 wl1271_tx_work_locked(wl);
990f5de7
IY		 1554
1555 /*
1556 * If the FW TX is busy, TX work will be scheduled by the threaded
1557 * interrupt handler function
1558 */
1559 return 0;
1560}
1561
1562/*
1563 * The size of the dummy packet should be at least 1400 bytes. However, in
1564 * order to minimize the number of bus transactions, aligning it to 512 bytes
1565 * boundaries could be beneficial, performance wise
1566 */
1567#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1568
cf27d867 1569static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
990f5de7
IY		 1570{
1571 struct sk_buff *skb;
ae47c45f 1572 struct ieee80211_hdr_3addr *hdr;
990f5de7
IY		 1573 unsigned int dummy_packet_size;
1574
1575 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1576 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
ae47c45f 1577
990f5de7 1578 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
ae47c45f 1579 if (!skb) {
990f5de7
IY		 1580 wl1271_warning("Failed to allocate a dummy packet skb");
1581 return NULL;
ae47c45f
SL		 1582 }
1583
1584 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1585
1586 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1587 memset(hdr, 0, sizeof(*hdr));
1588 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
990f5de7
IY		 1589 IEEE80211_STYPE_NULLFUNC |
1590 IEEE80211_FCTL_TODS);
ae47c45f 1591
990f5de7 1592 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
ae47c45f 1593
18b92ffa
LC		 1594 /* Dummy packets require the TID to be management */
1595 skb->priority = WL1271_TID_MGMT;
ae47c45f 1596
990f5de7 1597 /* Initialize all fields that might be used */
86c438f4 1598 skb_set_queue_mapping(skb, 0);
990f5de7 1599 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
ae47c45f 1600
990f5de7 1601 return skb;
ae47c45f
SL		 1602}
1603
990f5de7 1604
c2c192ac
JO		 1605static struct notifier_block wl1271_dev_notifier = {
1606 .notifier_call = wl1271_dev_notify,
1607};
1608
f634a4e7 1609#ifdef CONFIG_PM
d2d66c56
EP		 1610static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1611 struct wl12xx_vif *wlvif)
9439064c 1612{
e85d1629 1613 int ret = 0;
9439064c 1614
9439064c
EP		 1615 mutex_lock(&wl->mutex);
1616
ba8447f6 1617 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
e85d1629
EP		 1618 goto out_unlock;
1619
9439064c
EP		 1620 ret = wl1271_ps_elp_wakeup(wl);
1621 if (ret < 0)
1622 goto out_unlock;
1623
1624 /* enter psm if needed*/
c29bb001 1625 if (!test_bit(WLVIF_FLAG_PSM, &wlvif->flags)) {
9439064c
EP		 1626 DECLARE_COMPLETION_ONSTACK(compl);
1627
6ec45dc2 1628 wlvif->ps_compl = &compl;
0603d891 1629 ret = wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE,
d2d66c56 1630 wlvif->basic_rate, true);
9439064c
EP		 1631 if (ret < 0)
1632 goto out_sleep;
1633
1634 /* we must unlock here so we will be able to get events */
1635 wl1271_ps_elp_sleep(wl);
1636 mutex_unlock(&wl->mutex);
1637
1638 ret = wait_for_completion_timeout(
1639 &compl, msecs_to_jiffies(WL1271_PS_COMPLETE_TIMEOUT));
1640 if (ret <= 0) {
1641 wl1271_warning("couldn't enter ps mode!");
1642 ret = -EBUSY;
1643 goto out;
1644 }
1645
1646 /* take mutex again, and wakeup */
1647 mutex_lock(&wl->mutex);
1648
1649 ret = wl1271_ps_elp_wakeup(wl);
1650 if (ret < 0)
1651 goto out_unlock;
1652 }
1653out_sleep:
1654 wl1271_ps_elp_sleep(wl);
1655out_unlock:
1656 mutex_unlock(&wl->mutex);
1657out:
1658 return ret;
1659
1660}
1661
0603d891
EP		 1662static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1663 struct wl12xx_vif *wlvif)
8a7cf3fe 1664{
e85d1629 1665 int ret = 0;
8a7cf3fe
EP		 1666
1667 mutex_lock(&wl->mutex);
1668
53d40d0b 1669 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
e85d1629
EP		 1670 goto out_unlock;
1671
8a7cf3fe
EP		 1672 ret = wl1271_ps_elp_wakeup(wl);
1673 if (ret < 0)
1674 goto out_unlock;
1675
0603d891 1676 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
8a7cf3fe
EP		 1677
1678 wl1271_ps_elp_sleep(wl);
1679out_unlock:
1680 mutex_unlock(&wl->mutex);
1681 return ret;
1682
1683}
1684
d2d66c56
EP		 1685static int wl1271_configure_suspend(struct wl1271 *wl,
1686 struct wl12xx_vif *wlvif)
8a7cf3fe 1687{
536129c8 1688 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
d2d66c56 1689 return wl1271_configure_suspend_sta(wl, wlvif);
536129c8 1690 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
0603d891 1691 return wl1271_configure_suspend_ap(wl, wlvif);
8a7cf3fe
EP		 1692 return 0;
1693}
1694
d2d66c56
EP		 1695static void wl1271_configure_resume(struct wl1271 *wl,
1696 struct wl12xx_vif *wlvif)
9439064c
EP		 1697{
1698 int ret;
536129c8
EP		 1699 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1700 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
9439064c 1701
8a7cf3fe 1702 if (!is_sta && !is_ap)
9439064c
EP		 1703 return;
1704
1705 mutex_lock(&wl->mutex);
1706 ret = wl1271_ps_elp_wakeup(wl);
1707 if (ret < 0)
1708 goto out;
1709
8a7cf3fe
EP		 1710 if (is_sta) {
1711 /* exit psm if it wasn't configured */
c29bb001 1712 if (!test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags))
0603d891 1713 wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE,
d2d66c56 1714 wlvif->basic_rate, true);
8a7cf3fe 1715 } else if (is_ap) {
0603d891 1716 wl1271_acx_beacon_filter_opt(wl, wlvif, false);
8a7cf3fe 1717 }
9439064c
EP		 1718
1719 wl1271_ps_elp_sleep(wl);
1720out:
1721 mutex_unlock(&wl->mutex);
1722}
1723
402e4861
EP		 1724static int wl1271_op_suspend(struct ieee80211_hw *hw,
1725 struct cfg80211_wowlan *wow)
1726{
1727 struct wl1271 *wl = hw->priv;
6e8cd331 1728 struct wl12xx_vif *wlvif;
4a859df8
EP		 1729 int ret;
1730
402e4861 1731 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
4a859df8 1732 WARN_ON(!wow || !wow->any);
f44e5868 1733
4a859df8 1734 wl->wow_enabled = true;
6e8cd331
EP		 1735 wl12xx_for_each_wlvif(wl, wlvif) {
1736 ret = wl1271_configure_suspend(wl, wlvif);
1737 if (ret < 0) {
1738 wl1271_warning("couldn't prepare device to suspend");
1739 return ret;
1740 }
4a859df8
EP		 1741 }
1742 /* flush any remaining work */
1743 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
f44e5868 1744
4a859df8
EP		 1745 /*
1746 * disable and re-enable interrupts in order to flush
1747 * the threaded_irq
1748 */
1749 wl1271_disable_interrupts(wl);
1750
1751 /*
1752 * set suspended flag to avoid triggering a new threaded_irq
1753 * work. no need for spinlock as interrupts are disabled.
1754 */
1755 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1756
1757 wl1271_enable_interrupts(wl);
1758 flush_work(&wl->tx_work);
6e8cd331
EP		 1759 wl12xx_for_each_wlvif(wl, wlvif) {
1760 flush_delayed_work(&wlvif->pspoll_work);
1761 }
4a859df8 1762 flush_delayed_work(&wl->elp_work);
f44e5868 1763
402e4861
EP		 1764 return 0;
1765}
1766
1767static int wl1271_op_resume(struct ieee80211_hw *hw)
1768{
1769 struct wl1271 *wl = hw->priv;
6e8cd331 1770 struct wl12xx_vif *wlvif;
4a859df8
EP		 1771 unsigned long flags;
1772 bool run_irq_work = false;
1773
402e4861
EP		 1774 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1775 wl->wow_enabled);
4a859df8 1776 WARN_ON(!wl->wow_enabled);
f44e5868
EP		 1777
1778 /*
1779 * re-enable irq_work enqueuing, and call irq_work directly if
1780 * there is a pending work.
1781 */
4a859df8
EP		 1782 spin_lock_irqsave(&wl->wl_lock, flags);
1783 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1784 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1785 run_irq_work = true;
1786 spin_unlock_irqrestore(&wl->wl_lock, flags);
9439064c 1787
4a859df8
EP		 1788 if (run_irq_work) {
1789 wl1271_debug(DEBUG_MAC80211,
1790 "run postponed irq_work directly");
1791 wl1271_irq(0, wl);
1792 wl1271_enable_interrupts(wl);
f44e5868 1793 }
6e8cd331
EP		 1794 wl12xx_for_each_wlvif(wl, wlvif) {
1795 wl1271_configure_resume(wl, wlvif);
1796 }
ff91afc9 1797 wl->wow_enabled = false;
f44e5868 1798
402e4861
EP		 1799 return 0;
1800}
f634a4e7 1801#endif
402e4861 1802
f5fc0f86 1803static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1804{
1805 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1806
1807 /*
1808 * We have to delay the booting of the hardware because
1809 * we need to know the local MAC address before downloading and
1810 * initializing the firmware. The MAC address cannot be changed
1811 * after boot, and without the proper MAC address, the firmware
1812 * will not function properly.
1813 *
1814 * The MAC address is first known when the corresponding interface
1815 * is added. That is where we will initialize the hardware.
1816 */
1817
1818 return 0;
1819}
1820
1821static void wl1271_op_stop(struct ieee80211_hw *hw)
1822{
baf6277a
EP		 1823 struct wl1271 *wl = hw->priv;
1824 int i;
1825
1b72aecd 1826 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
baf6277a 1827
10c8cd01
EP		 1828 mutex_lock(&wl->mutex);
1829 if (wl->state == WL1271_STATE_OFF) {
1830 mutex_unlock(&wl->mutex);
1831 return;
1832 }
baf6277a
EP		 1833 /*
1834 * this must be before the cancel_work calls below, so that the work
1835 * functions don't perform further work.
1836 */
1837 wl->state = WL1271_STATE_OFF;
10c8cd01
EP		 1838 mutex_unlock(&wl->mutex);
1839
1840 mutex_lock(&wl_list_mutex);
1841 list_del(&wl->list);
baf6277a
EP		 1842 mutex_unlock(&wl_list_mutex);
1843
1844 wl1271_disable_interrupts(wl);
1845 wl1271_flush_deferred_work(wl);
1846 cancel_delayed_work_sync(&wl->scan_complete_work);
1847 cancel_work_sync(&wl->netstack_work);
1848 cancel_work_sync(&wl->tx_work);
baf6277a
EP		 1849 cancel_delayed_work_sync(&wl->elp_work);
1850
1851 /* let's notify MAC80211 about the remaining pending TX frames */
1852 wl12xx_tx_reset(wl, true);
1853 mutex_lock(&wl->mutex);
1854
1855 wl1271_power_off(wl);
1856
1857 wl->band = IEEE80211_BAND_2GHZ;
1858
1859 wl->rx_counter = 0;
1860 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1861 wl->tx_blocks_available = 0;
1862 wl->tx_allocated_blocks = 0;
1863 wl->tx_results_count = 0;
1864 wl->tx_packets_count = 0;
1865 wl->time_offset = 0;
baf6277a
EP		 1866 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
1867 wl->ap_fw_ps_map = 0;
1868 wl->ap_ps_map = 0;
1869 wl->sched_scanning = false;
1870 memset(wl->roles_map, 0, sizeof(wl->roles_map));
1871 memset(wl->links_map, 0, sizeof(wl->links_map));
1872 memset(wl->roc_map, 0, sizeof(wl->roc_map));
1873 wl->active_sta_count = 0;
1874
1875 /* The system link is always allocated */
1876 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1877
1878 /*
1879 * this is performed after the cancel_work calls and the associated
1880 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1881 * get executed before all these vars have been reset.
1882 */
1883 wl->flags = 0;
1884
1885 wl->tx_blocks_freed = 0;
1886
1887 for (i = 0; i < NUM_TX_QUEUES; i++) {
1888 wl->tx_pkts_freed[i] = 0;
1889 wl->tx_allocated_pkts[i] = 0;
1890 }
1891
1892 wl1271_debugfs_reset(wl);
1893
1894 kfree(wl->fw_status);
1895 wl->fw_status = NULL;
1896 kfree(wl->tx_res_if);
1897 wl->tx_res_if = NULL;
1898 kfree(wl->target_mem_map);
1899 wl->target_mem_map = NULL;
1900
1901 mutex_unlock(&wl->mutex);
1b72aecd
JO		 1902}
1903
e5a359f8
EP		 1904static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
1905{
1906 u8 policy = find_first_zero_bit(wl->rate_policies_map,
1907 WL12XX_MAX_RATE_POLICIES);
1908 if (policy >= WL12XX_MAX_RATE_POLICIES)
1909 return -EBUSY;
1910
1911 __set_bit(policy, wl->rate_policies_map);
1912 *idx = policy;
1913 return 0;
1914}
1915
1916static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
1917{
1918 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
1919 return;
1920
1921 __clear_bit(*idx, wl->rate_policies_map);
1922 *idx = WL12XX_MAX_RATE_POLICIES;
1923}
1924
536129c8 1925static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
b78b47eb 1926{
536129c8 1927 switch (wlvif->bss_type) {
b78b47eb 1928 case BSS_TYPE_AP_BSS:
fb0e707c 1929 if (wlvif->p2p)
045c745f
EP		 1930 return WL1271_ROLE_P2P_GO;
1931 else
1932 return WL1271_ROLE_AP;
b78b47eb
EP		 1933
1934 case BSS_TYPE_STA_BSS:
fb0e707c 1935 if (wlvif->p2p)
045c745f
EP		 1936 return WL1271_ROLE_P2P_CL;
1937 else
1938 return WL1271_ROLE_STA;
b78b47eb 1939
227e81e1
EP		 1940 case BSS_TYPE_IBSS:
1941 return WL1271_ROLE_IBSS;
1942
b78b47eb 1943 default:
536129c8 1944 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
b78b47eb
EP		 1945 }
1946 return WL12XX_INVALID_ROLE_TYPE;
1947}
1948
83587505 1949static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
87fbcb0f 1950{
e936bbe0 1951 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e5a359f8 1952 int i;
e936bbe0 1953
48e93e40
EP		 1954 /* clear everything but the persistent data */
1955 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
e936bbe0
EP		 1956
1957 switch (ieee80211_vif_type_p2p(vif)) {
1958 case NL80211_IFTYPE_P2P_CLIENT:
1959 wlvif->p2p = 1;
1960 /* fall-through */
1961 case NL80211_IFTYPE_STATION:
1962 wlvif->bss_type = BSS_TYPE_STA_BSS;
1963 break;
1964 case NL80211_IFTYPE_ADHOC:
1965 wlvif->bss_type = BSS_TYPE_IBSS;
1966 break;
1967 case NL80211_IFTYPE_P2P_GO:
1968 wlvif->p2p = 1;
1969 /* fall-through */
1970 case NL80211_IFTYPE_AP:
1971 wlvif->bss_type = BSS_TYPE_AP_BSS;
1972 break;
1973 default:
1974 wlvif->bss_type = MAX_BSS_TYPE;
1975 return -EOPNOTSUPP;
1976 }
1977
0603d891 1978 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
7edebf56 1979 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
afaf8bdb 1980 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
a8ab39a4 1981
e936bbe0
EP		 1982 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
1983 wlvif->bss_type == BSS_TYPE_IBSS) {
1984 /* init sta/ibss data */
1985 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 1986 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
1987 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
1988 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
e936bbe0
EP		 1989 } else {
1990 /* init ap data */
1991 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
1992 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 1993 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
1994 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
1995 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
1996 wl12xx_allocate_rate_policy(wl,
1997 &wlvif->ap.ucast_rate_idx[i]);
e936bbe0 1998 }
a8ab39a4 1999
83587505
EP		 2000 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2001 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
87fbcb0f 2002 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
d2d66c56 2003 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
30d0c8fd 2004 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
6a899796
EP		 2005 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
2006
1b92f15e
EP		 2007 /*
2008 * mac80211 configures some values globally, while we treat them
2009 * per-interface. thus, on init, we have to copy them from wl
2010 */
2011 wlvif->band = wl->band;
61f845f4 2012 wlvif->channel = wl->channel;
6bd65029 2013 wlvif->power_level = wl->power_level;
1b92f15e 2014
9eb599e9
EP		 2015 INIT_WORK(&wlvif->rx_streaming_enable_work,
2016 wl1271_rx_streaming_enable_work);
2017 INIT_WORK(&wlvif->rx_streaming_disable_work,
2018 wl1271_rx_streaming_disable_work);
252efa4f 2019 INIT_DELAYED_WORK(&wlvif->pspoll_work, wl1271_pspoll_work);
87627214 2020 INIT_LIST_HEAD(&wlvif->list);
252efa4f 2021
9eb599e9
EP		 2022 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
2023 (unsigned long) wlvif);
e936bbe0 2024 return 0;
87fbcb0f
EP		 2025}
2026
1d095475 2027static bool wl12xx_init_fw(struct wl1271 *wl)
f5fc0f86 2028{
9ccd9217 2029 int retries = WL1271_BOOT_RETRIES;
71125abd 2030 bool booted = false;
1d095475
EP		 2031 struct wiphy *wiphy = wl->hw->wiphy;
2032 int ret;
f5fc0f86 2033
9ccd9217
JO		 2034 while (retries) {
2035 retries--;
2036 ret = wl1271_chip_wakeup(wl);
2037 if (ret < 0)
2038 goto power_off;
f5fc0f86 2039
9ccd9217
JO		 2040 ret = wl1271_boot(wl);
2041 if (ret < 0)
2042 goto power_off;
f5fc0f86 2043
92c77c73
EP		 2044 ret = wl1271_hw_init(wl);
2045 if (ret < 0)
2046 goto irq_disable;
2047
71125abd
EP		 2048 booted = true;
2049 break;
eb5b28d0 2050
9ccd9217 2051irq_disable:
9ccd9217
JO		 2052 mutex_unlock(&wl->mutex);
2053 /* Unlocking the mutex in the middle of handling is
2054 inherently unsafe. In this case we deem it safe to do,
2055 because we need to let any possibly pending IRQ out of
2056 the system (and while we are WL1271_STATE_OFF the IRQ
2057 work function will not do anything.) Also, any other
2058 possible concurrent operations will fail due to the
2059 current state, hence the wl1271 struct should be safe. */
a620865e
IY		 2060 wl1271_disable_interrupts(wl);
2061 wl1271_flush_deferred_work(wl);
2062 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 2063 mutex_lock(&wl->mutex);
2064power_off:
2065 wl1271_power_off(wl);
2066 }
eb5b28d0 2067
71125abd
EP		 2068 if (!booted) {
2069 wl1271_error("firmware boot failed despite %d retries",
2070 WL1271_BOOT_RETRIES);
2071 goto out;
2072 }
2073
4b7fac77 2074 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 2075
2076 /* update hw/fw version info in wiphy struct */
2077 wiphy->hw_version = wl->chip.id;
4b7fac77 2078 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 2079 sizeof(wiphy->fw_version));
2080
fb6a6819
LC		 2081 /*
2082 * Now we know if 11a is supported (info from the NVS), so disable
2083 * 11a channels if not supported
2084 */
2085 if (!wl->enable_11a)
2086 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
2087
2088 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2089 wl->enable_11a ? "" : "not ");
2090
1d095475
EP		 2091 wl->state = WL1271_STATE_ON;
2092out:
2093 return booted;
2094}
2095
2096static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2097 struct ieee80211_vif *vif)
2098{
2099 struct wl1271 *wl = hw->priv;
2100 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2101 int ret = 0;
2102 u8 role_type;
2103 bool booted = false;
2104
2105 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2106 ieee80211_vif_type_p2p(vif), vif->addr);
2107
2108 mutex_lock(&wl->mutex);
f750c820
EP		 2109 ret = wl1271_ps_elp_wakeup(wl);
2110 if (ret < 0)
2111 goto out_unlock;
2112
1d095475
EP		 2113 if (wl->vif) {
2114 wl1271_debug(DEBUG_MAC80211,
2115 "multiple vifs are not supported yet");
2116 ret = -EBUSY;
2117 goto out;
2118 }
2119
2120 /*
2121 * in some very corner case HW recovery scenarios its possible to
2122 * get here before __wl1271_op_remove_interface is complete, so
2123 * opt out if that is the case.
2124 */
10c8cd01
EP		 2125 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2126 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
1d095475
EP		 2127 ret = -EBUSY;
2128 goto out;
2129 }
2130
83587505 2131 ret = wl12xx_init_vif_data(wl, vif);
1d095475
EP		 2132 if (ret < 0)
2133 goto out;
2134
2135 wlvif->wl = wl;
2136 role_type = wl12xx_get_role_type(wl, wlvif);
2137 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2138 ret = -EINVAL;
2139 goto out;
2140 }
2141
2142 /*
2143 * TODO: after the nvs issue will be solved, move this block
2144 * to start(), and make sure here the driver is ON.
2145 */
2146 if (wl->state == WL1271_STATE_OFF) {
2147 /*
2148 * we still need this in order to configure the fw
2149 * while uploading the nvs
2150 */
2151 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
2152
2153 booted = wl12xx_init_fw(wl);
2154 if (!booted) {
2155 ret = -EINVAL;
2156 goto out;
2157 }
2158 }
2159
2160 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2161 wlvif->bss_type == BSS_TYPE_IBSS) {
2162 /*
2163 * The device role is a special role used for
2164 * rx and tx frames prior to association (as
2165 * the STA role can get packets only from
2166 * its associated bssid)
2167 */
2168 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2169 WL1271_ROLE_DEVICE,
2170 &wlvif->dev_role_id);
2171 if (ret < 0)
2172 goto out;
2173 }
2174
2175 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2176 role_type, &wlvif->role_id);
2177 if (ret < 0)
2178 goto out;
2179
2180 ret = wl1271_init_vif_specific(wl, vif);
2181 if (ret < 0)
2182 goto out;
2183
2184 wl->vif = vif;
87627214 2185 list_add(&wlvif->list, &wl->wlvif_list);
10c8cd01 2186 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
a4e4130d
EP		 2187
2188 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2189 wl->ap_count++;
2190 else
2191 wl->sta_count++;
eb5b28d0 2192out:
f750c820
EP		 2193 wl1271_ps_elp_sleep(wl);
2194out_unlock:
f5fc0f86
LC		 2195 mutex_unlock(&wl->mutex);
2196
f9f774c1 2197 mutex_lock(&wl_list_mutex);
eb887dfd 2198 if (!ret)
01c09162 2199 list_add(&wl->list, &wl_list);
f9f774c1 2200 mutex_unlock(&wl_list_mutex);
01c09162 2201
f5fc0f86
LC		 2202 return ret;
2203}
2204
7dece1c8 2205static void __wl1271_op_remove_interface(struct wl1271 *wl,
536129c8 2206 struct ieee80211_vif *vif,
7dece1c8 2207 bool reset_tx_queues)
f5fc0f86 2208{
536129c8 2209 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e5a359f8 2210 int i, ret;
f5fc0f86 2211
1b72aecd 2212 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 2213
10c8cd01
EP		 2214 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2215 return;
2216
2f8e81ad
EP		 2217 wl->vif = NULL;
2218
13026dec
JO		 2219 /* because of hardware recovery, we may get here twice */
2220 if (wl->state != WL1271_STATE_ON)
2221 return;
2222
1b72aecd 2223 wl1271_info("down");
f5fc0f86 2224
8d2ef7bd 2225 /* enable dyn ps just in case (if left on due to fw crash etc) */
536129c8 2226 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
baf6277a 2227 ieee80211_enable_dyn_ps(vif);
8d2ef7bd 2228
baf6277a
EP		 2229 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2230 wl->scan_vif == vif) {
08688d6b 2231 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 2232 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
784f694d 2233 wl->scan_vif = NULL;
b739a42c 2234 wl->scan.req = NULL;
76a029fb 2235 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 2236 }
2237
b78b47eb
EP		 2238 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2239 /* disable active roles */
2240 ret = wl1271_ps_elp_wakeup(wl);
2241 if (ret < 0)
2242 goto deinit;
2243
536129c8 2244 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
7edebf56 2245 ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
04e8079c
EP		 2246 if (ret < 0)
2247 goto deinit;
2248 }
2249
0603d891 2250 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
b78b47eb
EP		 2251 if (ret < 0)
2252 goto deinit;
2253
2254 wl1271_ps_elp_sleep(wl);
2255 }
2256deinit:
e51ae9be 2257 /* clear all hlids (except system_hlid) */
afaf8bdb 2258 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 2259
2260 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2261 wlvif->bss_type == BSS_TYPE_IBSS) {
2262 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2263 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2264 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2265 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2266 } else {
2267 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2268 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2269 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2270 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2271 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2272 wl12xx_free_rate_policy(wl,
2273 &wlvif->ap.ucast_rate_idx[i]);
2274 }
b78b47eb 2275
d6a3cc2e 2276 wl12xx_tx_reset_wlvif(wl, wlvif);
170d0e67 2277 wl1271_free_ap_keys(wl, wlvif);
e4120df9
EP		 2278 if (wl->last_wlvif == wlvif)
2279 wl->last_wlvif = NULL;
87627214 2280 list_del(&wlvif->list);
c7ffb902 2281 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
0603d891 2282 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
7edebf56 2283 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
d6e19d13 2284
a4e4130d
EP		 2285 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2286 wl->ap_count--;
2287 else
2288 wl->sta_count--;
2289
baf6277a 2290 mutex_unlock(&wl->mutex);
9eb599e9
EP		 2291 del_timer_sync(&wlvif->rx_streaming_timer);
2292 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2293 cancel_work_sync(&wlvif->rx_streaming_disable_work);
baf6277a 2294 cancel_delayed_work_sync(&wlvif->pspoll_work);
bd9dc49c 2295
baf6277a 2296 mutex_lock(&wl->mutex);
52a2a375 2297}
bd9dc49c 2298
52a2a375
JO		 2299static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2300 struct ieee80211_vif *vif)
2301{
2302 struct wl1271 *wl = hw->priv;
10c8cd01 2303 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
6e8cd331 2304 struct wl12xx_vif *iter;
52a2a375
JO		 2305
2306 mutex_lock(&wl->mutex);
10c8cd01
EP		 2307
2308 if (wl->state == WL1271_STATE_OFF ||
2309 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2310 goto out;
2311
67353299
JO		 2312 /*
2313 * wl->vif can be null here if someone shuts down the interface
2314 * just when hardware recovery has been started.
2315 */
6e8cd331
EP		 2316 wl12xx_for_each_wlvif(wl, iter) {
2317 if (iter != wlvif)
2318 continue;
2319
536129c8 2320 __wl1271_op_remove_interface(wl, vif, true);
6e8cd331 2321 break;
67353299 2322 }
6e8cd331 2323 WARN_ON(iter != wlvif);
10c8cd01 2324out:
67353299 2325 mutex_unlock(&wl->mutex);
52b0e7a6 2326 cancel_work_sync(&wl->recovery_work);
f5fc0f86
LC		 2327}
2328
87fbcb0f
EP		 2329static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2330 bool set_assoc)
82429d32
JO		 2331{
2332 int ret;
536129c8 2333 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
82429d32 2334
69e5434c
JO		 2335 /*
2336 * One of the side effects of the JOIN command is that is clears
2337 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2338 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2339 * Currently the only valid scenario for JOIN during association
2340 * is on roaming, in which case we will also be given new keys.
2341 * Keep the below message for now, unless it starts bothering
2342 * users who really like to roam a lot :)
69e5434c 2343 */
ba8447f6 2344 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
69e5434c
JO		 2345 wl1271_info("JOIN while associated.");
2346
2347 if (set_assoc)
ba8447f6 2348 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
69e5434c 2349
227e81e1 2350 if (is_ibss)
87fbcb0f 2351 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
227e81e1 2352 else
87fbcb0f 2353 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
82429d32
JO		 2354 if (ret < 0)
2355 goto out;
2356
ba8447f6 2357 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
82429d32
JO		 2358 goto out;
2359
2360 /*
2361 * The join command disable the keep-alive mode, shut down its process,
2362 * and also clear the template config, so we need to reset it all after
2363 * the join. The acx_aid starts the keep-alive process, and the order
2364 * of the commands below is relevant.
2365 */
0603d891 2366 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
82429d32
JO		 2367 if (ret < 0)
2368 goto out;
2369
0603d891 2370 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
82429d32
JO		 2371 if (ret < 0)
2372 goto out;
2373
d2d66c56 2374 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
82429d32
JO		 2375 if (ret < 0)
2376 goto out;
2377
0603d891
EP		 2378 ret = wl1271_acx_keep_alive_config(wl, wlvif,
2379 CMD_TEMPL_KLV_IDX_NULL_DATA,
82429d32
JO		 2380 ACX_KEEP_ALIVE_TPL_VALID);
2381 if (ret < 0)
2382 goto out;
2383
2384out:
2385 return ret;
2386}
2387
0603d891 2388static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
c7f43e45
LC		 2389{
2390 int ret;
2391
52630c5d 2392 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
6e8cd331
EP		 2393 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2394
6d158ff3 2395 wl12xx_cmd_stop_channel_switch(wl);
6e8cd331 2396 ieee80211_chswitch_done(vif, false);
6d158ff3
SL		 2397 }
2398
c7f43e45 2399 /* to stop listening to a channel, we disconnect */
0603d891 2400 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
c7f43e45
LC		 2401 if (ret < 0)
2402 goto out;
2403
b992c682 2404 /* reset TX security counters on a clean disconnect */
48e93e40
EP		 2405 wlvif->tx_security_last_seq_lsb = 0;
2406 wlvif->tx_security_seq = 0;
b992c682 2407
c7f43e45
LC		 2408out:
2409 return ret;
2410}
2411
87fbcb0f 2412static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ebba60c6 2413{
1b92f15e 2414 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
30d0c8fd 2415 wlvif->rate_set = wlvif->basic_rate_set;
ebba60c6
JO		 2416}
2417
251c177f
EP		 2418static bool wl12xx_is_roc(struct wl1271 *wl)
2419{
2420 u8 role_id;
2421
2422 role_id = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
2423 if (role_id >= WL12XX_MAX_ROLES)
2424 return false;
2425
2426 return true;
2427}
2428
87fbcb0f
EP		 2429static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2430 bool idle)
0d58cbff
JO		 2431{
2432 int ret;
2433
2434 if (idle) {
251c177f
EP		 2435 /* no need to croc if we weren't busy (e.g. during boot) */
2436 if (wl12xx_is_roc(wl)) {
679a6734 2437 ret = wl12xx_stop_dev(wl, wlvif);
0d58cbff
JO		 2438 if (ret < 0)
2439 goto out;
2440 }
30d0c8fd
EP		 2441 wlvif->rate_set =
2442 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2443 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
0d58cbff
JO		 2444 if (ret < 0)
2445 goto out;
2446 ret = wl1271_acx_keep_alive_config(
0603d891 2447 wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
0d58cbff
JO		 2448 ACX_KEEP_ALIVE_TPL_INVALID);
2449 if (ret < 0)
2450 goto out;
2451 set_bit(WL1271_FLAG_IDLE, &wl->flags);
2452 } else {
33c2c06c
LC		 2453 /* The current firmware only supports sched_scan in idle */
2454 if (wl->sched_scanning) {
2455 wl1271_scan_sched_scan_stop(wl);
2456 ieee80211_sched_scan_stopped(wl->hw);
2457 }
2458
679a6734 2459 ret = wl12xx_start_dev(wl, wlvif);
0d58cbff
JO		 2460 if (ret < 0)
2461 goto out;
2462 clear_bit(WL1271_FLAG_IDLE, &wl->flags);
2463 }
2464
2465out:
2466 return ret;
2467}
2468
9f259c4e
EP		 2469static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2470 struct ieee80211_conf *conf, u32 changed)
f5fc0f86 2471{
9f259c4e
EP		 2472 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2473 int channel, ret;
f5fc0f86
LC		 2474
2475 channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
2476
ebba60c6 2477 /* if the channel changes while joined, join again */
69e5434c 2478 if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
1b92f15e 2479 ((wlvif->band != conf->channel->band) ||
61f845f4 2480 (wlvif->channel != channel))) {
c6930b07 2481 /* send all pending packets */
a32d0cdf 2482 wl1271_tx_work_locked(wl);
61f845f4
EP		 2483 wlvif->band = conf->channel->band;
2484 wlvif->channel = channel;
ebba60c6 2485
bee0ffec
AN		 2486 if (!is_ap) {
2487 /*
2488 * FIXME: the mac80211 should really provide a fixed
2489 * rate to use here. for now, just use the smallest
2490 * possible rate for the band as a fixed rate for
2491 * association frames and other control messages.
2492 */
ba8447f6 2493 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
87fbcb0f 2494 wl1271_set_band_rate(wl, wlvif);
bee0ffec 2495
d2d66c56 2496 wlvif->basic_rate =
87fbcb0f
EP		 2497 wl1271_tx_min_rate_get(wl,
2498 wlvif->basic_rate_set);
30d0c8fd 2499 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 2500 if (ret < 0)
bee0ffec 2501 wl1271_warning("rate policy for channel "
ebba60c6 2502 "failed %d", ret);
bee0ffec 2503
ba8447f6
EP		 2504 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED,
2505 &wlvif->flags)) {
251c177f
EP		 2506 if (wl12xx_is_roc(wl)) {
2507 /* roaming */
7edebf56
EP		 2508 ret = wl12xx_croc(wl,
2509 wlvif->dev_role_id);
251c177f 2510 if (ret < 0)
9f259c4e 2511 return ret;
251c177f 2512 }
87fbcb0f 2513 ret = wl1271_join(wl, wlvif, false);
bee0ffec
AN		 2514 if (ret < 0)
2515 wl1271_warning("cmd join on channel "
2516 "failed %d", ret);
251c177f
EP		 2517 } else {
2518 /*
2519 * change the ROC channel. do it only if we are
2520 * not idle. otherwise, CROC will be called
2521 * anyway.
2522 */
2523 if (wl12xx_is_roc(wl) &&
2524 !(conf->flags & IEEE80211_CONF_IDLE)) {
679a6734 2525 ret = wl12xx_stop_dev(wl, wlvif);
251c177f 2526 if (ret < 0)
9f259c4e 2527 return ret;
251c177f 2528
679a6734 2529 ret = wl12xx_start_dev(wl, wlvif);
251c177f 2530 if (ret < 0)
679a6734 2531 return ret;
251c177f 2532 }
bee0ffec 2533 }
ebba60c6
JO		 2534 }
2535 }
2536
bee0ffec 2537 if (changed & IEEE80211_CONF_CHANGE_IDLE && !is_ap) {
87fbcb0f 2538 ret = wl1271_sta_handle_idle(wl, wlvif,
bee0ffec 2539 conf->flags & IEEE80211_CONF_IDLE);
0d58cbff
JO		 2540 if (ret < 0)
2541 wl1271_warning("idle mode change failed %d", ret);
f5fc0f86
LC		 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
68eaaf6e 3303static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl,
1fe9f161 3304 struct ieee80211_vif *vif,
68eaaf6e
AN		 3305 u8 *probe_rsp_data,
3306 size_t probe_rsp_len,
3307 u32 rates)
3308{
1fe9f161
EP		 3309 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3310 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
68eaaf6e
AN		 3311 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3312 int ssid_ie_offset, ie_offset, templ_len;
3313 const u8 *ptr;
3314
3315 /* no need to change probe response if the SSID is set correctly */
1fe9f161 3316 if (wlvif->ssid_len > 0)
68eaaf6e
AN		 3317 return wl1271_cmd_template_set(wl,
3318 CMD_TEMPL_AP_PROBE_RESPONSE,
3319 probe_rsp_data,
3320 probe_rsp_len, 0,
3321 rates);
3322
3323 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3324 wl1271_error("probe_rsp template too big");
3325 return -EINVAL;
3326 }
3327
3328 /* start searching from IE offset */
3329 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3330
3331 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3332 probe_rsp_len - ie_offset);
3333 if (!ptr) {
3334 wl1271_error("No SSID in beacon!");
3335 return -EINVAL;
3336 }
3337
3338 ssid_ie_offset = ptr - probe_rsp_data;
3339 ptr += (ptr[1] + 2);
3340
3341 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3342
3343 /* insert SSID from bss_conf */
3344 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3345 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3346 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3347 bss_conf->ssid, bss_conf->ssid_len);
3348 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3349
3350 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3351 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3352 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3353
3354 return wl1271_cmd_template_set(wl,
3355 CMD_TEMPL_AP_PROBE_RESPONSE,
3356 probe_rsp_templ,
3357 templ_len, 0,
3358 rates);
3359}
3360
e78a287a 3361static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
0603d891 3362 struct ieee80211_vif *vif,
f5fc0f86
LC		 3363 struct ieee80211_bss_conf *bss_conf,
3364 u32 changed)
3365{
0603d891 3366 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3367 int ret = 0;
f5fc0f86 3368
e78a287a
AN		 3369 if (changed & BSS_CHANGED_ERP_SLOT) {
3370 if (bss_conf->use_short_slot)
0603d891 3371 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
e78a287a 3372 else
0603d891 3373 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
e78a287a
AN		 3374 if (ret < 0) {
3375 wl1271_warning("Set slot time failed %d", ret);
3376 goto out;
3377 }
3378 }
f5fc0f86 3379
e78a287a
AN		 3380 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3381 if (bss_conf->use_short_preamble)
0603d891 3382 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
e78a287a 3383 else
0603d891 3384 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
e78a287a 3385 }
f5fc0f86 3386
e78a287a
AN		 3387 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3388 if (bss_conf->use_cts_prot)
0603d891
EP		 3389 ret = wl1271_acx_cts_protect(wl, wlvif,
3390 CTSPROTECT_ENABLE);
e78a287a 3391 else
0603d891
EP		 3392 ret = wl1271_acx_cts_protect(wl, wlvif,
3393 CTSPROTECT_DISABLE);
e78a287a
AN		 3394 if (ret < 0) {
3395 wl1271_warning("Set ctsprotect failed %d", ret);
3396 goto out;
3397 }
3398 }
f8d9802f 3399
e78a287a
AN		 3400out:
3401 return ret;
3402}
f5fc0f86 3403
e78a287a
AN		 3404static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
3405 struct ieee80211_vif *vif,
3406 struct ieee80211_bss_conf *bss_conf,
3407 u32 changed)
3408{
87fbcb0f 3409 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
536129c8 3410 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 3411 int ret = 0;
3412
3413 if ((changed & BSS_CHANGED_BEACON_INT)) {
3414 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 3415 bss_conf->beacon_int);
3416
6a899796 3417 wlvif->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 3418 }
3419
e78a287a
AN		 3420 if ((changed & BSS_CHANGED_BEACON)) {
3421 struct ieee80211_hdr *hdr;
af7fbb28 3422 u32 min_rate;
e78a287a
AN		 3423 int ieoffset = offsetof(struct ieee80211_mgmt,
3424 u.beacon.variable);
3425 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3426 u16 tmpl_id;
3427
3428 if (!beacon)
3429 goto out;
3430
3431 wl1271_debug(DEBUG_MASTER, "beacon updated");
3432
1fe9f161 3433 ret = wl1271_ssid_set(vif, beacon, ieoffset);
e78a287a
AN		 3434 if (ret < 0) {
3435 dev_kfree_skb(beacon);
3436 goto out;
3437 }
87fbcb0f 3438 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
e78a287a
AN		 3439 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3440 CMD_TEMPL_BEACON;
3441 ret = wl1271_cmd_template_set(wl, tmpl_id,
3442 beacon->data,
3443 beacon->len, 0,
af7fbb28 3444 min_rate);
e78a287a
AN		 3445 if (ret < 0) {
3446 dev_kfree_skb(beacon);
3447 goto out;
3448 }
3449
d48055d9
EP		 3450 /* remove TIM ie from probe response */
3451 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3452
26b4bf2e
EP		 3453 /*
3454 * remove p2p ie from probe response.
3455 * the fw reponds to probe requests that don't include
3456 * the p2p ie. probe requests with p2p ie will be passed,
3457 * and will be responded by the supplicant (the spec
3458 * forbids including the p2p ie when responding to probe
3459 * requests that didn't include it).
3460 */
3461 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3462 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3463
e78a287a
AN		 3464 hdr = (struct ieee80211_hdr *) beacon->data;
3465 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3466 IEEE80211_STYPE_PROBE_RESP);
68eaaf6e 3467 if (is_ap)
1fe9f161 3468 ret = wl1271_ap_set_probe_resp_tmpl(wl, vif,
68eaaf6e
AN		 3469 beacon->data,
3470 beacon->len,
af7fbb28 3471 min_rate);
68eaaf6e
AN		 3472 else
3473 ret = wl1271_cmd_template_set(wl,
3474 CMD_TEMPL_PROBE_RESPONSE,
3475 beacon->data,
3476 beacon->len, 0,
af7fbb28 3477 min_rate);
e78a287a
AN		 3478 dev_kfree_skb(beacon);
3479 if (ret < 0)
3480 goto out;
3481 }
3482
3483out:
3484 return ret;
3485}
3486
3487/* AP mode changes */
3488static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
3489 struct ieee80211_vif *vif,
3490 struct ieee80211_bss_conf *bss_conf,
3491 u32 changed)
3492{
87fbcb0f 3493 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3494 int ret = 0;
e0d8bbf0 3495
e78a287a
AN		 3496 if ((changed & BSS_CHANGED_BASIC_RATES)) {
3497 u32 rates = bss_conf->basic_rates;
5da11dcd 3498
87fbcb0f 3499 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3500 wlvif->band);
d2d66c56 3501 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
87fbcb0f 3502 wlvif->basic_rate_set);
70f47424 3503
87fbcb0f 3504 ret = wl1271_init_ap_rates(wl, wlvif);
e78a287a 3505 if (ret < 0) {
70f47424 3506 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 3507 goto out;
3508 }
c45a85b5 3509
784f694d 3510 ret = wl1271_ap_init_templates(wl, vif);
c45a85b5
AN		 3511 if (ret < 0)
3512 goto out;
e78a287a 3513 }
2f6724b2 3514
e78a287a
AN		 3515 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
3516 if (ret < 0)
3517 goto out;
30240fc7 3518
e78a287a
AN		 3519 if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
3520 if (bss_conf->enable_beacon) {
53d40d0b 3521 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
87fbcb0f 3522 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
e78a287a
AN		 3523 if (ret < 0)
3524 goto out;
e0d8bbf0 3525
a8ab39a4 3526 ret = wl1271_ap_init_hwenc(wl, wlvif);
7f179b46
AN		 3527 if (ret < 0)
3528 goto out;
cf42039f 3529
53d40d0b 3530 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
cf42039f 3531 wl1271_debug(DEBUG_AP, "started AP");
e0d8bbf0 3532 }
e78a287a 3533 } else {
53d40d0b 3534 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
0603d891 3535 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
e78a287a
AN		 3536 if (ret < 0)
3537 goto out;
e0d8bbf0 3538
53d40d0b 3539 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
e78a287a
AN		 3540 wl1271_debug(DEBUG_AP, "stopped AP");
3541 }
3542 }
3543 }
e0d8bbf0 3544
0603d891 3545 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 3546 if (ret < 0)
3547 goto out;
0b932ab9
AN		 3548
3549 /* Handle HT information change */
3550 if ((changed & BSS_CHANGED_HT) &&
3551 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0603d891 3552 ret = wl1271_acx_set_ht_information(wl, wlvif,
0b932ab9
AN		 3553 bss_conf->ht_operation_mode);
3554 if (ret < 0) {
3555 wl1271_warning("Set ht information failed %d", ret);
3556 goto out;
3557 }
3558 }
3559
e78a287a
AN		 3560out:
3561 return;
3562}
8bf29b0e 3563
e78a287a
AN		 3564/* STA/IBSS mode changes */
3565static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
3566 struct ieee80211_vif *vif,
3567 struct ieee80211_bss_conf *bss_conf,
3568 u32 changed)
3569{
87fbcb0f 3570 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3571 bool do_join = false, set_assoc = false;
536129c8 3572 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
227e81e1 3573 bool ibss_joined = false;
72c2d9e5 3574 u32 sta_rate_set = 0;
e78a287a 3575 int ret;
2d6e4e76 3576 struct ieee80211_sta *sta;
a100885d
AN		 3577 bool sta_exists = false;
3578 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 3579
3580 if (is_ibss) {
3581 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
3582 changed);
3583 if (ret < 0)
3584 goto out;
e0d8bbf0
JO		 3585 }
3586
227e81e1
EP		 3587 if (changed & BSS_CHANGED_IBSS) {
3588 if (bss_conf->ibss_joined) {
eee514e3 3589 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
227e81e1
EP		 3590 ibss_joined = true;
3591 } else {
eee514e3
EP		 3592 if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3593 &wlvif->flags)) {
0603d891 3594 wl1271_unjoin(wl, wlvif);
679a6734 3595 wl12xx_start_dev(wl, wlvif);
227e81e1
EP		 3596 }
3597 }
3598 }
3599
3600 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
e78a287a
AN		 3601 do_join = true;
3602
3603 /* Need to update the SSID (for filtering etc) */
227e81e1 3604 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
e78a287a
AN		 3605 do_join = true;
3606
227e81e1 3607 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
5da11dcd
JO		 3608 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
3609 bss_conf->enable_beacon ? "enabled" : "disabled");
3610
5da11dcd
JO		 3611 do_join = true;
3612 }
3613
e78a287a 3614 if ((changed & BSS_CHANGED_CQM)) {
00236aed
JO		 3615 bool enable = false;
3616 if (bss_conf->cqm_rssi_thold)
3617 enable = true;
0603d891 3618 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
00236aed
JO		 3619 bss_conf->cqm_rssi_thold,
3620 bss_conf->cqm_rssi_hyst);
3621 if (ret < 0)
3622 goto out;
04324d99 3623 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
00236aed
JO		 3624 }
3625
cdf09495
EP		 3626 if (changed & BSS_CHANGED_BSSID)
3627 if (!is_zero_ether_addr(bss_conf->bssid)) {
d2d66c56 3628 ret = wl12xx_cmd_build_null_data(wl, wlvif);
fa287b8f
EP		 3629 if (ret < 0)
3630 goto out;
30240fc7 3631
784f694d 3632 ret = wl1271_build_qos_null_data(wl, vif);
fa287b8f
EP		 3633 if (ret < 0)
3634 goto out;
30240fc7 3635
fa287b8f
EP		 3636 /* Need to update the BSSID (for filtering etc) */
3637 do_join = true;
3638 }
30240fc7 3639
0f9c8250
AN		 3640 if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
3641 rcu_read_lock();
3642 sta = ieee80211_find_sta(vif, bss_conf->bssid);
3643 if (!sta)
3644 goto sta_not_found;
3645
72c2d9e5
EP		 3646 /* save the supp_rates of the ap */
3647 sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
3648 if (sta->ht_cap.ht_supported)
3649 sta_rate_set |=
3650 (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
a100885d
AN		 3651 sta_ht_cap = sta->ht_cap;
3652 sta_exists = true;
72c2d9e5 3653
0f9c8250
AN		 3654sta_not_found:
3655 rcu_read_unlock();
72c2d9e5 3656 }
72c2d9e5 3657
e78a287a 3658 if ((changed & BSS_CHANGED_ASSOC)) {
f5fc0f86 3659 if (bss_conf->assoc) {
ebba60c6 3660 u32 rates;
2f6724b2 3661 int ieoffset;
6840e37a 3662 wlvif->aid = bss_conf->aid;
69e5434c 3663 set_assoc = true;
f5fc0f86 3664
74ec8395 3665 wlvif->ps_poll_failures = 0;
90494a90 3666
ebba60c6
JO		 3667 /*
3668 * use basic rates from AP, and determine lowest rate
3669 * to use with control frames.
3670 */
3671 rates = bss_conf->basic_rates;
87fbcb0f 3672 wlvif->basic_rate_set =
af7fbb28 3673 wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3674 wlvif->band);
d2d66c56 3675 wlvif->basic_rate =
87fbcb0f
EP		 3676 wl1271_tx_min_rate_get(wl,
3677 wlvif->basic_rate_set);
72c2d9e5 3678 if (sta_rate_set)
30d0c8fd
EP		 3679 wlvif->rate_set =
3680 wl1271_tx_enabled_rates_get(wl,
af7fbb28 3681 sta_rate_set,
1b92f15e 3682 wlvif->band);
30d0c8fd 3683 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 3684 if (ret < 0)
e78a287a 3685 goto out;
ebba60c6 3686
ae751bab
LC		 3687 /*
3688 * with wl1271, we don't need to update the
3689 * beacon_int and dtim_period, because the firmware
3690 * updates it by itself when the first beacon is
3691 * received after a join.
3692 */
6840e37a 3693 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
f5fc0f86 3694 if (ret < 0)
e78a287a 3695 goto out;
f5fc0f86 3696
c2b2d99b 3697 /*
2f6724b2 3698 * Get a template for hardware connection maintenance
c2b2d99b 3699 */
bddb29b8
EP		 3700 dev_kfree_skb(wlvif->probereq);
3701 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
83587505 3702 wlvif,
bddb29b8 3703 NULL);
2f6724b2
JO		 3704 ieoffset = offsetof(struct ieee80211_mgmt,
3705 u.probe_req.variable);
bddb29b8 3706 wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
c2b2d99b 3707
6ccbb92e 3708 /* enable the connection monitoring feature */
0603d891 3709 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
f5fc0f86 3710 if (ret < 0)
e78a287a 3711 goto out;
d94cd297
JO		 3712 } else {
3713 /* use defaults when not associated */
30df14d0 3714 bool was_assoc =
ba8447f6
EP		 3715 !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
3716 &wlvif->flags);
251c177f 3717 bool was_ifup =
8181aecc
EP		 3718 !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
3719 &wlvif->flags);
6840e37a 3720 wlvif->aid = 0;
6ccbb92e 3721
2f6724b2 3722 /* free probe-request template */
bddb29b8
EP		 3723 dev_kfree_skb(wlvif->probereq);
3724 wlvif->probereq = NULL;
2f6724b2 3725
8d2ef7bd 3726 /* re-enable dynamic ps - just in case */
6e8cd331 3727 ieee80211_enable_dyn_ps(vif);
8d2ef7bd 3728
ebba60c6 3729 /* revert back to minimum rates for the current band */
87fbcb0f 3730 wl1271_set_band_rate(wl, wlvif);
d2d66c56 3731 wlvif->basic_rate =
87fbcb0f
EP		 3732 wl1271_tx_min_rate_get(wl,
3733 wlvif->basic_rate_set);
30d0c8fd 3734 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
ebba60c6 3735 if (ret < 0)
e78a287a 3736 goto out;
ebba60c6 3737
6ccbb92e 3738 /* disable connection monitor features */
0603d891 3739 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
c1899554
JO		 3740
3741 /* Disable the keep-alive feature */
0603d891 3742 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
6ccbb92e 3743 if (ret < 0)
e78a287a 3744 goto out;
b84a7d3d
JO		 3745
3746 /* restore the bssid filter and go to dummy bssid */
30df14d0 3747 if (was_assoc) {
251c177f
EP		 3748 u32 conf_flags = wl->hw->conf.flags;
3749 /*
3750 * we might have to disable roc, if there was
3751 * no IF_OPER_UP notification.
3752 */
3753 if (!was_ifup) {
0603d891 3754 ret = wl12xx_croc(wl, wlvif->role_id);
251c177f
EP		 3755 if (ret < 0)
3756 goto out;
3757 }
3758 /*
3759 * (we also need to disable roc in case of
3760 * roaming on the same channel. until we will
3761 * have a better flow...)
3762 */
7edebf56
EP		 3763 if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
3764 ret = wl12xx_croc(wl,
3765 wlvif->dev_role_id);
251c177f
EP		 3766 if (ret < 0)
3767 goto out;
3768 }
3769
0603d891 3770 wl1271_unjoin(wl, wlvif);
679a6734
EP		 3771 if (!(conf_flags & IEEE80211_CONF_IDLE))
3772 wl12xx_start_dev(wl, wlvif);
30df14d0 3773 }
f5fc0f86 3774 }
f5fc0f86
LC		 3775 }
3776
d192d268
EP		 3777 if (changed & BSS_CHANGED_IBSS) {
3778 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
3779 bss_conf->ibss_joined);
3780
3781 if (bss_conf->ibss_joined) {
3782 u32 rates = bss_conf->basic_rates;
87fbcb0f 3783 wlvif->basic_rate_set =
af7fbb28 3784 wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 3785 wlvif->band);
d2d66c56 3786 wlvif->basic_rate =
87fbcb0f
EP		 3787 wl1271_tx_min_rate_get(wl,
3788 wlvif->basic_rate_set);
d192d268 3789
06b660e1 3790 /* by default, use 11b + OFDM rates */
30d0c8fd
EP		 3791 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
3792 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
d192d268
EP		 3793 if (ret < 0)
3794 goto out;
3795 }
3796 }
3797
0603d891 3798 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 3799 if (ret < 0)
3800 goto out;
f5fc0f86 3801
ca52a5eb
JO		 3802 if (changed & BSS_CHANGED_ARP_FILTER) {
3803 __be32 addr = bss_conf->arp_addr_list[0];
536129c8 3804 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
ca52a5eb 3805
c5312772
EP		 3806 if (bss_conf->arp_addr_cnt == 1 &&
3807 bss_conf->arp_filter_enabled) {
3808 /*
3809 * The template should have been configured only upon
3810 * association. however, it seems that the correct ip
3811 * isn't being set (when sending), so we have to
3812 * reconfigure the template upon every ip change.
3813 */
d2d66c56 3814 ret = wl1271_cmd_build_arp_rsp(wl, wlvif, addr);
c5312772
EP		 3815 if (ret < 0) {
3816 wl1271_warning("build arp rsp failed: %d", ret);
e78a287a 3817 goto out;
c5312772
EP		 3818 }
3819
0603d891 3820 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
e5e2f24b 3821 ACX_ARP_FILTER_ARP_FILTERING,
c5312772
EP		 3822 addr);
3823 } else
0603d891 3824 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
ca52a5eb
JO		 3825
3826 if (ret < 0)
e78a287a 3827 goto out;
ca52a5eb
JO		 3828 }
3829
8bf29b0e 3830 if (do_join) {
87fbcb0f 3831 ret = wl1271_join(wl, wlvif, set_assoc);
8bf29b0e
JO		 3832 if (ret < 0) {
3833 wl1271_warning("cmd join failed %d", ret);
e78a287a 3834 goto out;
8bf29b0e 3835 }
251c177f
EP		 3836
3837 /* ROC until connected (after EAPOL exchange) */
3838 if (!is_ibss) {
1b92f15e 3839 ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
251c177f
EP		 3840 if (ret < 0)
3841 goto out;
3842
ba8447f6 3843 wl1271_check_operstate(wl, wlvif,
251c177f
EP		 3844 ieee80211_get_operstate(vif));
3845 }
3846 /*
3847 * stop device role if started (we might already be in
3848 * STA role). TODO: make it better.
3849 */
7edebf56 3850 if (wlvif->dev_role_id != WL12XX_INVALID_ROLE_ID) {
679a6734 3851 ret = wl12xx_stop_dev(wl, wlvif);
251c177f
EP		 3852 if (ret < 0)
3853 goto out;
3854 }
05dba355
EP		 3855
3856 /* If we want to go in PSM but we're not there yet */
c29bb001
EP		 3857 if (test_bit(WLVIF_FLAG_PSM_REQUESTED, &wlvif->flags) &&
3858 !test_bit(WLVIF_FLAG_PSM, &wlvif->flags)) {
05dba355
EP		 3859 enum wl1271_cmd_ps_mode mode;
3860
3861 mode = STATION_POWER_SAVE_MODE;
0603d891 3862 ret = wl1271_ps_set_mode(wl, wlvif, mode,
d2d66c56 3863 wlvif->basic_rate,
05dba355
EP		 3864 true);
3865 if (ret < 0)
3866 goto out;
3867 }
c1899554
JO		 3868 }
3869
0b932ab9 3870 /* Handle new association with HT. Do this after join. */
0f9c8250
AN		 3871 if (sta_exists) {
3872 if ((changed & BSS_CHANGED_HT) &&
3873 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0b932ab9
AN		 3874 ret = wl1271_acx_set_ht_capabilities(wl,
3875 &sta_ht_cap,
3876 true,
154da67c 3877 wlvif->sta.hlid);
0f9c8250
AN		 3878 if (ret < 0) {
3879 wl1271_warning("Set ht cap true failed %d",
3880 ret);
3881 goto out;
3882 }
3883 }
3884 /* handle new association without HT and disassociation */
3885 else if (changed & BSS_CHANGED_ASSOC) {
0b932ab9
AN		 3886 ret = wl1271_acx_set_ht_capabilities(wl,
3887 &sta_ht_cap,
3888 false,
154da67c 3889 wlvif->sta.hlid);
0f9c8250
AN		 3890 if (ret < 0) {
3891 wl1271_warning("Set ht cap false failed %d",
3892 ret);
3893 goto out;
3894 }
3895 }
3896 }
3897
0b932ab9
AN		 3898 /* Handle HT information change. Done after join. */
3899 if ((changed & BSS_CHANGED_HT) &&
0f9c8250 3900 (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
0603d891 3901 ret = wl1271_acx_set_ht_information(wl, wlvif,
0f9c8250
AN		 3902 bss_conf->ht_operation_mode);
3903 if (ret < 0) {
3904 wl1271_warning("Set ht information failed %d", ret);
3905 goto out;
3906 }
3907 }
3908
e78a287a
AN		 3909out:
3910 return;
3911}
3912
3913static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
3914 struct ieee80211_vif *vif,
3915 struct ieee80211_bss_conf *bss_conf,
3916 u32 changed)
3917{
3918 struct wl1271 *wl = hw->priv;
536129c8
EP		 3919 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3920 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 3921 int ret;
3922
3923 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
3924 (int)changed);
3925
3926 mutex_lock(&wl->mutex);
3927
3928 if (unlikely(wl->state == WL1271_STATE_OFF))
3929 goto out;
3930
10c8cd01
EP		 3931 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
3932 goto out;
3933
a620865e 3934 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 3935 if (ret < 0)
3936 goto out;
3937
3938 if (is_ap)
3939 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
3940 else
3941 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
3942
f5fc0f86
LC		 3943 wl1271_ps_elp_sleep(wl);
3944
3945out:
3946 mutex_unlock(&wl->mutex);
3947}
3948
8a3a3c85
EP		 3949static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
3950 struct ieee80211_vif *vif, u16 queue,
c6999d83
KV		 3951 const struct ieee80211_tx_queue_params *params)
3952{
3953 struct wl1271 *wl = hw->priv;
0603d891 3954 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4695dc91 3955 u8 ps_scheme;
488fc540 3956 int ret = 0;
c6999d83
KV		 3957
3958 mutex_lock(&wl->mutex);
3959
3960 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
3961
4695dc91
KV		 3962 if (params->uapsd)
3963 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
3964 else
3965 ps_scheme = CONF_PS_SCHEME_LEGACY;
3966
488fc540
AN		 3967 if (wl->state == WL1271_STATE_OFF) {
3968 /*
3969 * If the state is off, the parameters will be recorded and
3970 * configured on init. This happens in AP-mode.
3971 */
3972 struct conf_tx_ac_category *conf_ac =
3973 &wl->conf.tx.ac_conf[wl1271_tx_get_queue(queue)];
3974 struct conf_tx_tid *conf_tid =
3975 &wl->conf.tx.tid_conf[wl1271_tx_get_queue(queue)];
3976
3977 conf_ac->ac = wl1271_tx_get_queue(queue);
3978 conf_ac->cw_min = (u8)params->cw_min;
3979 conf_ac->cw_max = params->cw_max;
3980 conf_ac->aifsn = params->aifs;
3981 conf_ac->tx_op_limit = params->txop << 5;
3982
3983 conf_tid->queue_id = wl1271_tx_get_queue(queue);
3984 conf_tid->channel_type = CONF_CHANNEL_TYPE_EDCF;
3985 conf_tid->tsid = wl1271_tx_get_queue(queue);
3986 conf_tid->ps_scheme = ps_scheme;
3987 conf_tid->ack_policy = CONF_ACK_POLICY_LEGACY;
3988 conf_tid->apsd_conf[0] = 0;
3989 conf_tid->apsd_conf[1] = 0;
c1b193eb
EP		 3990 goto out;
3991 }
488fc540 3992
c1b193eb
EP		 3993 ret = wl1271_ps_elp_wakeup(wl);
3994 if (ret < 0)
3995 goto out;
488fc540 3996
c1b193eb
EP		 3997 /*
3998 * the txop is confed in units of 32us by the mac80211,
3999 * we need us
4000 */
0603d891 4001 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4002 params->cw_min, params->cw_max,
4003 params->aifs, params->txop << 5);
4004 if (ret < 0)
4005 goto out_sleep;
4006
0603d891 4007 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4008 CONF_CHANNEL_TYPE_EDCF,
4009 wl1271_tx_get_queue(queue),
4010 ps_scheme, CONF_ACK_POLICY_LEGACY,
4011 0, 0);
c82c1dde
KV		 4012
4013out_sleep:
c1b193eb 4014 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 4015
4016out:
4017 mutex_unlock(&wl->mutex);
4018
4019 return ret;
4020}
4021
37a41b4a
EP		 4022static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4023 struct ieee80211_vif *vif)
bbbb538e
JO		 4024{
4025
4026 struct wl1271 *wl = hw->priv;
4027 u64 mactime = ULLONG_MAX;
4028 int ret;
4029
4030 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4031
4032 mutex_lock(&wl->mutex);
4033
f8d9802f
JO		 4034 if (unlikely(wl->state == WL1271_STATE_OFF))
4035 goto out;
4036
a620865e 4037 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 4038 if (ret < 0)
4039 goto out;
4040
4041 ret = wl1271_acx_tsf_info(wl, &mactime);
4042 if (ret < 0)
4043 goto out_sleep;
4044
4045out_sleep:
4046 wl1271_ps_elp_sleep(wl);
4047
4048out:
4049 mutex_unlock(&wl->mutex);
4050 return mactime;
4051}
f5fc0f86 4052
ece550d0
JL		 4053static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4054 struct survey_info *survey)
4055{
4056 struct wl1271 *wl = hw->priv;
4057 struct ieee80211_conf *conf = &hw->conf;
b739a42c 4058
ece550d0
JL		 4059 if (idx != 0)
4060 return -ENOENT;
b739a42c 4061
ece550d0
JL		 4062 survey->channel = conf->channel;
4063 survey->filled = SURVEY_INFO_NOISE_DBM;
4064 survey->noise = wl->noise;
b739a42c 4065
ece550d0
JL		 4066 return 0;
4067}
4068
409622ec 4069static int wl1271_allocate_sta(struct wl1271 *wl,
c7ffb902
EP		 4070 struct wl12xx_vif *wlvif,
4071 struct ieee80211_sta *sta)
f84f7d78
AN		 4072{
4073 struct wl1271_station *wl_sta;
c7ffb902 4074 int ret;
f84f7d78 4075
c7ffb902
EP		 4076
4077 if (wl->active_sta_count >= AP_MAX_STATIONS) {
f84f7d78
AN		 4078 wl1271_warning("could not allocate HLID - too much stations");
4079 return -EBUSY;
4080 }
4081
4082 wl_sta = (struct wl1271_station *)sta->drv_priv;
c7ffb902
EP		 4083 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4084 if (ret < 0) {
4085 wl1271_warning("could not allocate HLID - too many links");
4086 return -EBUSY;
4087 }
4088
4089 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
b622d992 4090 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
da03209e 4091 wl->active_sta_count++;
f84f7d78
AN		 4092 return 0;
4093}
4094
c7ffb902 4095void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
f84f7d78 4096{
c7ffb902 4097 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
f1acea9a
AN		 4098 return;
4099
c7ffb902 4100 clear_bit(hlid, wlvif->ap.sta_hlid_map);
b622d992 4101 memset(wl->links[hlid].addr, 0, ETH_ALEN);
0f9c8250 4102 wl->links[hlid].ba_bitmap = 0;
a8c0ddb5 4103 wl1271_tx_reset_link_queues(wl, hlid);
b622d992
AN		 4104 __clear_bit(hlid, &wl->ap_ps_map);
4105 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
c7ffb902 4106 wl12xx_free_link(wl, wlvif, &hlid);
da03209e 4107 wl->active_sta_count--;
f84f7d78
AN		 4108}
4109
4110static int wl1271_op_sta_add(struct ieee80211_hw *hw,
4111 struct ieee80211_vif *vif,
4112 struct ieee80211_sta *sta)
4113{
4114 struct wl1271 *wl = hw->priv;
536129c8 4115 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
c7ffb902 4116 struct wl1271_station *wl_sta;
f84f7d78
AN		 4117 int ret = 0;
4118 u8 hlid;
4119
4120 mutex_lock(&wl->mutex);
4121
4122 if (unlikely(wl->state == WL1271_STATE_OFF))
4123 goto out;
4124
536129c8 4125 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
f84f7d78
AN		 4126 goto out;
4127
4128 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4129
c7ffb902 4130 ret = wl1271_allocate_sta(wl, wlvif, sta);
f84f7d78
AN		 4131 if (ret < 0)
4132 goto out;
4133
c7ffb902
EP		 4134 wl_sta = (struct wl1271_station *)sta->drv_priv;
4135 hlid = wl_sta->hlid;
4136
a620865e 4137 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78 4138 if (ret < 0)
409622ec 4139 goto out_free_sta;
f84f7d78 4140
1b92f15e 4141 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
f84f7d78
AN		 4142 if (ret < 0)
4143 goto out_sleep;
4144
b67476ef
EP		 4145 ret = wl12xx_cmd_set_peer_state(wl, hlid);
4146 if (ret < 0)
4147 goto out_sleep;
4148
0b932ab9
AN		 4149 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true, hlid);
4150 if (ret < 0)
4151 goto out_sleep;
4152
f84f7d78
AN		 4153out_sleep:
4154 wl1271_ps_elp_sleep(wl);
4155
409622ec
AN		 4156out_free_sta:
4157 if (ret < 0)
c7ffb902 4158 wl1271_free_sta(wl, wlvif, hlid);
409622ec 4159
f84f7d78
AN		 4160out:
4161 mutex_unlock(&wl->mutex);
4162 return ret;
4163}
4164
4165static int wl1271_op_sta_remove(struct ieee80211_hw *hw,
4166 struct ieee80211_vif *vif,
4167 struct ieee80211_sta *sta)
4168{
4169 struct wl1271 *wl = hw->priv;
536129c8 4170 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
f84f7d78
AN		 4171 struct wl1271_station *wl_sta;
4172 int ret = 0, id;
4173
4174 mutex_lock(&wl->mutex);
4175
4176 if (unlikely(wl->state == WL1271_STATE_OFF))
4177 goto out;
4178
536129c8 4179 if (wlvif->bss_type != BSS_TYPE_AP_BSS)
f84f7d78
AN		 4180 goto out;
4181
4182 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4183
4184 wl_sta = (struct wl1271_station *)sta->drv_priv;
c7ffb902
EP		 4185 id = wl_sta->hlid;
4186 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
f84f7d78
AN		 4187 goto out;
4188
a620865e 4189 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 4190 if (ret < 0)
4191 goto out;
4192
c690ec81 4193 ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
f84f7d78
AN		 4194 if (ret < 0)
4195 goto out_sleep;
4196
c7ffb902 4197 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
f84f7d78
AN		 4198
4199out_sleep:
4200 wl1271_ps_elp_sleep(wl);
4201
4202out:
4203 mutex_unlock(&wl->mutex);
4204 return ret;
4205}
4206
4623ec7d
LC		 4207static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4208 struct ieee80211_vif *vif,
4209 enum ieee80211_ampdu_mlme_action action,
4210 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4211 u8 buf_size)
bbba3e68
LS		 4212{
4213 struct wl1271 *wl = hw->priv;
536129c8 4214 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
bbba3e68 4215 int ret;
0f9c8250
AN		 4216 u8 hlid, *ba_bitmap;
4217
4218 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4219 tid);
4220
4221 /* sanity check - the fields in FW are only 8bits wide */
4222 if (WARN_ON(tid > 0xFF))
4223 return -ENOTSUPP;
bbba3e68
LS		 4224
4225 mutex_lock(&wl->mutex);
4226
4227 if (unlikely(wl->state == WL1271_STATE_OFF)) {
4228 ret = -EAGAIN;
4229 goto out;
4230 }
4231
536129c8 4232 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
154da67c 4233 hlid = wlvif->sta.hlid;
d0802abd 4234 ba_bitmap = &wlvif->sta.ba_rx_bitmap;
536129c8 4235 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
0f9c8250
AN		 4236 struct wl1271_station *wl_sta;
4237
4238 wl_sta = (struct wl1271_station *)sta->drv_priv;
4239 hlid = wl_sta->hlid;
4240 ba_bitmap = &wl->links[hlid].ba_bitmap;
4241 } else {
4242 ret = -EINVAL;
4243 goto out;
4244 }
4245
a620865e 4246 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 4247 if (ret < 0)
4248 goto out;
4249
70559a06
SL		 4250 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
4251 tid, action);
4252
bbba3e68
LS		 4253 switch (action) {
4254 case IEEE80211_AMPDU_RX_START:
d0802abd 4255 if (!wlvif->ba_support || !wlvif->ba_allowed) {
bbba3e68 4256 ret = -ENOTSUPP;
0f9c8250
AN		 4257 break;
4258 }
4259
4260 if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
4261 ret = -EBUSY;
4262 wl1271_error("exceeded max RX BA sessions");
4263 break;
4264 }
4265
4266 if (*ba_bitmap & BIT(tid)) {
4267 ret = -EINVAL;
4268 wl1271_error("cannot enable RX BA session on active "
4269 "tid: %d", tid);
4270 break;
4271 }
4272
4273 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
4274 hlid);
4275 if (!ret) {
4276 *ba_bitmap |= BIT(tid);
4277 wl->ba_rx_session_count++;
bbba3e68
LS		 4278 }
4279 break;
4280
4281 case IEEE80211_AMPDU_RX_STOP:
0f9c8250
AN		 4282 if (!(*ba_bitmap & BIT(tid))) {
4283 ret = -EINVAL;
4284 wl1271_error("no active RX BA session on tid: %d",
4285 tid);
4286 break;
4287 }
4288
4289 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
4290 hlid);
4291 if (!ret) {
4292 *ba_bitmap &= ~BIT(tid);
4293 wl->ba_rx_session_count--;
4294 }
bbba3e68
LS		 4295 break;
4296
4297 /*
4298 * The BA initiator session management in FW independently.
4299 * Falling break here on purpose for all TX APDU commands.
4300 */
4301 case IEEE80211_AMPDU_TX_START:
4302 case IEEE80211_AMPDU_TX_STOP:
4303 case IEEE80211_AMPDU_TX_OPERATIONAL:
4304 ret = -EINVAL;
4305 break;
4306
4307 default:
4308 wl1271_error("Incorrect ampdu action id=%x\n", action);
4309 ret = -EINVAL;
4310 }
4311
4312 wl1271_ps_elp_sleep(wl);
4313
4314out:
4315 mutex_unlock(&wl->mutex);
4316
4317 return ret;
4318}
4319
af7fbb28
EP		 4320static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
4321 struct ieee80211_vif *vif,
4322 const struct cfg80211_bitrate_mask *mask)
4323{
83587505 4324 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
af7fbb28 4325 struct wl1271 *wl = hw->priv;
d6fa37c9 4326 int i, ret = 0;
af7fbb28
EP		 4327
4328 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
4329 mask->control[NL80211_BAND_2GHZ].legacy,
4330 mask->control[NL80211_BAND_5GHZ].legacy);
4331
4332 mutex_lock(&wl->mutex);
4333
4334 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
83587505 4335 wlvif->bitrate_masks[i] =
af7fbb28
EP		 4336 wl1271_tx_enabled_rates_get(wl,
4337 mask->control[i].legacy,
4338 i);
d6fa37c9
EP		 4339
4340 if (unlikely(wl->state == WL1271_STATE_OFF))
4341 goto out;
4342
4343 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4344 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
4345
4346 ret = wl1271_ps_elp_wakeup(wl);
4347 if (ret < 0)
4348 goto out;
4349
4350 wl1271_set_band_rate(wl, wlvif);
4351 wlvif->basic_rate =
4352 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4353 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4354
4355 wl1271_ps_elp_sleep(wl);
4356 }
4357out:
af7fbb28
EP		 4358 mutex_unlock(&wl->mutex);
4359
d6fa37c9 4360 return ret;
af7fbb28
EP		 4361}
4362
6d158ff3
SL		 4363static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
4364 struct ieee80211_channel_switch *ch_switch)
4365{
4366 struct wl1271 *wl = hw->priv;
52630c5d 4367 struct wl12xx_vif *wlvif;
6d158ff3
SL		 4368 int ret;
4369
4370 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
4371
4372 mutex_lock(&wl->mutex);
4373
4374 if (unlikely(wl->state == WL1271_STATE_OFF)) {
6e8cd331
EP		 4375 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4376 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4377 ieee80211_chswitch_done(vif, false);
4378 }
4379 goto out;
6d158ff3
SL		 4380 }
4381
4382 ret = wl1271_ps_elp_wakeup(wl);
4383 if (ret < 0)
4384 goto out;
4385
52630c5d
EP		 4386 /* TODO: change mac80211 to pass vif as param */
4387 wl12xx_for_each_wlvif_sta(wl, wlvif) {
4388 ret = wl12xx_cmd_channel_switch(wl, ch_switch);
6d158ff3 4389
52630c5d
EP		 4390 if (!ret)
4391 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
4392 }
6d158ff3
SL		 4393
4394 wl1271_ps_elp_sleep(wl);
4395
4396out:
4397 mutex_unlock(&wl->mutex);
4398}
4399
33437893
AN		 4400static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
4401{
4402 struct wl1271 *wl = hw->priv;
4403 bool ret = false;
4404
4405 mutex_lock(&wl->mutex);
4406
4407 if (unlikely(wl->state == WL1271_STATE_OFF))
4408 goto out;
4409
4410 /* packets are considered pending if in the TX queue or the FW */
f1a46384 4411 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 4412out:
4413 mutex_unlock(&wl->mutex);
4414
4415 return ret;
4416}
4417
f5fc0f86
LC		 4418/* can't be const, mac80211 writes to this */
4419static struct ieee80211_rate wl1271_rates[] = {
4420 { .bitrate = 10,
2b60100b
JO		 4421 .hw_value = CONF_HW_BIT_RATE_1MBPS,
4422 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 4423 { .bitrate = 20,
2b60100b
JO		 4424 .hw_value = CONF_HW_BIT_RATE_2MBPS,
4425 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 4426 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4427 { .bitrate = 55,
2b60100b
JO		 4428 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
4429 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 4430 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4431 { .bitrate = 110,
2b60100b
JO		 4432 .hw_value = CONF_HW_BIT_RATE_11MBPS,
4433 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 4434 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
4435 { .bitrate = 60,
2b60100b
JO		 4436 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4437 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 4438 { .bitrate = 90,
2b60100b
JO		 4439 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4440 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 4441 { .bitrate = 120,
2b60100b
JO		 4442 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4443 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 4444 { .bitrate = 180,
2b60100b
JO		 4445 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4446 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 4447 { .bitrate = 240,
2b60100b
JO		 4448 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4449 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 4450 { .bitrate = 360,
2b60100b
JO		 4451 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4452 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 4453 { .bitrate = 480,
2b60100b
JO		 4454 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4455 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 4456 { .bitrate = 540,
2b60100b
JO		 4457 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4458 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 4459};
4460
fa97f46b 4461/* can't be const, mac80211 writes to this */
f5fc0f86 4462static struct ieee80211_channel wl1271_channels[] = {
a2d0e3f1 4463 { .hw_value = 1, .center_freq = 2412, .max_power = 25 },
fa21c7a9 4464 { .hw_value = 2, .center_freq = 2417, .max_power = 25 },
fa97f46b
JO		 4465 { .hw_value = 3, .center_freq = 2422, .max_power = 25 },
4466 { .hw_value = 4, .center_freq = 2427, .max_power = 25 },
4467 { .hw_value = 5, .center_freq = 2432, .max_power = 25 },
fa21c7a9 4468 { .hw_value = 6, .center_freq = 2437, .max_power = 25 },
fa97f46b
JO		 4469 { .hw_value = 7, .center_freq = 2442, .max_power = 25 },
4470 { .hw_value = 8, .center_freq = 2447, .max_power = 25 },
4471 { .hw_value = 9, .center_freq = 2452, .max_power = 25 },
fa21c7a9 4472 { .hw_value = 10, .center_freq = 2457, .max_power = 25 },
fa97f46b
JO		 4473 { .hw_value = 11, .center_freq = 2462, .max_power = 25 },
4474 { .hw_value = 12, .center_freq = 2467, .max_power = 25 },
4475 { .hw_value = 13, .center_freq = 2472, .max_power = 25 },
6c89b7b2 4476 { .hw_value = 14, .center_freq = 2484, .max_power = 25 },
f5fc0f86
LC		 4477};
4478
f876bb9a 4479/* mapping to indexes for wl1271_rates */
a0ea9493 4480static const u8 wl1271_rate_to_idx_2ghz[] = {
f876bb9a 4481 /* MCS rates are used only with 11n */
18357850
SL		 4482 7, /* CONF_HW_RXTX_RATE_MCS7 */
4483 6, /* CONF_HW_RXTX_RATE_MCS6 */
4484 5, /* CONF_HW_RXTX_RATE_MCS5 */
4485 4, /* CONF_HW_RXTX_RATE_MCS4 */
4486 3, /* CONF_HW_RXTX_RATE_MCS3 */
4487 2, /* CONF_HW_RXTX_RATE_MCS2 */
4488 1, /* CONF_HW_RXTX_RATE_MCS1 */
4489 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4490
4491 11, /* CONF_HW_RXTX_RATE_54 */
4492 10, /* CONF_HW_RXTX_RATE_48 */
4493 9, /* CONF_HW_RXTX_RATE_36 */
4494 8, /* CONF_HW_RXTX_RATE_24 */
4495
4496 /* TI-specific rate */
4497 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4498
4499 7, /* CONF_HW_RXTX_RATE_18 */
4500 6, /* CONF_HW_RXTX_RATE_12 */
4501 3, /* CONF_HW_RXTX_RATE_11 */
4502 5, /* CONF_HW_RXTX_RATE_9 */
4503 4, /* CONF_HW_RXTX_RATE_6 */
4504 2, /* CONF_HW_RXTX_RATE_5_5 */
4505 1, /* CONF_HW_RXTX_RATE_2 */
4506 0 /* CONF_HW_RXTX_RATE_1 */
4507};
4508
e8b03a2b
SL		 4509/* 11n STA capabilities */
4510#define HW_RX_HIGHEST_RATE 72
4511
00d20100 4512#define WL12XX_HT_CAP { \
871d0c3b
SL		 4513 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 | \
4514 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT), \
e8b03a2b
SL		 4515 .ht_supported = true, \
4516 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, \
4517 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
4518 .mcs = { \
4519 .rx_mask = { 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, \
4520 .rx_highest = cpu_to_le16(HW_RX_HIGHEST_RATE), \
4521 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
4522 }, \
4523}
4524
f5fc0f86
LC		 4525/* can't be const, mac80211 writes to this */
4526static struct ieee80211_supported_band wl1271_band_2ghz = {
4527 .channels = wl1271_channels,
4528 .n_channels = ARRAY_SIZE(wl1271_channels),
4529 .bitrates = wl1271_rates,
4530 .n_bitrates = ARRAY_SIZE(wl1271_rates),
00d20100 4531 .ht_cap = WL12XX_HT_CAP,
f5fc0f86
LC		 4532};
4533
1ebec3d7
TP		 4534/* 5 GHz data rates for WL1273 */
4535static struct ieee80211_rate wl1271_rates_5ghz[] = {
4536 { .bitrate = 60,
4537 .hw_value = CONF_HW_BIT_RATE_6MBPS,
4538 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
4539 { .bitrate = 90,
4540 .hw_value = CONF_HW_BIT_RATE_9MBPS,
4541 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
4542 { .bitrate = 120,
4543 .hw_value = CONF_HW_BIT_RATE_12MBPS,
4544 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
4545 { .bitrate = 180,
4546 .hw_value = CONF_HW_BIT_RATE_18MBPS,
4547 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
4548 { .bitrate = 240,
4549 .hw_value = CONF_HW_BIT_RATE_24MBPS,
4550 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
4551 { .bitrate = 360,
4552 .hw_value = CONF_HW_BIT_RATE_36MBPS,
4553 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
4554 { .bitrate = 480,
4555 .hw_value = CONF_HW_BIT_RATE_48MBPS,
4556 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
4557 { .bitrate = 540,
4558 .hw_value = CONF_HW_BIT_RATE_54MBPS,
4559 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
4560};
4561
fa97f46b 4562/* 5 GHz band channels for WL1273 */
1ebec3d7 4563static struct ieee80211_channel wl1271_channels_5ghz[] = {
6cfa5cff
AN		 4564 { .hw_value = 7, .center_freq = 5035, .max_power = 25 },
4565 { .hw_value = 8, .center_freq = 5040, .max_power = 25 },
4566 { .hw_value = 9, .center_freq = 5045, .max_power = 25 },
4567 { .hw_value = 11, .center_freq = 5055, .max_power = 25 },
4568 { .hw_value = 12, .center_freq = 5060, .max_power = 25 },
4569 { .hw_value = 16, .center_freq = 5080, .max_power = 25 },
4570 { .hw_value = 34, .center_freq = 5170, .max_power = 25 },
4571 { .hw_value = 36, .center_freq = 5180, .max_power = 25 },
4572 { .hw_value = 38, .center_freq = 5190, .max_power = 25 },
4573 { .hw_value = 40, .center_freq = 5200, .max_power = 25 },
4574 { .hw_value = 42, .center_freq = 5210, .max_power = 25 },
4575 { .hw_value = 44, .center_freq = 5220, .max_power = 25 },
4576 { .hw_value = 46, .center_freq = 5230, .max_power = 25 },
4577 { .hw_value = 48, .center_freq = 5240, .max_power = 25 },
4578 { .hw_value = 52, .center_freq = 5260, .max_power = 25 },
4579 { .hw_value = 56, .center_freq = 5280, .max_power = 25 },
4580 { .hw_value = 60, .center_freq = 5300, .max_power = 25 },
4581 { .hw_value = 64, .center_freq = 5320, .max_power = 25 },
4582 { .hw_value = 100, .center_freq = 5500, .max_power = 25 },
4583 { .hw_value = 104, .center_freq = 5520, .max_power = 25 },
4584 { .hw_value = 108, .center_freq = 5540, .max_power = 25 },
4585 { .hw_value = 112, .center_freq = 5560, .max_power = 25 },
4586 { .hw_value = 116, .center_freq = 5580, .max_power = 25 },
4587 { .hw_value = 120, .center_freq = 5600, .max_power = 25 },
4588 { .hw_value = 124, .center_freq = 5620, .max_power = 25 },
4589 { .hw_value = 128, .center_freq = 5640, .max_power = 25 },
4590 { .hw_value = 132, .center_freq = 5660, .max_power = 25 },
4591 { .hw_value = 136, .center_freq = 5680, .max_power = 25 },
4592 { .hw_value = 140, .center_freq = 5700, .max_power = 25 },
4593 { .hw_value = 149, .center_freq = 5745, .max_power = 25 },
4594 { .hw_value = 153, .center_freq = 5765, .max_power = 25 },
4595 { .hw_value = 157, .center_freq = 5785, .max_power = 25 },
4596 { .hw_value = 161, .center_freq = 5805, .max_power = 25 },
4597 { .hw_value = 165, .center_freq = 5825, .max_power = 25 },
1ebec3d7
TP		 4598};
4599
f876bb9a 4600/* mapping to indexes for wl1271_rates_5ghz */
a0ea9493 4601static const u8 wl1271_rate_to_idx_5ghz[] = {
f876bb9a 4602 /* MCS rates are used only with 11n */
18357850
SL		 4603 7, /* CONF_HW_RXTX_RATE_MCS7 */
4604 6, /* CONF_HW_RXTX_RATE_MCS6 */
4605 5, /* CONF_HW_RXTX_RATE_MCS5 */
4606 4, /* CONF_HW_RXTX_RATE_MCS4 */
4607 3, /* CONF_HW_RXTX_RATE_MCS3 */
4608 2, /* CONF_HW_RXTX_RATE_MCS2 */
4609 1, /* CONF_HW_RXTX_RATE_MCS1 */
4610 0, /* CONF_HW_RXTX_RATE_MCS0 */
f876bb9a
JO		 4611
4612 7, /* CONF_HW_RXTX_RATE_54 */
4613 6, /* CONF_HW_RXTX_RATE_48 */
4614 5, /* CONF_HW_RXTX_RATE_36 */
4615 4, /* CONF_HW_RXTX_RATE_24 */
4616
4617 /* TI-specific rate */
4618 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_22 */
4619
4620 3, /* CONF_HW_RXTX_RATE_18 */
4621 2, /* CONF_HW_RXTX_RATE_12 */
4622 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_11 */
4623 1, /* CONF_HW_RXTX_RATE_9 */
4624 0, /* CONF_HW_RXTX_RATE_6 */
4625 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_5_5 */
4626 CONF_HW_RXTX_RATE_UNSUPPORTED, /* CONF_HW_RXTX_RATE_2 */
4627 CONF_HW_RXTX_RATE_UNSUPPORTED /* CONF_HW_RXTX_RATE_1 */
4628};
1ebec3d7
TP		 4629
4630static struct ieee80211_supported_band wl1271_band_5ghz = {
4631 .channels = wl1271_channels_5ghz,
4632 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
4633 .bitrates = wl1271_rates_5ghz,
4634 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
00d20100 4635 .ht_cap = WL12XX_HT_CAP,
1ebec3d7
TP		 4636};
4637
a0ea9493 4638static const u8 *wl1271_band_rate_to_idx[] = {
f876bb9a
JO		 4639 [IEEE80211_BAND_2GHZ] = wl1271_rate_to_idx_2ghz,
4640 [IEEE80211_BAND_5GHZ] = wl1271_rate_to_idx_5ghz
4641};
4642
f5fc0f86
LC		 4643static const struct ieee80211_ops wl1271_ops = {
4644 .start = wl1271_op_start,
4645 .stop = wl1271_op_stop,
4646 .add_interface = wl1271_op_add_interface,
4647 .remove_interface = wl1271_op_remove_interface,
f634a4e7 4648#ifdef CONFIG_PM
402e4861
EP		 4649 .suspend = wl1271_op_suspend,
4650 .resume = wl1271_op_resume,
f634a4e7 4651#endif
f5fc0f86 4652 .config = wl1271_op_config,
c87dec9f 4653 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 4654 .configure_filter = wl1271_op_configure_filter,
4655 .tx = wl1271_op_tx,
4656 .set_key = wl1271_op_set_key,
4657 .hw_scan = wl1271_op_hw_scan,
73ecce31 4658 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 4659 .sched_scan_start = wl1271_op_sched_scan_start,
4660 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 4661 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 4662 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 4663 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 4664 .conf_tx = wl1271_op_conf_tx,
bbbb538e 4665 .get_tsf = wl1271_op_get_tsf,
ece550d0 4666 .get_survey = wl1271_op_get_survey,
f84f7d78
AN		 4667 .sta_add = wl1271_op_sta_add,
4668 .sta_remove = wl1271_op_sta_remove,
bbba3e68 4669 .ampdu_action = wl1271_op_ampdu_action,
33437893 4670 .tx_frames_pending = wl1271_tx_frames_pending,
af7fbb28 4671 .set_bitrate_mask = wl12xx_set_bitrate_mask,
6d158ff3 4672 .channel_switch = wl12xx_op_channel_switch,
c8c90873 4673 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 4674};
4675
f876bb9a 4676
6a2de93b 4677u8 wl1271_rate_to_idx(int rate, enum ieee80211_band band)
f876bb9a
JO		 4678{
4679 u8 idx;
4680
6a2de93b 4681 BUG_ON(band >= sizeof(wl1271_band_rate_to_idx)/sizeof(u8 *));
f876bb9a
JO		 4682
4683 if (unlikely(rate >= CONF_HW_RXTX_RATE_MAX)) {
4684 wl1271_error("Illegal RX rate from HW: %d", rate);
4685 return 0;
4686 }
4687
6a2de93b 4688 idx = wl1271_band_rate_to_idx[band][rate];
f876bb9a
JO		 4689 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
4690 wl1271_error("Unsupported RX rate from HW: %d", rate);
4691 return 0;
4692 }
4693
4694 return idx;
4695}
4696
7fc3a864
JO		 4697static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
4698 struct device_attribute *attr,
4699 char *buf)
4700{
4701 struct wl1271 *wl = dev_get_drvdata(dev);
4702 ssize_t len;
4703
2f63b011 4704 len = PAGE_SIZE;
7fc3a864
JO		 4705
4706 mutex_lock(&wl->mutex);
4707 len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
4708 wl->sg_enabled);
4709 mutex_unlock(&wl->mutex);
4710
4711 return len;
4712
4713}
4714
4715static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
4716 struct device_attribute *attr,
4717 const char *buf, size_t count)
4718{
4719 struct wl1271 *wl = dev_get_drvdata(dev);
4720 unsigned long res;
4721 int ret;
4722
6277ed65 4723 ret = kstrtoul(buf, 10, &res);
7fc3a864
JO		 4724 if (ret < 0) {
4725 wl1271_warning("incorrect value written to bt_coex_mode");
4726 return count;
4727 }
4728
4729 mutex_lock(&wl->mutex);
4730
4731 res = !!res;
4732
4733 if (res == wl->sg_enabled)
4734 goto out;
4735
4736 wl->sg_enabled = res;
4737
4738 if (wl->state == WL1271_STATE_OFF)
4739 goto out;
4740
a620865e 4741 ret = wl1271_ps_elp_wakeup(wl);
7fc3a864
JO		 4742 if (ret < 0)
4743 goto out;
4744
4745 wl1271_acx_sg_enable(wl, wl->sg_enabled);
4746 wl1271_ps_elp_sleep(wl);
4747
4748 out:
4749 mutex_unlock(&wl->mutex);
4750 return count;
4751}
4752
4753static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
4754 wl1271_sysfs_show_bt_coex_state,
4755 wl1271_sysfs_store_bt_coex_state);
4756
d717fd61
JO		 4757static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
4758 struct device_attribute *attr,
4759 char *buf)
4760{
4761 struct wl1271 *wl = dev_get_drvdata(dev);
4762 ssize_t len;
4763
2f63b011 4764 len = PAGE_SIZE;
d717fd61
JO		 4765
4766 mutex_lock(&wl->mutex);
4767 if (wl->hw_pg_ver >= 0)
4768 len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
4769 else
4770 len = snprintf(buf, len, "n/a\n");
4771 mutex_unlock(&wl->mutex);
4772
4773 return len;
4774}
4775
6f07b72a 4776static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
d717fd61
JO		 4777 wl1271_sysfs_show_hw_pg_ver, NULL);
4778
95dac04f
IY		 4779static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
4780 struct bin_attribute *bin_attr,
4781 char *buffer, loff_t pos, size_t count)
4782{
4783 struct device *dev = container_of(kobj, struct device, kobj);
4784 struct wl1271 *wl = dev_get_drvdata(dev);
4785 ssize_t len;
4786 int ret;
4787
4788 ret = mutex_lock_interruptible(&wl->mutex);
4789 if (ret < 0)
4790 return -ERESTARTSYS;
4791
4792 /* Let only one thread read the log at a time, blocking others */
4793 while (wl->fwlog_size == 0) {
4794 DEFINE_WAIT(wait);
4795
4796 prepare_to_wait_exclusive(&wl->fwlog_waitq,
4797 &wait,
4798 TASK_INTERRUPTIBLE);
4799
4800 if (wl->fwlog_size != 0) {
4801 finish_wait(&wl->fwlog_waitq, &wait);
4802 break;
4803 }
4804
4805 mutex_unlock(&wl->mutex);
4806
4807 schedule();
4808 finish_wait(&wl->fwlog_waitq, &wait);
4809
4810 if (signal_pending(current))
4811 return -ERESTARTSYS;
4812
4813 ret = mutex_lock_interruptible(&wl->mutex);
4814 if (ret < 0)
4815 return -ERESTARTSYS;
4816 }
4817
4818 /* Check if the fwlog is still valid */
4819 if (wl->fwlog_size < 0) {
4820 mutex_unlock(&wl->mutex);
4821 return 0;
4822 }
4823
4824 /* Seeking is not supported - old logs are not kept. Disregard pos. */
4825 len = min(count, (size_t)wl->fwlog_size);
4826 wl->fwlog_size -= len;
4827 memcpy(buffer, wl->fwlog, len);
4828
4829 /* Make room for new messages */
4830 memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);
4831
4832 mutex_unlock(&wl->mutex);
4833
4834 return len;
4835}
4836
4837static struct bin_attribute fwlog_attr = {
4838 .attr = {.name = "fwlog", .mode = S_IRUSR},
4839 .read = wl1271_sysfs_read_fwlog,
4840};
4841
4b32a2c9 4842static int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 4843{
4844 int ret;
4845
4846 if (wl->mac80211_registered)
4847 return 0;
4848
31d26ec6
AN		 4849 ret = wl1271_fetch_nvs(wl);
4850 if (ret == 0) {
bc765bf3
SL		 4851 /* NOTE: The wl->nvs->nvs element must be first, in
4852 * order to simplify the casting, we assume it is at
4853 * the beginning of the wl->nvs structure.
4854 */
4855 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6
AN		 4856
4857 wl->mac_addr[0] = nvs_ptr[11];
4858 wl->mac_addr[1] = nvs_ptr[10];
4859 wl->mac_addr[2] = nvs_ptr[6];
4860 wl->mac_addr[3] = nvs_ptr[5];
4861 wl->mac_addr[4] = nvs_ptr[4];
4862 wl->mac_addr[5] = nvs_ptr[3];
4863 }
4864
f5fc0f86
LC		 4865 SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr);
4866
4867 ret = ieee80211_register_hw(wl->hw);
4868 if (ret < 0) {
4869 wl1271_error("unable to register mac80211 hw: %d", ret);
4870 return ret;
4871 }
4872
4873 wl->mac80211_registered = true;
4874
d60080ae
EP		 4875 wl1271_debugfs_init(wl);
4876
c2c192ac
JO		 4877 register_netdevice_notifier(&wl1271_dev_notifier);
4878
f5fc0f86
LC		 4879 wl1271_notice("loaded");
4880
4881 return 0;
4882}
4883
4b32a2c9 4884static void wl1271_unregister_hw(struct wl1271 *wl)
3b56dd6a 4885{
4ae3fa87
JO		 4886 if (wl->state == WL1271_STATE_PLT)
4887 __wl1271_plt_stop(wl);
4888
c2c192ac 4889 unregister_netdevice_notifier(&wl1271_dev_notifier);
3b56dd6a
TP		 4890 ieee80211_unregister_hw(wl->hw);
4891 wl->mac80211_registered = false;
4892
4893}
3b56dd6a 4894
4b32a2c9 4895static int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 4896{
7a55724e
JO		 4897 static const u32 cipher_suites[] = {
4898 WLAN_CIPHER_SUITE_WEP40,
4899 WLAN_CIPHER_SUITE_WEP104,
4900 WLAN_CIPHER_SUITE_TKIP,
4901 WLAN_CIPHER_SUITE_CCMP,
4902 WL1271_CIPHER_SUITE_GEM,
4903 };
4904
1e2b7976
JO		 4905 /* The tx descriptor buffer and the TKIP space. */
4906 wl->hw->extra_tx_headroom = WL1271_TKIP_IV_SPACE +
4907 sizeof(struct wl1271_tx_hw_descr);
f5fc0f86
LC		 4908
4909 /* unit us */
4910 /* FIXME: find a proper value */
4911 wl->hw->channel_change_time = 10000;
50c500ad 4912 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 4913
4914 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
03442a33 4915 IEEE80211_HW_BEACON_FILTER |
0a34332f 4916 IEEE80211_HW_SUPPORTS_PS |
4695dc91 4917 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 4918 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 4919 IEEE80211_HW_CONNECTION_MONITOR |
62c0740c 4920 IEEE80211_HW_SUPPORTS_CQM_RSSI |
25eaea30 4921 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 4922 IEEE80211_HW_SPECTRUM_MGMT |
93f8c8e0
AN		 4923 IEEE80211_HW_AP_LINK_PS |
4924 IEEE80211_HW_AMPDU_AGGREGATION |
4925 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
f5fc0f86 4926
7a55724e
JO		 4927 wl->hw->wiphy->cipher_suites = cipher_suites;
4928 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
4929
e0d8bbf0 4930 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
045c745f
EP		 4931 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
4932 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
f5fc0f86 4933 wl->hw->wiphy->max_scan_ssids = 1;
221737d2
LC		 4934 wl->hw->wiphy->max_sched_scan_ssids = 16;
4935 wl->hw->wiphy->max_match_sets = 16;
ea559b46
GE		 4936 /*
4937 * Maximum length of elements in scanning probe request templates
4938 * should be the maximum length possible for a template, without
4939 * the IEEE80211 header of the template
4940 */
154037d1 4941 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
ea559b46 4942 sizeof(struct ieee80211_header);
a8aaaf53 4943
c9e79a47
LC		 4944 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_DFLT_SIZE -
4945 sizeof(struct ieee80211_header);
4946
1ec23f7f
EP		 4947 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4948
4a31c11c
LC		 4949 /* make sure all our channels fit in the scanned_ch bitmask */
4950 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
4951 ARRAY_SIZE(wl1271_channels_5ghz) >
4952 WL1271_MAX_CHANNELS);
a8aaaf53
LC		 4953 /*
4954 * We keep local copies of the band structs because we need to
4955 * modify them on a per-device basis.
4956 */
4957 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
4958 sizeof(wl1271_band_2ghz));
4959 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
4960 sizeof(wl1271_band_5ghz));
4961
4962 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
4963 &wl->bands[IEEE80211_BAND_2GHZ];
4964 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
4965 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 4966
12bd8949 4967 wl->hw->queues = 4;
31627dc5 4968 wl->hw->max_rates = 1;
12bd8949 4969
b7417d93
JO		 4970 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
4971
a390e85c 4972 SET_IEEE80211_DEV(wl->hw, wl->dev);
f5fc0f86 4973
f84f7d78 4974 wl->hw->sta_data_size = sizeof(struct wl1271_station);
87fbcb0f 4975 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
f84f7d78 4976
4c9cfa78
LC		 4977 wl->hw->max_rx_aggregation_subframes = 8;
4978
f5fc0f86
LC		 4979 return 0;
4980}
4981
f5fc0f86 4982#define WL1271_DEFAULT_CHANNEL 0
c332a4b8 4983
4b32a2c9 4984static struct ieee80211_hw *wl1271_alloc_hw(void)
f5fc0f86 4985{
f5fc0f86
LC		 4986 struct ieee80211_hw *hw;
4987 struct wl1271 *wl;
a8c0ddb5 4988 int i, j, ret;
1f37cbc9 4989 unsigned int order;
f5fc0f86 4990
c7ffb902 4991 BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
f80c2d12 4992
f5fc0f86
LC		 4993 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
4994 if (!hw) {
4995 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 4996 ret = -ENOMEM;
3b56dd6a
TP		 4997 goto err_hw_alloc;
4998 }
4999
f5fc0f86
LC		 5000 wl = hw->priv;
5001 memset(wl, 0, sizeof(*wl));
5002
01c09162 5003 INIT_LIST_HEAD(&wl->list);
87627214 5004 INIT_LIST_HEAD(&wl->wlvif_list);
01c09162 5005
f5fc0f86 5006 wl->hw = hw;
f5fc0f86 5007
a8c0ddb5 5008 for (i = 0; i < NUM_TX_QUEUES; i++)
c7ffb902 5009 for (j = 0; j < WL12XX_MAX_LINKS; j++)
a8c0ddb5
AN		 5010 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5011
a620865e
IY		 5012 skb_queue_head_init(&wl->deferred_rx_queue);
5013 skb_queue_head_init(&wl->deferred_tx_queue);
5014
37b70a81 5015 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
a620865e 5016 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 5017 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5018 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5019 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
77ddaa10 5020
92ef8960
EP		 5021 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5022 if (!wl->freezable_wq) {
5023 ret = -ENOMEM;
5024 goto err_hw;
5025 }
5026
f5fc0f86 5027 wl->channel = WL1271_DEFAULT_CHANNEL;
f5fc0f86 5028 wl->rx_counter = 0;
f5fc0f86 5029 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
8a5a37a6 5030 wl->band = IEEE80211_BAND_2GHZ;
b771eee5 5031 wl->vif = NULL;
830fb67b 5032 wl->flags = 0;
7fc3a864 5033 wl->sg_enabled = true;
d717fd61 5034 wl->hw_pg_ver = -1;
b622d992
AN		 5035 wl->ap_ps_map = 0;
5036 wl->ap_fw_ps_map = 0;
606ea9fa 5037 wl->quirks = 0;
341b7cde 5038 wl->platform_quirks = 0;
33c2c06c 5039 wl->sched_scanning = false;
e9eb8cbe 5040 wl->tx_spare_blocks = TX_HW_BLOCK_SPARE_DEFAULT;
f4df1bd5 5041 wl->system_hlid = WL12XX_SYSTEM_HLID;
da03209e 5042 wl->active_sta_count = 0;
95dac04f
IY		 5043 wl->fwlog_size = 0;
5044 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 5045
f4df1bd5
EP		 5046 /* The system link is always allocated */
5047 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5048
25eeb9e3 5049 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
be7078c2 5050 for (i = 0; i < ACX_TX_DESCRIPTORS; i++)
f5fc0f86
LC		 5051 wl->tx_frames[i] = NULL;
5052
5053 spin_lock_init(&wl->wl_lock);
5054
f5fc0f86
LC		 5055 wl->state = WL1271_STATE_OFF;
5056 mutex_init(&wl->mutex);
5057
c332a4b8
TP		 5058 /* Apply default driver configuration. */
5059 wl1271_conf_init(wl);
5060
1f37cbc9
IY		 5061 order = get_order(WL1271_AGGR_BUFFER_SIZE);
5062 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5063 if (!wl->aggr_buf) {
5064 ret = -ENOMEM;
92ef8960 5065 goto err_wq;
1f37cbc9
IY		 5066 }
5067
990f5de7
IY		 5068 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5069 if (!wl->dummy_packet) {
5070 ret = -ENOMEM;
5071 goto err_aggr;
5072 }
5073
95dac04f
IY		 5074 /* Allocate one page for the FW log */
5075 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5076 if (!wl->fwlog) {
5077 ret = -ENOMEM;
5078 goto err_dummy_packet;
5079 }
5080
c332a4b8 5081 return hw;
a1dd8187 5082
990f5de7
IY		 5083err_dummy_packet:
5084 dev_kfree_skb(wl->dummy_packet);
5085
1f37cbc9
IY		 5086err_aggr:
5087 free_pages((unsigned long)wl->aggr_buf, order);
5088
92ef8960
EP		 5089err_wq:
5090 destroy_workqueue(wl->freezable_wq);
5091
a1dd8187 5092err_hw:
3b56dd6a 5093 wl1271_debugfs_exit(wl);
3b56dd6a
TP		 5094 ieee80211_free_hw(hw);
5095
5096err_hw_alloc:
a1dd8187 5097
a1dd8187 5098 return ERR_PTR(ret);
c332a4b8
TP		 5099}
5100
4b32a2c9 5101static int wl1271_free_hw(struct wl1271 *wl)
c332a4b8 5102{
95dac04f
IY		 5103 /* Unblock any fwlog readers */
5104 mutex_lock(&wl->mutex);
5105 wl->fwlog_size = -1;
5106 wake_up_interruptible_all(&wl->fwlog_waitq);
5107 mutex_unlock(&wl->mutex);
5108
f79f890c 5109 device_remove_bin_file(wl->dev, &fwlog_attr);
6f07b72a 5110
f79f890c 5111 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
6f07b72a 5112
f79f890c 5113 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
95dac04f 5114 free_page((unsigned long)wl->fwlog);
990f5de7 5115 dev_kfree_skb(wl->dummy_packet);
1f37cbc9
IY		 5116 free_pages((unsigned long)wl->aggr_buf,
5117 get_order(WL1271_AGGR_BUFFER_SIZE));
c332a4b8
TP		 5118
5119 wl1271_debugfs_exit(wl);
5120
c332a4b8
TP		 5121 vfree(wl->fw);
5122 wl->fw = NULL;
5123 kfree(wl->nvs);
5124 wl->nvs = NULL;
5125
5126 kfree(wl->fw_status);
5127 kfree(wl->tx_res_if);
92ef8960 5128 destroy_workqueue(wl->freezable_wq);
c332a4b8
TP		 5129
5130 ieee80211_free_hw(wl->hw);
5131
5132 return 0;
5133}
50b3eb4b 5134
a390e85c
FB		 5135static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
5136{
5137 struct wl1271 *wl = cookie;
5138 unsigned long flags;
5139
5140 wl1271_debug(DEBUG_IRQ, "IRQ");
5141
5142 /* complete the ELP completion */
5143 spin_lock_irqsave(&wl->wl_lock, flags);
5144 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
5145 if (wl->elp_compl) {
5146 complete(wl->elp_compl);
5147 wl->elp_compl = NULL;
5148 }
5149
5150 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
5151 /* don't enqueue a work right now. mark it as pending */
5152 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
5153 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
5154 disable_irq_nosync(wl->irq);
5155 pm_wakeup_event(wl->dev, 0);
5156 spin_unlock_irqrestore(&wl->wl_lock, flags);
5157 return IRQ_HANDLED;
5158 }
5159 spin_unlock_irqrestore(&wl->wl_lock, flags);
5160
5161 return IRQ_WAKE_THREAD;
5162}
5163
ce2a217c
FB		 5164static int __devinit wl12xx_probe(struct platform_device *pdev)
5165{
a390e85c
FB		 5166 struct wl12xx_platform_data *pdata = pdev->dev.platform_data;
5167 struct ieee80211_hw *hw;
5168 struct wl1271 *wl;
5169 unsigned long irqflags;
5170 int ret = -ENODEV;
5171
5172 hw = wl1271_alloc_hw();
5173 if (IS_ERR(hw)) {
5174 wl1271_error("can't allocate hw");
5175 ret = PTR_ERR(hw);
5176 goto out;
5177 }
5178
5179 wl = hw->priv;
5180 wl->irq = platform_get_irq(pdev, 0);
5181 wl->ref_clock = pdata->board_ref_clock;
5182 wl->tcxo_clock = pdata->board_tcxo_clock;
5183 wl->platform_quirks = pdata->platform_quirks;
5184 wl->set_power = pdata->set_power;
5185 wl->dev = &pdev->dev;
5186 wl->if_ops = pdata->ops;
5187
5188 platform_set_drvdata(pdev, wl);
5189
5190 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
5191 irqflags = IRQF_TRIGGER_RISING;
5192 else
5193 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
5194
5195 ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,
5196 irqflags,
5197 pdev->name, wl);
5198 if (ret < 0) {
5199 wl1271_error("request_irq() failed: %d", ret);
5200 goto out_free_hw;
5201 }
5202
5203 ret = enable_irq_wake(wl->irq);
5204 if (!ret) {
5205 wl->irq_wake_enabled = true;
5206 device_init_wakeup(wl->dev, 1);
5207 if (pdata->pwr_in_suspend)
5208 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
5209
5210 }
5211 disable_irq(wl->irq);
5212
5213 ret = wl1271_init_ieee80211(wl);
5214 if (ret)
5215 goto out_irq;
5216
5217 ret = wl1271_register_hw(wl);
5218 if (ret)
5219 goto out_irq;
5220
f79f890c
FB		 5221 /* Create sysfs file to control bt coex state */
5222 ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
5223 if (ret < 0) {
5224 wl1271_error("failed to create sysfs file bt_coex_state");
5225 goto out_irq;
5226 }
5227
5228 /* Create sysfs file to get HW PG version */
5229 ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
5230 if (ret < 0) {
5231 wl1271_error("failed to create sysfs file hw_pg_ver");
5232 goto out_bt_coex_state;
5233 }
5234
5235 /* Create sysfs file for the FW log */
5236 ret = device_create_bin_file(wl->dev, &fwlog_attr);
5237 if (ret < 0) {
5238 wl1271_error("failed to create sysfs file fwlog");
5239 goto out_hw_pg_ver;
5240 }
5241
ce2a217c 5242 return 0;
a390e85c 5243
f79f890c
FB		 5244out_hw_pg_ver:
5245 device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5246
5247out_bt_coex_state:
5248 device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5249
a390e85c
FB		 5250out_irq:
5251 free_irq(wl->irq, wl);
5252
5253out_free_hw:
5254 wl1271_free_hw(wl);
5255
5256out:
5257 return ret;
ce2a217c
FB		 5258}
5259
5260static int __devexit wl12xx_remove(struct platform_device *pdev)
5261{
a390e85c
FB		 5262 struct wl1271 *wl = platform_get_drvdata(pdev);
5263
5264 if (wl->irq_wake_enabled) {
5265 device_init_wakeup(wl->dev, 0);
5266 disable_irq_wake(wl->irq);
5267 }
5268 wl1271_unregister_hw(wl);
5269 free_irq(wl->irq, wl);
5270 wl1271_free_hw(wl);
5271
ce2a217c
FB		 5272 return 0;
5273}
5274
5275static const struct platform_device_id wl12xx_id_table[] __devinitconst = {
ccb62000 5276 { "wl12xx", 0 },
ce2a217c
FB		 5277 { } /* Terminating Entry */
5278};
5279MODULE_DEVICE_TABLE(platform, wl12xx_id_table);
5280
5281static struct platform_driver wl12xx_driver = {
5282 .probe = wl12xx_probe,
5283 .remove = __devexit_p(wl12xx_remove),
5284 .id_table = wl12xx_id_table,
5285 .driver = {
ccb62000 5286 .name = "wl12xx_driver",
ce2a217c
FB		 5287 .owner = THIS_MODULE,
5288 }
5289};
5290
5291static int __init wl12xx_init(void)
5292{
5293 return platform_driver_register(&wl12xx_driver);
5294}
5295module_init(wl12xx_init);
5296
5297static void __exit wl12xx_exit(void)
5298{
5299 platform_driver_unregister(&wl12xx_driver);
5300}
5301module_exit(wl12xx_exit);
5302
491bbd6b 5303u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 5304EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 5305module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 5306MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
5307
95dac04f
IY		 5308module_param_named(fwlog, fwlog_param, charp, 0);
5309MODULE_PARM_DESC(keymap,
5310 "FW logger options: continuous, ondemand, dbgpins or disable");
5311
2a5bff09
EP		 5312module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
5313MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
5314
50b3eb4b 5315MODULE_LICENSE("GPL");
b1a48cab 5316MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 5317MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
kernel source for telekom puls (alcatel/mediatek)