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