projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wlcore: enable beacon filtering only after receiving a beacon
[deliverable/linux.git] / drivers / net / wireless / ti / wlcore / main.c
CommitLineData
f1d63a59 1
f5fc0f86 2/*
8f6ac537 3 * This file is part of wlcore
f5fc0f86 4 *
8bf29b0e 5 * Copyright (C) 2008-2010 Nokia Corporation
8f6ac537 6 * Copyright (C) 2011-2013 Texas Instruments Inc.
f5fc0f86
LC		 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 25#include <linux/firmware.h>
f5fc0f86 26#include <linux/etherdevice.h>
1fba4974 27#include <linux/vmalloc.h>
341b7cde 28#include <linux/wl12xx.h>
a390e85c 29#include <linux/interrupt.h>
f5fc0f86 30
c31be25a 31#include "wlcore.h"
0f4e3122 32#include "debug.h"
f5fc0f86 33#include "wl12xx_80211.h"
00d20100 34#include "io.h"
00d20100 35#include "tx.h"
00d20100
SL		 36#include "ps.h"
37#include "init.h"
38#include "debugfs.h"
00d20100
SL		 39#include "testmode.h"
40#include "scan.h"
53d67a50 41#include "hw_ops.h"
33cab57a 42#include "sysfs.h"
f5fc0f86 43
9ccd9217
JO		 44#define WL1271_BOOT_RETRIES 3
45
95dac04f 46static char *fwlog_param;
93ac8488 47static int fwlog_mem_blocks = -1;
7230341f
YS		 48static int bug_on_recovery = -1;
49static int no_recovery = -1;
95dac04f 50
7dece1c8 51static void __wl1271_op_remove_interface(struct wl1271 *wl,
536129c8 52 struct ieee80211_vif *vif,
7dece1c8 53 bool reset_tx_queues);
c24ec83b 54static void wlcore_op_stop_locked(struct wl1271 *wl);
170d0e67 55static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
52b0e7a6 56
8f6ac537 57static int wl12xx_set_authorized(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ef4b29e9
EP		 58{
59 int ret;
0603d891 60
9fd6f21b
EP		 61 if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
62 return -EINVAL;
63
64 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
ef4b29e9
EP		 65 return 0;
66
8181aecc 67 if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
ef4b29e9
EP		 68 return 0;
69
d50529c0 70 ret = wl12xx_cmd_set_peer_state(wl, wlvif, wlvif->sta.hlid);
ef4b29e9
EP		 71 if (ret < 0)
72 return ret;
73
74 wl1271_info("Association completed.");
75 return 0;
76}
c2c192ac 77
0c0280bd
LR		 78static void wl1271_reg_notify(struct wiphy *wiphy,
79 struct regulatory_request *request)
573c67cf 80{
b7417d93
JO		 81 struct ieee80211_supported_band *band;
82 struct ieee80211_channel *ch;
83 int i;
6b70e7eb
VG		 84 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
85 struct wl1271 *wl = hw->priv;
b7417d93
JO		 86
87 band = wiphy->bands[IEEE80211_BAND_5GHZ];
88 for (i = 0; i < band->n_channels; i++) {
89 ch = &band->channels[i];
90 if (ch->flags & IEEE80211_CHAN_DISABLED)
91 continue;
92
93 if (ch->flags & IEEE80211_CHAN_RADAR)
8fe02e16 94 ch->flags |= IEEE80211_CHAN_NO_IR;
b7417d93
JO		 95
96 }
97
75592be5 98 wlcore_regdomain_config(wl);
b7417d93
JO		 99}
100
9eb599e9
EP		 101static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
102 bool enable)
77ddaa10
EP		 103{
104 int ret = 0;
105
106 /* we should hold wl->mutex */
9eb599e9 107 ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
77ddaa10
EP		 108 if (ret < 0)
109 goto out;
110
111 if (enable)
0744bdb6 112 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
77ddaa10 113 else
0744bdb6 114 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
77ddaa10
EP		 115out:
116 return ret;
117}
118
119/*
120 * this function is being called when the rx_streaming interval
121 * has beed changed or rx_streaming should be disabled
122 */
9eb599e9 123int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
77ddaa10
EP		 124{
125 int ret = 0;
126 int period = wl->conf.rx_streaming.interval;
127
128 /* don't reconfigure if rx_streaming is disabled */
0744bdb6 129 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
77ddaa10
EP		 130 goto out;
131
132 /* reconfigure/disable according to new streaming_period */
133 if (period &&
ba8447f6 134 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
77ddaa10
EP		 135 (wl->conf.rx_streaming.always ||
136 test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
9eb599e9 137 ret = wl1271_set_rx_streaming(wl, wlvif, true);
77ddaa10 138 else {
9eb599e9 139 ret = wl1271_set_rx_streaming(wl, wlvif, false);
77ddaa10 140 /* don't cancel_work_sync since we might deadlock */
9eb599e9 141 del_timer_sync(&wlvif->rx_streaming_timer);
77ddaa10
EP		 142 }
143out:
144 return ret;
145}
146
147static void wl1271_rx_streaming_enable_work(struct work_struct *work)
148{
149 int ret;
9eb599e9
EP		 150 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
151 rx_streaming_enable_work);
152 struct wl1271 *wl = wlvif->wl;
77ddaa10
EP		 153
154 mutex_lock(&wl->mutex);
155
0744bdb6 156 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
ba8447f6 157 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
77ddaa10
EP		 158 (!wl->conf.rx_streaming.always &&
159 !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
160 goto out;
161
162 if (!wl->conf.rx_streaming.interval)
163 goto out;
164
165 ret = wl1271_ps_elp_wakeup(wl);
166 if (ret < 0)
167 goto out;
168
9eb599e9 169 ret = wl1271_set_rx_streaming(wl, wlvif, true);
77ddaa10
EP		 170 if (ret < 0)
171 goto out_sleep;
172
173 /* stop it after some time of inactivity */
9eb599e9 174 mod_timer(&wlvif->rx_streaming_timer,
77ddaa10
EP		 175 jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
176
177out_sleep:
178 wl1271_ps_elp_sleep(wl);
179out:
180 mutex_unlock(&wl->mutex);
181}
182
183static void wl1271_rx_streaming_disable_work(struct work_struct *work)
184{
185 int ret;
9eb599e9
EP		 186 struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
187 rx_streaming_disable_work);
188 struct wl1271 *wl = wlvif->wl;
77ddaa10
EP		 189
190 mutex_lock(&wl->mutex);
191
0744bdb6 192 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
77ddaa10
EP		 193 goto out;
194
195 ret = wl1271_ps_elp_wakeup(wl);
196 if (ret < 0)
197 goto out;
198
9eb599e9 199 ret = wl1271_set_rx_streaming(wl, wlvif, false);
77ddaa10
EP		 200 if (ret)
201 goto out_sleep;
202
203out_sleep:
204 wl1271_ps_elp_sleep(wl);
205out:
206 mutex_unlock(&wl->mutex);
207}
208
209static void wl1271_rx_streaming_timer(unsigned long data)
210{
9eb599e9
EP		 211 struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
212 struct wl1271 *wl = wlvif->wl;
213 ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
77ddaa10
EP		 214}
215
55df5afb
AN		 216/* wl->mutex must be taken */
217void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
218{
219 /* if the watchdog is not armed, don't do anything */
220 if (wl->tx_allocated_blocks == 0)
221 return;
222
223 cancel_delayed_work(&wl->tx_watchdog_work);
224 ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
225 msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
226}
227
228static void wl12xx_tx_watchdog_work(struct work_struct *work)
229{
230 struct delayed_work *dwork;
231 struct wl1271 *wl;
232
233 dwork = container_of(work, struct delayed_work, work);
234 wl = container_of(dwork, struct wl1271, tx_watchdog_work);
235
236 mutex_lock(&wl->mutex);
237
4cc53383 238 if (unlikely(wl->state != WLCORE_STATE_ON))
55df5afb
AN		 239 goto out;
240
241 /* Tx went out in the meantime - everything is ok */
242 if (unlikely(wl->tx_allocated_blocks == 0))
243 goto out;
244
245 /*
246 * if a ROC is in progress, we might not have any Tx for a long
247 * time (e.g. pending Tx on the non-ROC channels)
248 */
249 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
250 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
251 wl->conf.tx.tx_watchdog_timeout);
252 wl12xx_rearm_tx_watchdog_locked(wl);
253 goto out;
254 }
255
256 /*
257 * if a scan is in progress, we might not have any Tx for a long
258 * time
259 */
260 if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
261 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
262 wl->conf.tx.tx_watchdog_timeout);
263 wl12xx_rearm_tx_watchdog_locked(wl);
264 goto out;
265 }
266
267 /*
268 * AP might cache a frame for a long time for a sleeping station,
269 * so rearm the timer if there's an AP interface with stations. If
270 * Tx is genuinely stuck we will most hopefully discover it when all
271 * stations are removed due to inactivity.
272 */
273 if (wl->active_sta_count) {
274 wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
275 " %d stations",
276 wl->conf.tx.tx_watchdog_timeout,
277 wl->active_sta_count);
278 wl12xx_rearm_tx_watchdog_locked(wl);
279 goto out;
280 }
281
282 wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
283 wl->conf.tx.tx_watchdog_timeout);
284 wl12xx_queue_recovery_work(wl);
285
286out:
287 mutex_unlock(&wl->mutex);
288}
289
e87288f0 290static void wlcore_adjust_conf(struct wl1271 *wl)
8a08048a 291{
95dac04f 292 /* Adjust settings according to optional module parameters */
7230341f 293
93ac8488
IR		 294 /* Firmware Logger params */
295 if (fwlog_mem_blocks != -1) {
296 if (fwlog_mem_blocks >= CONF_FWLOG_MIN_MEM_BLOCKS &&
297 fwlog_mem_blocks <= CONF_FWLOG_MAX_MEM_BLOCKS) {
298 wl->conf.fwlog.mem_blocks = fwlog_mem_blocks;
299 } else {
300 wl1271_error(
301 "Illegal fwlog_mem_blocks=%d using default %d",
302 fwlog_mem_blocks, wl->conf.fwlog.mem_blocks);
303 }
304 }
305
95dac04f
IY		 306 if (fwlog_param) {
307 if (!strcmp(fwlog_param, "continuous")) {
308 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
309 } else if (!strcmp(fwlog_param, "ondemand")) {
310 wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
311 } else if (!strcmp(fwlog_param, "dbgpins")) {
312 wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
313 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
314 } else if (!strcmp(fwlog_param, "disable")) {
315 wl->conf.fwlog.mem_blocks = 0;
316 wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
317 } else {
318 wl1271_error("Unknown fwlog parameter %s", fwlog_param);
319 }
320 }
7230341f
YS		 321
322 if (bug_on_recovery != -1)
323 wl->conf.recovery.bug_on_recovery = (u8) bug_on_recovery;
324
325 if (no_recovery != -1)
326 wl->conf.recovery.no_recovery = (u8) no_recovery;
95dac04f 327}
2b60100b 328
6e8cd331
EP		 329static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
330 struct wl12xx_vif *wlvif,
331 u8 hlid, u8 tx_pkts)
b622d992 332{
37c68ea6 333 bool fw_ps;
b622d992 334
b622d992
AN		 335 fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
336
337 /*
338 * Wake up from high level PS if the STA is asleep with too little
9b17f1b3 339 * packets in FW or if the STA is awake.
b622d992 340 */
9b17f1b3 341 if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
6e8cd331 342 wl12xx_ps_link_end(wl, wlvif, hlid);
b622d992 343
da03209e
AN		 344 /*
345 * Start high-level PS if the STA is asleep with enough blocks in FW.
9a100968
AN		 346 * Make an exception if this is the only connected link. In this
347 * case FW-memory congestion is less of a problem.
41ed1a78
EP		 348 * Note that a single connected STA means 2*ap_count + 1 active links,
349 * since we must account for the global and broadcast AP links
350 * for each AP. The "fw_ps" check assures us the other link is a STA
351 * connected to the AP. Otherwise the FW would not set the PSM bit.
da03209e 352 */
41ed1a78 353 else if (wl->active_link_count > (wl->ap_count*2 + 1) && fw_ps &&
37c68ea6 354 tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
6e8cd331 355 wl12xx_ps_link_start(wl, wlvif, hlid, true);
b622d992
AN		 356}
357
9b17f1b3 358static void wl12xx_irq_update_links_status(struct wl1271 *wl,
c7ffb902 359 struct wl12xx_vif *wlvif,
75fb4df7 360 struct wl_fw_status *status)
b622d992
AN		 361{
362 u32 cur_fw_ps_map;
9ebcb232 363 u8 hlid;
b622d992 364
75fb4df7 365 cur_fw_ps_map = status->link_ps_bitmap;
b622d992
AN		 366 if (wl->ap_fw_ps_map != cur_fw_ps_map) {
367 wl1271_debug(DEBUG_PSM,
368 "link ps prev 0x%x cur 0x%x changed 0x%x",
369 wl->ap_fw_ps_map, cur_fw_ps_map,
370 wl->ap_fw_ps_map ^ cur_fw_ps_map);
371
372 wl->ap_fw_ps_map = cur_fw_ps_map;
373 }
374
da08fdfa 375 for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, wl->num_links)
6e8cd331 376 wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
9ebcb232 377 wl->links[hlid].allocated_pkts);
b622d992
AN		 378}
379
75fb4df7 380static int wlcore_fw_status(struct wl1271 *wl, struct wl_fw_status *status)
f5fc0f86 381{
6e8cd331 382 struct wl12xx_vif *wlvif;
ac5e1e39 383 struct timespec ts;
13b107dd 384 u32 old_tx_blk_count = wl->tx_blocks_available;
4d56ad9c 385 int avail, freed_blocks;
bf54e301 386 int i;
8b7c0fc3 387 int ret;
9ebcb232 388 struct wl1271_link *lnk;
6bac40a6 389
75fb4df7
EP		 390 ret = wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR,
391 wl->raw_fw_status,
392 wl->fw_status_len, false);
8b7c0fc3
IY		 393 if (ret < 0)
394 return ret;
13b107dd 395
75fb4df7
EP		 396 wlcore_hw_convert_fw_status(wl, wl->raw_fw_status, wl->fw_status);
397
f5fc0f86
LC		 398 wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
399 "drv_rx_counter = %d, tx_results_counter = %d)",
75fb4df7
EP		 400 status->intr,
401 status->fw_rx_counter,
402 status->drv_rx_counter,
403 status->tx_results_counter);
f5fc0f86 404
bf54e301
AN		 405 for (i = 0; i < NUM_TX_QUEUES; i++) {
406 /* prevent wrap-around in freed-packets counter */
742246f8 407 wl->tx_allocated_pkts[i] -=
75fb4df7 408 (status->counters.tx_released_pkts[i] -
bf54e301
AN		 409 wl->tx_pkts_freed[i]) & 0xff;
410
75fb4df7 411 wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i];
bf54e301
AN		 412 }
413
9ebcb232 414
da08fdfa 415 for_each_set_bit(i, wl->links_map, wl->num_links) {
93d5d100 416 u8 diff;
9ebcb232 417 lnk = &wl->links[i];
93d5d100 418
9ebcb232 419 /* prevent wrap-around in freed-packets counter */
75fb4df7 420 diff = (status->counters.tx_lnk_free_pkts[i] -
93d5d100
AN		 421 lnk->prev_freed_pkts) & 0xff;
422
423 if (diff == 0)
424 continue;
9ebcb232 425
93d5d100 426 lnk->allocated_pkts -= diff;
75fb4df7 427 lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[i];
93d5d100
AN		 428
429 /* accumulate the prev_freed_pkts counter */
430 lnk->total_freed_pkts += diff;
9ebcb232
AN		 431 }
432
bdf91cfa 433 /* prevent wrap-around in total blocks counter */
75fb4df7
EP		 434 if (likely(wl->tx_blocks_freed <= status->total_released_blks))
435 freed_blocks = status->total_released_blks -
bdf91cfa
AN		 436 wl->tx_blocks_freed;
437 else
438 freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
75fb4df7 439 status->total_released_blks;
bdf91cfa 440
75fb4df7 441 wl->tx_blocks_freed = status->total_released_blks;
13b107dd 442
7bb5d6ce
AN		 443 wl->tx_allocated_blocks -= freed_blocks;
444
55df5afb
AN		 445 /*
446 * If the FW freed some blocks:
447 * If we still have allocated blocks - re-arm the timer, Tx is
448 * not stuck. Otherwise, cancel the timer (no Tx currently).
449 */
450 if (freed_blocks) {
451 if (wl->tx_allocated_blocks)
452 wl12xx_rearm_tx_watchdog_locked(wl);
453 else
454 cancel_delayed_work(&wl->tx_watchdog_work);
455 }
456
75fb4df7 457 avail = status->tx_total - wl->tx_allocated_blocks;
13b107dd 458
4d56ad9c
EP		 459 /*
460 * The FW might change the total number of TX memblocks before
461 * we get a notification about blocks being released. Thus, the
462 * available blocks calculation might yield a temporary result
463 * which is lower than the actual available blocks. Keeping in
464 * mind that only blocks that were allocated can be moved from
465 * TX to RX, tx_blocks_available should never decrease here.
466 */
467 wl->tx_blocks_available = max((int)wl->tx_blocks_available,
468 avail);
f5fc0f86 469
a522550a 470 /* if more blocks are available now, tx work can be scheduled */
13b107dd 471 if (wl->tx_blocks_available > old_tx_blk_count)
a522550a 472 clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
f5fc0f86 473
4d56ad9c 474 /* for AP update num of allocated TX blocks per link and ps status */
6e8cd331 475 wl12xx_for_each_wlvif_ap(wl, wlvif) {
75fb4df7 476 wl12xx_irq_update_links_status(wl, wlvif, status);
6e8cd331 477 }
4d56ad9c 478
f5fc0f86 479 /* update the host-chipset time offset */
ac5e1e39
JO		 480 getnstimeofday(&ts);
481 wl->time_offset = (timespec_to_ns(&ts) >> 10) -
75fb4df7 482 (s64)(status->fw_localtime);
8b7c0fc3 483
75fb4df7 484 wl->fw_fast_lnk_map = status->link_fast_bitmap;
0e810479 485
8b7c0fc3 486 return 0;
f5fc0f86
LC		 487}
488
a620865e
IY		 489static void wl1271_flush_deferred_work(struct wl1271 *wl)
490{
491 struct sk_buff *skb;
492
493 /* Pass all received frames to the network stack */
494 while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
495 ieee80211_rx_ni(wl->hw, skb);
496
497 /* Return sent skbs to the network stack */
498 while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
c27d3acc 499 ieee80211_tx_status_ni(wl->hw, skb);
a620865e
IY		 500}
501
502static void wl1271_netstack_work(struct work_struct *work)
503{
504 struct wl1271 *wl =
505 container_of(work, struct wl1271, netstack_work);
506
507 do {
508 wl1271_flush_deferred_work(wl);
509 } while (skb_queue_len(&wl->deferred_rx_queue));
510}
1e73eb62 511
a620865e
IY		 512#define WL1271_IRQ_MAX_LOOPS 256
513
b5b45b3c 514static int wlcore_irq_locked(struct wl1271 *wl)
f5fc0f86 515{
b5b45b3c 516 int ret = 0;
c15f63bf 517 u32 intr;
1e73eb62 518 int loopcount = WL1271_IRQ_MAX_LOOPS;
a620865e
IY		 519 bool done = false;
520 unsigned int defer_count;
b07d4037
IY		 521 unsigned long flags;
522
341b7cde
IY		 523 /*
524 * In case edge triggered interrupt must be used, we cannot iterate
525 * more than once without introducing race conditions with the hardirq.
526 */
527 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
528 loopcount = 1;
529
f5fc0f86
LC		 530 wl1271_debug(DEBUG_IRQ, "IRQ work");
531
4cc53383 532 if (unlikely(wl->state != WLCORE_STATE_ON))
f5fc0f86
LC		 533 goto out;
534
a620865e 535 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 536 if (ret < 0)
537 goto out;
538
a620865e
IY		 539 while (!done && loopcount--) {
540 /*
541 * In order to avoid a race with the hardirq, clear the flag
542 * before acknowledging the chip. Since the mutex is held,
543 * wl1271_ps_elp_wakeup cannot be called concurrently.
544 */
545 clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
546 smp_mb__after_clear_bit();
1e73eb62 547
75fb4df7 548 ret = wlcore_fw_status(wl, wl->fw_status);
b5b45b3c 549 if (ret < 0)
8b7c0fc3 550 goto out;
53d67a50
AN		 551
552 wlcore_hw_tx_immediate_compl(wl);
553
75fb4df7 554 intr = wl->fw_status->intr;
f5755fe9 555 intr &= WLCORE_ALL_INTR_MASK;
1e73eb62 556 if (!intr) {
a620865e 557 done = true;
1e73eb62
JO		 558 continue;
559 }
f5fc0f86 560
ccc83b04 561 if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
f5755fe9
IR		 562 wl1271_error("HW watchdog interrupt received! starting recovery.");
563 wl->watchdog_recovery = true;
b5b45b3c 564 ret = -EIO;
f5755fe9
IR		 565
566 /* restarting the chip. ignore any other interrupt. */
567 goto out;
568 }
569
570 if (unlikely(intr & WL1271_ACX_SW_INTR_WATCHDOG)) {
571 wl1271_error("SW watchdog interrupt received! "
ccc83b04 572 "starting recovery.");
afbe3718 573 wl->watchdog_recovery = true;
b5b45b3c 574 ret = -EIO;
ccc83b04
EP		 575
576 /* restarting the chip. ignore any other interrupt. */
577 goto out;
578 }
579
a620865e 580 if (likely(intr & WL1271_ACX_INTR_DATA)) {
1e73eb62 581 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
1fd2794f 582
75fb4df7 583 ret = wlcore_rx(wl, wl->fw_status);
b5b45b3c 584 if (ret < 0)
045b9b5f 585 goto out;
f5fc0f86 586
a522550a 587 /* Check if any tx blocks were freed */
b07d4037 588 spin_lock_irqsave(&wl->wl_lock, flags);
a522550a 589 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
f1a46384 590 wl1271_tx_total_queue_count(wl) > 0) {
b07d4037 591 spin_unlock_irqrestore(&wl->wl_lock, flags);
a522550a
IY		 592 /*
593 * In order to avoid starvation of the TX path,
594 * call the work function directly.
595 */
eb96f841 596 ret = wlcore_tx_work_locked(wl);
b5b45b3c 597 if (ret < 0)
eb96f841 598 goto out;
b07d4037
IY		 599 } else {
600 spin_unlock_irqrestore(&wl->wl_lock, flags);
a522550a
IY		 601 }
602
8aad2464 603 /* check for tx results */
045b9b5f 604 ret = wlcore_hw_tx_delayed_compl(wl);
b5b45b3c 605 if (ret < 0)
045b9b5f 606 goto out;
a620865e
IY		 607
608 /* Make sure the deferred queues don't get too long */
609 defer_count = skb_queue_len(&wl->deferred_tx_queue) +
610 skb_queue_len(&wl->deferred_rx_queue);
611 if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
612 wl1271_flush_deferred_work(wl);
1e73eb62 613 }
f5fc0f86 614
1e73eb62
JO		 615 if (intr & WL1271_ACX_INTR_EVENT_A) {
616 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
045b9b5f 617 ret = wl1271_event_handle(wl, 0);
b5b45b3c 618 if (ret < 0)
045b9b5f 619 goto out;
1e73eb62 620 }
f5fc0f86 621
1e73eb62
JO		 622 if (intr & WL1271_ACX_INTR_EVENT_B) {
623 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
045b9b5f 624 ret = wl1271_event_handle(wl, 1);
b5b45b3c 625 if (ret < 0)
045b9b5f 626 goto out;
1e73eb62 627 }
f5fc0f86 628
1e73eb62
JO		 629 if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
630 wl1271_debug(DEBUG_IRQ,
631 "WL1271_ACX_INTR_INIT_COMPLETE");
f5fc0f86 632
1e73eb62
JO		 633 if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
634 wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
c15f63bf 635 }
f5fc0f86 636
f5fc0f86
LC		 637 wl1271_ps_elp_sleep(wl);
638
639out:
b5b45b3c
AN		 640 return ret;
641}
642
643static irqreturn_t wlcore_irq(int irq, void *cookie)
644{
645 int ret;
646 unsigned long flags;
647 struct wl1271 *wl = cookie;
648
97236a06
LC		 649 /* complete the ELP completion */
650 spin_lock_irqsave(&wl->wl_lock, flags);
651 set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
652 if (wl->elp_compl) {
653 complete(wl->elp_compl);
654 wl->elp_compl = NULL;
655 }
656
657 if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
658 /* don't enqueue a work right now. mark it as pending */
659 set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
660 wl1271_debug(DEBUG_IRQ, "should not enqueue work");
661 disable_irq_nosync(wl->irq);
662 pm_wakeup_event(wl->dev, 0);
663 spin_unlock_irqrestore(&wl->wl_lock, flags);
664 return IRQ_HANDLED;
665 }
666 spin_unlock_irqrestore(&wl->wl_lock, flags);
667
b5b45b3c
AN		 668 /* TX might be handled here, avoid redundant work */
669 set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
670 cancel_work_sync(&wl->tx_work);
671
672 mutex_lock(&wl->mutex);
673
674 ret = wlcore_irq_locked(wl);
675 if (ret)
676 wl12xx_queue_recovery_work(wl);
677
b07d4037
IY		 678 spin_lock_irqsave(&wl->wl_lock, flags);
679 /* In case TX was not handled here, queue TX work */
680 clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
681 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
f1a46384 682 wl1271_tx_total_queue_count(wl) > 0)
b07d4037
IY		 683 ieee80211_queue_work(wl->hw, &wl->tx_work);
684 spin_unlock_irqrestore(&wl->wl_lock, flags);
685
f5fc0f86 686 mutex_unlock(&wl->mutex);
a620865e
IY		 687
688 return IRQ_HANDLED;
f5fc0f86
LC		 689}
690
4549d09c
EP		 691struct vif_counter_data {
692 u8 counter;
693
694 struct ieee80211_vif *cur_vif;
695 bool cur_vif_running;
696};
697
698static void wl12xx_vif_count_iter(void *data, u8 *mac,
699 struct ieee80211_vif *vif)
700{
701 struct vif_counter_data *counter = data;
702
703 counter->counter++;
704 if (counter->cur_vif == vif)
705 counter->cur_vif_running = true;
706}
707
708/* caller must not hold wl->mutex, as it might deadlock */
709static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
710 struct ieee80211_vif *cur_vif,
711 struct vif_counter_data *data)
712{
713 memset(data, 0, sizeof(*data));
714 data->cur_vif = cur_vif;
715
8b2c9824 716 ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
4549d09c
EP		 717 wl12xx_vif_count_iter, data);
718}
719
3fcdab70 720static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
f5fc0f86
LC		 721{
722 const struct firmware *fw;
166d504e 723 const char *fw_name;
3fcdab70 724 enum wl12xx_fw_type fw_type;
f5fc0f86
LC		 725 int ret;
726
3fcdab70
EP		 727 if (plt) {
728 fw_type = WL12XX_FW_TYPE_PLT;
6f7dd16c 729 fw_name = wl->plt_fw_name;
3fcdab70 730 } else {
4549d09c
EP		 731 /*
732 * we can't call wl12xx_get_vif_count() here because
733 * wl->mutex is taken, so use the cached last_vif_count value
734 */
9b1a0a77 735 if (wl->last_vif_count > 1 && wl->mr_fw_name) {
4549d09c 736 fw_type = WL12XX_FW_TYPE_MULTI;
6f7dd16c 737 fw_name = wl->mr_fw_name;
4549d09c
EP		 738 } else {
739 fw_type = WL12XX_FW_TYPE_NORMAL;
6f7dd16c 740 fw_name = wl->sr_fw_name;
4549d09c 741 }
3fcdab70
EP		 742 }
743
744 if (wl->fw_type == fw_type)
745 return 0;
166d504e
AN		 746
747 wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
748
a390e85c 749 ret = request_firmware(&fw, fw_name, wl->dev);
f5fc0f86
LC		 750
751 if (ret < 0) {
35898935 752 wl1271_error("could not get firmware %s: %d", fw_name, ret);
f5fc0f86
LC		 753 return ret;
754 }
755
756 if (fw->size % 4) {
757 wl1271_error("firmware size is not multiple of 32 bits: %zu",
758 fw->size);
759 ret = -EILSEQ;
760 goto out;
761 }
762
166d504e 763 vfree(wl->fw);
3fcdab70 764 wl->fw_type = WL12XX_FW_TYPE_NONE;
f5fc0f86 765 wl->fw_len = fw->size;
1fba4974 766 wl->fw = vmalloc(wl->fw_len);
f5fc0f86
LC		 767
768 if (!wl->fw) {
769 wl1271_error("could not allocate memory for the firmware");
770 ret = -ENOMEM;
771 goto out;
772 }
773
774 memcpy(wl->fw, fw->data, wl->fw_len);
f5fc0f86 775 ret = 0;
3fcdab70 776 wl->fw_type = fw_type;
f5fc0f86
LC		 777out:
778 release_firmware(fw);
779
780 return ret;
781}
782
baacb9ae
IY		 783void wl12xx_queue_recovery_work(struct wl1271 *wl)
784{
b666bb7f 785 /* Avoid a recursive recovery */
792a58a8 786 if (wl->state == WLCORE_STATE_ON) {
1ede9500
AN		 787 WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY,
788 &wl->flags));
789
4cc53383 790 wl->state = WLCORE_STATE_RESTARTING;
792a58a8 791 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
2473ec8f 792 wl1271_ps_elp_wakeup(wl);
b666bb7f 793 wlcore_disable_interrupts_nosync(wl);
baacb9ae 794 ieee80211_queue_work(wl->hw, &wl->recovery_work);
b666bb7f 795 }
baacb9ae
IY		 796}
797
95dac04f
IY		 798size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
799{
c83cb803 800 size_t len;
95dac04f
IY		 801
802 /* Make sure we have enough room */
c83cb803 803 len = min(maxlen, (size_t)(PAGE_SIZE - wl->fwlog_size));
95dac04f
IY		 804
805 /* Fill the FW log file, consumed by the sysfs fwlog entry */
806 memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
807 wl->fwlog_size += len;
808
809 return len;
810}
811
812static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
813{
c83cb803 814 struct wlcore_partition_set part, old_part;
95dac04f 815 u32 addr;
1e41213f
IC		 816 u32 offset;
817 u32 end_of_log;
95dac04f 818 u8 *block;
8b7c0fc3 819 int ret;
95dac04f 820
6f7dd16c 821 if ((wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
95dac04f
IY		 822 (wl->conf.fwlog.mem_blocks == 0))
823 return;
824
825 wl1271_info("Reading FW panic log");
826
c83cb803 827 block = kmalloc(wl->fw_mem_block_size, GFP_KERNEL);
95dac04f
IY		 828 if (!block)
829 return;
830
831 /*
832 * Make sure the chip is awake and the logger isn't active.
847cbebd
EP		 833 * Do not send a stop fwlog command if the fw is hanged or if
834 * dbgpins are used (due to some fw bug).
95dac04f 835 */
1e41213f 836 if (wl1271_ps_elp_wakeup(wl))
afbe3718 837 goto out;
847cbebd
EP		 838 if (!wl->watchdog_recovery &&
839 wl->conf.fwlog.output != WL12XX_FWLOG_OUTPUT_DBG_PINS)
1e41213f 840 wl12xx_cmd_stop_fwlog(wl);
95dac04f
IY		 841
842 /* Read the first memory block address */
75fb4df7 843 ret = wlcore_fw_status(wl, wl->fw_status);
8b7c0fc3 844 if (ret < 0)
95dac04f
IY		 845 goto out;
846
75fb4df7 847 addr = wl->fw_status->log_start_addr;
1e41213f 848 if (!addr)
95dac04f
IY		 849 goto out;
850
1e41213f
IC		 851 if (wl->conf.fwlog.mode == WL12XX_FWLOG_CONTINUOUS) {
852 offset = sizeof(addr) + sizeof(struct wl1271_rx_descriptor);
c83cb803 853 end_of_log = wl->fwlog_end;
1e41213f
IC		 854 } else {
855 offset = sizeof(addr);
856 end_of_log = addr;
857 }
858
c83cb803
IC		 859 old_part = wl->curr_part;
860 memset(&part, 0, sizeof(part));
861
95dac04f 862 /* Traverse the memory blocks linked list */
95dac04f 863 do {
c83cb803
IC		 864 part.mem.start = wlcore_hw_convert_hwaddr(wl, addr);
865 part.mem.size = PAGE_SIZE;
866
867 ret = wlcore_set_partition(wl, &part);
868 if (ret < 0) {
869 wl1271_error("%s: set_partition start=0x%X size=%d",
870 __func__, part.mem.start, part.mem.size);
871 goto out;
872 }
873
874 memset(block, 0, wl->fw_mem_block_size);
875 ret = wlcore_read_hwaddr(wl, addr, block,
876 wl->fw_mem_block_size, false);
877
2b800407
IY		 878 if (ret < 0)
879 goto out;
95dac04f
IY		 880
881 /*
882 * Memory blocks are linked to one another. The first 4 bytes
883 * of each memory block hold the hardware address of the next
1e41213f
IC		 884 * one. The last memory block points to the first one in
885 * on demand mode and is equal to 0x2000000 in continuous mode.
95dac04f 886 */
4d56ad9c 887 addr = le32_to_cpup((__le32 *)block);
c83cb803 888
1e41213f 889 if (!wl12xx_copy_fwlog(wl, block + offset,
c83cb803 890 wl->fw_mem_block_size - offset))
95dac04f 891 break;
1e41213f 892 } while (addr && (addr != end_of_log));
95dac04f
IY		 893
894 wake_up_interruptible(&wl->fwlog_waitq);
895
896out:
897 kfree(block);
c83cb803 898 wlcore_set_partition(wl, &old_part);
95dac04f
IY		 899}
900
6134323f
IY		 901static void wlcore_print_recovery(struct wl1271 *wl)
902{
903 u32 pc = 0;
904 u32 hint_sts = 0;
905 int ret;
906
907 wl1271_info("Hardware recovery in progress. FW ver: %s",
908 wl->chip.fw_ver_str);
909
910 /* change partitions momentarily so we can read the FW pc */
b0f0ad39
IY		 911 ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
912 if (ret < 0)
913 return;
6134323f
IY		 914
915 ret = wlcore_read_reg(wl, REG_PC_ON_RECOVERY, &pc);
916 if (ret < 0)
917 return;
918
919 ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &hint_sts);
920 if (ret < 0)
921 return;
922
c108c905
LC		 923 wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
924 pc, hint_sts, ++wl->recovery_count);
6134323f
IY		 925
926 wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
927}
928
929
52b0e7a6
JO		 930static void wl1271_recovery_work(struct work_struct *work)
931{
932 struct wl1271 *wl =
933 container_of(work, struct wl1271, recovery_work);
48e93e40 934 struct wl12xx_vif *wlvif;
6e8cd331 935 struct ieee80211_vif *vif;
52b0e7a6
JO		 936
937 mutex_lock(&wl->mutex);
938
4cc53383 939 if (wl->state == WLCORE_STATE_OFF || wl->plt)
f0277434 940 goto out_unlock;
52b0e7a6 941
aafec111 942 if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags)) {
5cc14c04
BB		 943 if (wl->conf.fwlog.output == WL12XX_FWLOG_OUTPUT_HOST)
944 wl12xx_read_fwlog_panic(wl);
aafec111
AN		 945 wlcore_print_recovery(wl);
946 }
52b0e7a6 947
7230341f 948 BUG_ON(wl->conf.recovery.bug_on_recovery &&
e9ba7152 949 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
2a5bff09 950
7230341f 951 if (wl->conf.recovery.no_recovery) {
34785be5 952 wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
34785be5
AN		 953 goto out_unlock;
954 }
955
7dece1c8 956 /* Prevent spurious TX during FW restart */
66396114 957 wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
7dece1c8 958
52b0e7a6 959 /* reboot the chipset */
6e8cd331
EP		 960 while (!list_empty(&wl->wlvif_list)) {
961 wlvif = list_first_entry(&wl->wlvif_list,
962 struct wl12xx_vif, list);
963 vif = wl12xx_wlvif_to_vif(wlvif);
964 __wl1271_op_remove_interface(wl, vif, false);
965 }
c24ec83b
IY		 966
967 wlcore_op_stop_locked(wl);
baacb9ae 968
52b0e7a6
JO		 969 ieee80211_restart_hw(wl->hw);
970
7dece1c8
AN		 971 /*
972 * Its safe to enable TX now - the queues are stopped after a request
973 * to restart the HW.
974 */
66396114 975 wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
c24ec83b 976
f0277434 977out_unlock:
b034fd6f
AN		 978 wl->watchdog_recovery = false;
979 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
52b0e7a6
JO		 980 mutex_unlock(&wl->mutex);
981}
982
b0f0ad39 983static int wlcore_fw_wakeup(struct wl1271 *wl)
f5fc0f86 984{
b0f0ad39 985 return wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
f5fc0f86
LC		 986}
987
988static int wl1271_setup(struct wl1271 *wl)
989{
75fb4df7
EP		 990 wl->raw_fw_status = kzalloc(wl->fw_status_len, GFP_KERNEL);
991 if (!wl->raw_fw_status)
992 goto err;
f5fc0f86 993
75fb4df7
EP		 994 wl->fw_status = kzalloc(sizeof(*wl->fw_status), GFP_KERNEL);
995 if (!wl->fw_status)
996 goto err;
0afd04e5 997
5cbba2d4 998 wl->tx_res_if = kzalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
75fb4df7
EP		 999 if (!wl->tx_res_if)
1000 goto err;
f5fc0f86 1001
f5fc0f86 1002 return 0;
75fb4df7
EP		 1003err:
1004 kfree(wl->fw_status);
1005 kfree(wl->raw_fw_status);
1006 return -ENOMEM;
f5fc0f86
LC		 1007}
1008
30c5dbd1 1009static int wl12xx_set_power_on(struct wl1271 *wl)
f5fc0f86 1010{
30c5dbd1 1011 int ret;
f5fc0f86 1012
01ac17ec 1013 msleep(WL1271_PRE_POWER_ON_SLEEP);
2cc78ff7
OBC		 1014 ret = wl1271_power_on(wl);
1015 if (ret < 0)
1016 goto out;
f5fc0f86 1017 msleep(WL1271_POWER_ON_SLEEP);
9b280722
TP		 1018 wl1271_io_reset(wl);
1019 wl1271_io_init(wl);
f5fc0f86 1020
b0f0ad39
IY		 1021 ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
1022 if (ret < 0)
1023 goto fail;
f5fc0f86
LC		 1024
1025 /* ELP module wake up */
b0f0ad39
IY		 1026 ret = wlcore_fw_wakeup(wl);
1027 if (ret < 0)
1028 goto fail;
f5fc0f86 1029
30c5dbd1
LC		 1030out:
1031 return ret;
b0f0ad39
IY		 1032
1033fail:
1034 wl1271_power_off(wl);
1035 return ret;
30c5dbd1 1036}
f5fc0f86 1037
3fcdab70 1038static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
30c5dbd1
LC		 1039{
1040 int ret = 0;
1041
1042 ret = wl12xx_set_power_on(wl);
1043 if (ret < 0)
1044 goto out;
f5fc0f86 1045
e62c9ce4
LC		 1046 /*
1047 * For wl127x based devices we could use the default block
1048 * size (512 bytes), but due to a bug in the sdio driver, we
1049 * need to set it explicitly after the chip is powered on. To
1050 * simplify the code and since the performance impact is
1051 * negligible, we use the same block size for all different
1052 * chip types.
b5d6d9b2
LC		 1053 *
1054 * Check if the bus supports blocksize alignment and, if it
1055 * doesn't, make sure we don't have the quirk.
e62c9ce4 1056 */
b5d6d9b2
LC		 1057 if (!wl1271_set_block_size(wl))
1058 wl->quirks &= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
f5fc0f86 1059
6f7dd16c 1060 /* TODO: make sure the lower driver has set things up correctly */
0830ceed 1061
6f7dd16c
LC		 1062 ret = wl1271_setup(wl);
1063 if (ret < 0)
9ccd9217 1064 goto out;
f5fc0f86 1065
3fcdab70
EP		 1066 ret = wl12xx_fetch_firmware(wl, plt);
1067 if (ret < 0)
1068 goto out;
f5fc0f86 1069
f5fc0f86
LC		 1070out:
1071 return ret;
1072}
1073
7019c80e 1074int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode)
f5fc0f86 1075{
9ccd9217 1076 int retries = WL1271_BOOT_RETRIES;
6f07b72a 1077 struct wiphy *wiphy = wl->hw->wiphy;
7019c80e
YS		 1078
1079 static const char* const PLT_MODE[] = {
1080 "PLT_OFF",
1081 "PLT_ON",
dd491ffb
YS		 1082 "PLT_FEM_DETECT",
1083 "PLT_CHIP_AWAKE"
7019c80e
YS		 1084 };
1085
f5fc0f86
LC		 1086 int ret;
1087
1088 mutex_lock(&wl->mutex);
1089
1090 wl1271_notice("power up");
1091
4cc53383 1092 if (wl->state != WLCORE_STATE_OFF) {
f5fc0f86
LC		 1093 wl1271_error("cannot go into PLT state because not "
1094 "in off state: %d", wl->state);
1095 ret = -EBUSY;
1096 goto out;
1097 }
1098
7019c80e
YS		 1099 /* Indicate to lower levels that we are now in PLT mode */
1100 wl->plt = true;
1101 wl->plt_mode = plt_mode;
1102
9ccd9217
JO		 1103 while (retries) {
1104 retries--;
3fcdab70 1105 ret = wl12xx_chip_wakeup(wl, true);
9ccd9217
JO		 1106 if (ret < 0)
1107 goto power_off;
f5fc0f86 1108
dd491ffb
YS		 1109 if (plt_mode != PLT_CHIP_AWAKE) {
1110 ret = wl->ops->plt_init(wl);
1111 if (ret < 0)
1112 goto power_off;
1113 }
eb5b28d0 1114
4cc53383 1115 wl->state = WLCORE_STATE_ON;
7019c80e
YS		 1116 wl1271_notice("firmware booted in PLT mode %s (%s)",
1117 PLT_MODE[plt_mode],
4b7fac77 1118 wl->chip.fw_ver_str);
e7ddf549 1119
6f07b72a
GK		 1120 /* update hw/fw version info in wiphy struct */
1121 wiphy->hw_version = wl->chip.id;
1122 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1123 sizeof(wiphy->fw_version));
1124
9ccd9217 1125 goto out;
eb5b28d0 1126
9ccd9217
JO		 1127power_off:
1128 wl1271_power_off(wl);
1129 }
f5fc0f86 1130
7019c80e
YS		 1131 wl->plt = false;
1132 wl->plt_mode = PLT_OFF;
1133
9ccd9217
JO		 1134 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1135 WL1271_BOOT_RETRIES);
f5fc0f86
LC		 1136out:
1137 mutex_unlock(&wl->mutex);
1138
1139 return ret;
1140}
1141
f3df1331 1142int wl1271_plt_stop(struct wl1271 *wl)
f5fc0f86
LC		 1143{
1144 int ret = 0;
1145
f5fc0f86
LC		 1146 wl1271_notice("power down");
1147
46b0cc9f
IY		 1148 /*
1149 * Interrupts must be disabled before setting the state to OFF.
1150 * Otherwise, the interrupt handler might be called and exit without
1151 * reading the interrupt status.
1152 */
dd5512eb 1153 wlcore_disable_interrupts(wl);
f3df1331 1154 mutex_lock(&wl->mutex);
3fcdab70 1155 if (!wl->plt) {
f3df1331 1156 mutex_unlock(&wl->mutex);
46b0cc9f
IY		 1157
1158 /*
1159 * This will not necessarily enable interrupts as interrupts
1160 * may have been disabled when op_stop was called. It will,
1161 * however, balance the above call to disable_interrupts().
1162 */
dd5512eb 1163 wlcore_enable_interrupts(wl);
46b0cc9f 1164
f5fc0f86
LC		 1165 wl1271_error("cannot power down because not in PLT "
1166 "state: %d", wl->state);
1167 ret = -EBUSY;
1168 goto out;
1169 }
1170
f5fc0f86 1171 mutex_unlock(&wl->mutex);
f3df1331 1172
a620865e
IY		 1173 wl1271_flush_deferred_work(wl);
1174 cancel_work_sync(&wl->netstack_work);
52b0e7a6 1175 cancel_work_sync(&wl->recovery_work);
f6fbeccd 1176 cancel_delayed_work_sync(&wl->elp_work);
55df5afb 1177 cancel_delayed_work_sync(&wl->tx_watchdog_work);
a454969e
IY		 1178
1179 mutex_lock(&wl->mutex);
1180 wl1271_power_off(wl);
f6fbeccd 1181 wl->flags = 0;
2f18cf7c 1182 wl->sleep_auth = WL1271_PSM_ILLEGAL;
4cc53383 1183 wl->state = WLCORE_STATE_OFF;
3fcdab70 1184 wl->plt = false;
7019c80e 1185 wl->plt_mode = PLT_OFF;
f6fbeccd 1186 wl->rx_counter = 0;
a454969e
IY		 1187 mutex_unlock(&wl->mutex);
1188
4ae3fa87
JO		 1189out:
1190 return ret;
1191}
1192
36323f81
TH		 1193static void wl1271_op_tx(struct ieee80211_hw *hw,
1194 struct ieee80211_tx_control *control,
1195 struct sk_buff *skb)
f5fc0f86
LC		 1196{
1197 struct wl1271 *wl = hw->priv;
a8ab39a4
EP		 1198 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1199 struct ieee80211_vif *vif = info->control.vif;
0f168014 1200 struct wl12xx_vif *wlvif = NULL;
830fb67b 1201 unsigned long flags;
708bb3cf 1202 int q, mapping;
d6a3cc2e 1203 u8 hlid;
f5fc0f86 1204
f4d02007
AN		 1205 if (!vif) {
1206 wl1271_debug(DEBUG_TX, "DROP skb with no vif");
1207 ieee80211_free_txskb(hw, skb);
1208 return;
1209 }
0f168014 1210
f4d02007 1211 wlvif = wl12xx_vif_to_data(vif);
708bb3cf
AN		 1212 mapping = skb_get_queue_mapping(skb);
1213 q = wl1271_tx_get_queue(mapping);
b07d4037 1214
36323f81 1215 hlid = wl12xx_tx_get_hlid(wl, wlvif, skb, control->sta);
b07d4037 1216
830fb67b 1217 spin_lock_irqsave(&wl->wl_lock, flags);
b07d4037 1218
66396114
AN		 1219 /*
1220 * drop the packet if the link is invalid or the queue is stopped
1221 * for any reason but watermark. Watermark is a "soft"-stop so we
1222 * allow these packets through.
1223 */
d6a3cc2e 1224 if (hlid == WL12XX_INVALID_LINK_ID ||
f4d02007 1225 (!test_bit(hlid, wlvif->links_map)) ||
d6037d22
AN		 1226 (wlcore_is_queue_stopped_locked(wl, wlvif, q) &&
1227 !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
66396114 1228 WLCORE_QUEUE_STOP_REASON_WATERMARK))) {
d6a3cc2e 1229 wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
5de8eef4 1230 ieee80211_free_txskb(hw, skb);
d6a3cc2e 1231 goto out;
a8c0ddb5 1232 }
f5fc0f86 1233
8ccd16e6
EP		 1234 wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
1235 hlid, q, skb->len);
d6a3cc2e
EP		 1236 skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1237
04b4d69c 1238 wl->tx_queue_count[q]++;
f4d02007 1239 wlvif->tx_queue_count[q]++;
04b4d69c
AN		 1240
1241 /*
1242 * The workqueue is slow to process the tx_queue and we need stop
1243 * the queue here, otherwise the queue will get too long.
1244 */
1c33db78 1245 if (wlvif->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK &&
d6037d22 1246 !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
8cdc44aa 1247 WLCORE_QUEUE_STOP_REASON_WATERMARK)) {
04b4d69c 1248 wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1c33db78 1249 wlcore_stop_queue_locked(wl, wlvif, q,
66396114 1250 WLCORE_QUEUE_STOP_REASON_WATERMARK);
04b4d69c
AN		 1251 }
1252
f5fc0f86
LC		 1253 /*
1254 * The chip specific setup must run before the first TX packet -
1255 * before that, the tx_work will not be initialized!
1256 */
1257
b07d4037
IY		 1258 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1259 !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
a522550a 1260 ieee80211_queue_work(wl->hw, &wl->tx_work);
b07d4037 1261
04216da3 1262out:
b07d4037 1263 spin_unlock_irqrestore(&wl->wl_lock, flags);
f5fc0f86
LC		 1264}
1265
ae47c45f
SL		 1266int wl1271_tx_dummy_packet(struct wl1271 *wl)
1267{
990f5de7 1268 unsigned long flags;
14623787
AN		 1269 int q;
1270
1271 /* no need to queue a new dummy packet if one is already pending */
1272 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1273 return 0;
1274
1275 q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
990f5de7
IY		 1276
1277 spin_lock_irqsave(&wl->wl_lock, flags);
1278 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
f1a46384 1279 wl->tx_queue_count[q]++;
990f5de7
IY		 1280 spin_unlock_irqrestore(&wl->wl_lock, flags);
1281
1282 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1283 if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
eb96f841 1284 return wlcore_tx_work_locked(wl);
990f5de7
IY		 1285
1286 /*
1287 * If the FW TX is busy, TX work will be scheduled by the threaded
1288 * interrupt handler function
1289 */
1290 return 0;
1291}
1292
1293/*
1294 * The size of the dummy packet should be at least 1400 bytes. However, in
1295 * order to minimize the number of bus transactions, aligning it to 512 bytes
1296 * boundaries could be beneficial, performance wise
1297 */
1298#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1299
cf27d867 1300static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
990f5de7
IY		 1301{
1302 struct sk_buff *skb;
ae47c45f 1303 struct ieee80211_hdr_3addr *hdr;
990f5de7
IY		 1304 unsigned int dummy_packet_size;
1305
1306 dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1307 sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
ae47c45f 1308
990f5de7 1309 skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
ae47c45f 1310 if (!skb) {
990f5de7
IY		 1311 wl1271_warning("Failed to allocate a dummy packet skb");
1312 return NULL;
ae47c45f
SL		 1313 }
1314
1315 skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1316
1317 hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
1318 memset(hdr, 0, sizeof(*hdr));
1319 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
990f5de7
IY		 1320 IEEE80211_STYPE_NULLFUNC |
1321 IEEE80211_FCTL_TODS);
ae47c45f 1322
990f5de7 1323 memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
ae47c45f 1324
18b92ffa
LC		 1325 /* Dummy packets require the TID to be management */
1326 skb->priority = WL1271_TID_MGMT;
ae47c45f 1327
990f5de7 1328 /* Initialize all fields that might be used */
86c438f4 1329 skb_set_queue_mapping(skb, 0);
990f5de7 1330 memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
ae47c45f 1331
990f5de7 1332 return skb;
ae47c45f
SL		 1333}
1334
990f5de7 1335
f634a4e7 1336#ifdef CONFIG_PM
22479972 1337static int
50ac6607 1338wl1271_validate_wowlan_pattern(struct cfg80211_pkt_pattern *p)
b95d7cef
ES		 1339{
1340 int num_fields = 0, in_field = 0, fields_size = 0;
1341 int i, pattern_len = 0;
1342
1343 if (!p->mask) {
1344 wl1271_warning("No mask in WoWLAN pattern");
1345 return -EINVAL;
1346 }
1347
1348 /*
1349 * The pattern is broken up into segments of bytes at different offsets
1350 * that need to be checked by the FW filter. Each segment is called
1351 * a field in the FW API. We verify that the total number of fields
1352 * required for this pattern won't exceed FW limits (8)
1353 * as well as the total fields buffer won't exceed the FW limit.
1354 * Note that if there's a pattern which crosses Ethernet/IP header
1355 * boundary a new field is required.
1356 */
1357 for (i = 0; i < p->pattern_len; i++) {
1358 if (test_bit(i, (unsigned long *)p->mask)) {
1359 if (!in_field) {
1360 in_field = 1;
1361 pattern_len = 1;
1362 } else {
1363 if (i == WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1364 num_fields++;
1365 fields_size += pattern_len +
1366 RX_FILTER_FIELD_OVERHEAD;
1367 pattern_len = 1;
1368 } else
1369 pattern_len++;
1370 }
1371 } else {
1372 if (in_field) {
1373 in_field = 0;
1374 fields_size += pattern_len +
1375 RX_FILTER_FIELD_OVERHEAD;
1376 num_fields++;
1377 }
1378 }
1379 }
1380
1381 if (in_field) {
1382 fields_size += pattern_len + RX_FILTER_FIELD_OVERHEAD;
1383 num_fields++;
1384 }
1385
1386 if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
1387 wl1271_warning("RX Filter too complex. Too many segments");
1388 return -EINVAL;
1389 }
1390
1391 if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
1392 wl1271_warning("RX filter pattern is too big");
1393 return -E2BIG;
1394 }
1395
1396 return 0;
1397}
1398
a6eab0c8
ES		 1399struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void)
1400{
1401 return kzalloc(sizeof(struct wl12xx_rx_filter), GFP_KERNEL);
1402}
1403
1404void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)
1405{
1406 int i;
1407
1408 if (filter == NULL)
1409 return;
1410
1411 for (i = 0; i < filter->num_fields; i++)
1412 kfree(filter->fields[i].pattern);
1413
1414 kfree(filter);
1415}
1416
1417int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
1418 u16 offset, u8 flags,
1419 u8 *pattern, u8 len)
1420{
1421 struct wl12xx_rx_filter_field *field;
1422
1423 if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
1424 wl1271_warning("Max fields per RX filter. can't alloc another");
1425 return -EINVAL;
1426 }
1427
1428 field = &filter->fields[filter->num_fields];
1429
1430 field->pattern = kzalloc(len, GFP_KERNEL);
1431 if (!field->pattern) {
1432 wl1271_warning("Failed to allocate RX filter pattern");
1433 return -ENOMEM;
1434 }
1435
1436 filter->num_fields++;
1437
1438 field->offset = cpu_to_le16(offset);
1439 field->flags = flags;
1440 field->len = len;
1441 memcpy(field->pattern, pattern, len);
1442
1443 return 0;
1444}
1445
1446int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)
1447{
1448 int i, fields_size = 0;
1449
1450 for (i = 0; i < filter->num_fields; i++)
1451 fields_size += filter->fields[i].len +
1452 sizeof(struct wl12xx_rx_filter_field) -
1453 sizeof(u8 *);
1454
1455 return fields_size;
1456}
1457
1458void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
1459 u8 *buf)
1460{
1461 int i;
1462 struct wl12xx_rx_filter_field *field;
1463
1464 for (i = 0; i < filter->num_fields; i++) {
1465 field = (struct wl12xx_rx_filter_field *)buf;
1466
1467 field->offset = filter->fields[i].offset;
1468 field->flags = filter->fields[i].flags;
1469 field->len = filter->fields[i].len;
1470
1471 memcpy(&field->pattern, filter->fields[i].pattern, field->len);
1472 buf += sizeof(struct wl12xx_rx_filter_field) -
1473 sizeof(u8 *) + field->len;
1474 }
1475}
1476
b95d7cef
ES		 1477/*
1478 * Allocates an RX filter returned through f
1479 * which needs to be freed using rx_filter_free()
1480 */
50ac6607
AK		 1481static int
1482wl1271_convert_wowlan_pattern_to_rx_filter(struct cfg80211_pkt_pattern *p,
1483 struct wl12xx_rx_filter **f)
b95d7cef
ES		 1484{
1485 int i, j, ret = 0;
1486 struct wl12xx_rx_filter *filter;
1487 u16 offset;
1488 u8 flags, len;
1489
1490 filter = wl1271_rx_filter_alloc();
1491 if (!filter) {
1492 wl1271_warning("Failed to alloc rx filter");
1493 ret = -ENOMEM;
1494 goto err;
1495 }
1496
1497 i = 0;
1498 while (i < p->pattern_len) {
1499 if (!test_bit(i, (unsigned long *)p->mask)) {
1500 i++;
1501 continue;
1502 }
1503
1504 for (j = i; j < p->pattern_len; j++) {
1505 if (!test_bit(j, (unsigned long *)p->mask))
1506 break;
1507
1508 if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE &&
1509 j >= WL1271_RX_FILTER_ETH_HEADER_SIZE)
1510 break;
1511 }
1512
1513 if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1514 offset = i;
1515 flags = WL1271_RX_FILTER_FLAG_ETHERNET_HEADER;
1516 } else {
1517 offset = i - WL1271_RX_FILTER_ETH_HEADER_SIZE;
1518 flags = WL1271_RX_FILTER_FLAG_IP_HEADER;
1519 }
1520
1521 len = j - i;
1522
1523 ret = wl1271_rx_filter_alloc_field(filter,
1524 offset,
1525 flags,
1526 &p->pattern[i], len);
1527 if (ret)
1528 goto err;
1529
1530 i = j;
1531 }
1532
1533 filter->action = FILTER_SIGNAL;
1534
1535 *f = filter;
1536 return 0;
1537
1538err:
1539 wl1271_rx_filter_free(filter);
1540 *f = NULL;
1541
1542 return ret;
1543}
1544
1545static int wl1271_configure_wowlan(struct wl1271 *wl,
1546 struct cfg80211_wowlan *wow)
1547{
1548 int i, ret;
1549
1550 if (!wow || wow->any || !wow->n_patterns) {
c439a1ca
AN		 1551 ret = wl1271_acx_default_rx_filter_enable(wl, 0,
1552 FILTER_SIGNAL);
1553 if (ret)
1554 goto out;
1555
1556 ret = wl1271_rx_filter_clear_all(wl);
1557 if (ret)
1558 goto out;
1559
b95d7cef
ES		 1560 return 0;
1561 }
1562
1563 if (WARN_ON(wow->n_patterns > WL1271_MAX_RX_FILTERS))
1564 return -EINVAL;
1565
1566 /* Validate all incoming patterns before clearing current FW state */
1567 for (i = 0; i < wow->n_patterns; i++) {
1568 ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
1569 if (ret) {
1570 wl1271_warning("Bad wowlan pattern %d", i);
1571 return ret;
1572 }
1573 }
1574
c439a1ca
AN		 1575 ret = wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
1576 if (ret)
1577 goto out;
1578
1579 ret = wl1271_rx_filter_clear_all(wl);
1580 if (ret)
1581 goto out;
b95d7cef
ES		 1582
1583 /* Translate WoWLAN patterns into filters */
1584 for (i = 0; i < wow->n_patterns; i++) {
50ac6607 1585 struct cfg80211_pkt_pattern *p;
b95d7cef
ES		 1586 struct wl12xx_rx_filter *filter = NULL;
1587
1588 p = &wow->patterns[i];
1589
1590 ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
1591 if (ret) {
1592 wl1271_warning("Failed to create an RX filter from "
1593 "wowlan pattern %d", i);
1594 goto out;
1595 }
1596
1597 ret = wl1271_rx_filter_enable(wl, i, 1, filter);
1598
1599 wl1271_rx_filter_free(filter);
1600 if (ret)
1601 goto out;
1602 }
1603
1604 ret = wl1271_acx_default_rx_filter_enable(wl, 1, FILTER_DROP);
1605
1606out:
1607 return ret;
1608}
1609
dae728fe 1610static int wl1271_configure_suspend_sta(struct wl1271 *wl,
b95d7cef
ES		 1611 struct wl12xx_vif *wlvif,
1612 struct cfg80211_wowlan *wow)
dae728fe
ES		 1613{
1614 int ret = 0;
1615
dae728fe 1616 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
c56dbd57 1617 goto out;
dae728fe
ES		 1618
1619 ret = wl1271_ps_elp_wakeup(wl);
1620 if (ret < 0)
c56dbd57 1621 goto out;
dae728fe 1622
c439a1ca
AN		 1623 ret = wl1271_configure_wowlan(wl, wow);
1624 if (ret < 0)
1625 goto out_sleep;
1626
11bc97eb
ES		 1627 if ((wl->conf.conn.suspend_wake_up_event ==
1628 wl->conf.conn.wake_up_event) &&
1629 (wl->conf.conn.suspend_listen_interval ==
1630 wl->conf.conn.listen_interval))
1631 goto out_sleep;
1632
dae728fe
ES		 1633 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1634 wl->conf.conn.suspend_wake_up_event,
1635 wl->conf.conn.suspend_listen_interval);
1636
1637 if (ret < 0)
1638 wl1271_error("suspend: set wake up conditions failed: %d", ret);
1639
c439a1ca 1640out_sleep:
dae728fe 1641 wl1271_ps_elp_sleep(wl);
c56dbd57 1642out:
dae728fe
ES		 1643 return ret;
1644
1645}
9439064c 1646
0603d891
EP		 1647static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1648 struct wl12xx_vif *wlvif)
8a7cf3fe 1649{
e85d1629 1650 int ret = 0;
8a7cf3fe 1651
53d40d0b 1652 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
c56dbd57 1653 goto out;
e85d1629 1654
8a7cf3fe
EP		 1655 ret = wl1271_ps_elp_wakeup(wl);
1656 if (ret < 0)
c56dbd57 1657 goto out;
8a7cf3fe 1658
0603d891 1659 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
8a7cf3fe
EP		 1660
1661 wl1271_ps_elp_sleep(wl);
c56dbd57 1662out:
8a7cf3fe
EP		 1663 return ret;
1664
1665}
1666
d2d66c56 1667static int wl1271_configure_suspend(struct wl1271 *wl,
b95d7cef
ES		 1668 struct wl12xx_vif *wlvif,
1669 struct cfg80211_wowlan *wow)
8a7cf3fe 1670{
dae728fe 1671 if (wlvif->bss_type == BSS_TYPE_STA_BSS)
b95d7cef 1672 return wl1271_configure_suspend_sta(wl, wlvif, wow);
536129c8 1673 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
0603d891 1674 return wl1271_configure_suspend_ap(wl, wlvif);
8a7cf3fe
EP		 1675 return 0;
1676}
1677
8f6ac537 1678static void wl1271_configure_resume(struct wl1271 *wl, struct wl12xx_vif *wlvif)
9439064c 1679{
dae728fe 1680 int ret = 0;
536129c8 1681 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
dae728fe 1682 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
9439064c 1683
dae728fe 1684 if ((!is_ap) && (!is_sta))
9439064c
EP		 1685 return;
1686
d49524d3
EP		 1687 if (is_sta && !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1688 return;
1689
9439064c
EP		 1690 ret = wl1271_ps_elp_wakeup(wl);
1691 if (ret < 0)
c56dbd57 1692 return;
9439064c 1693
dae728fe 1694 if (is_sta) {
b95d7cef
ES		 1695 wl1271_configure_wowlan(wl, NULL);
1696
11bc97eb
ES		 1697 if ((wl->conf.conn.suspend_wake_up_event ==
1698 wl->conf.conn.wake_up_event) &&
1699 (wl->conf.conn.suspend_listen_interval ==
1700 wl->conf.conn.listen_interval))
1701 goto out_sleep;
1702
dae728fe
ES		 1703 ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1704 wl->conf.conn.wake_up_event,
1705 wl->conf.conn.listen_interval);
1706
1707 if (ret < 0)
1708 wl1271_error("resume: wake up conditions failed: %d",
1709 ret);
1710
1711 } else if (is_ap) {
1712 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1713 }
9439064c 1714
11bc97eb 1715out_sleep:
9439064c 1716 wl1271_ps_elp_sleep(wl);
9439064c
EP		 1717}
1718
402e4861
EP		 1719static int wl1271_op_suspend(struct ieee80211_hw *hw,
1720 struct cfg80211_wowlan *wow)
1721{
1722 struct wl1271 *wl = hw->priv;
6e8cd331 1723 struct wl12xx_vif *wlvif;
4a859df8
EP		 1724 int ret;
1725
402e4861 1726 wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
b95d7cef 1727 WARN_ON(!wow);
f44e5868 1728
96caded8
AN		 1729 /* we want to perform the recovery before suspending */
1730 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
1731 wl1271_warning("postponing suspend to perform recovery");
1732 return -EBUSY;
1733 }
1734
b9239b66
AN		 1735 wl1271_tx_flush(wl);
1736
c56dbd57 1737 mutex_lock(&wl->mutex);
4a859df8 1738 wl->wow_enabled = true;
6e8cd331 1739 wl12xx_for_each_wlvif(wl, wlvif) {
b95d7cef 1740 ret = wl1271_configure_suspend(wl, wlvif, wow);
6e8cd331 1741 if (ret < 0) {
cd840f6a 1742 mutex_unlock(&wl->mutex);
6e8cd331
EP		 1743 wl1271_warning("couldn't prepare device to suspend");
1744 return ret;
1745 }
4a859df8 1746 }
c56dbd57 1747 mutex_unlock(&wl->mutex);
4a859df8
EP		 1748 /* flush any remaining work */
1749 wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
f44e5868 1750
4a859df8
EP		 1751 /*
1752 * disable and re-enable interrupts in order to flush
1753 * the threaded_irq
1754 */
dd5512eb 1755 wlcore_disable_interrupts(wl);
4a859df8
EP		 1756
1757 /*
1758 * set suspended flag to avoid triggering a new threaded_irq
1759 * work. no need for spinlock as interrupts are disabled.
1760 */
1761 set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1762
dd5512eb 1763 wlcore_enable_interrupts(wl);
4a859df8 1764 flush_work(&wl->tx_work);
4a859df8 1765 flush_delayed_work(&wl->elp_work);
f44e5868 1766
9be86cf0
AN		 1767 /*
1768 * Cancel the watchdog even if above tx_flush failed. We will detect
1769 * it on resume anyway.
1770 */
1771 cancel_delayed_work(&wl->tx_watchdog_work);
1772
402e4861
EP		 1773 return 0;
1774}
1775
1776static int wl1271_op_resume(struct ieee80211_hw *hw)
1777{
1778 struct wl1271 *wl = hw->priv;
6e8cd331 1779 struct wl12xx_vif *wlvif;
4a859df8 1780 unsigned long flags;
ea0a3cf9 1781 bool run_irq_work = false, pending_recovery;
725b8277 1782 int ret;
4a859df8 1783
402e4861
EP		 1784 wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1785 wl->wow_enabled);
4a859df8 1786 WARN_ON(!wl->wow_enabled);
f44e5868
EP		 1787
1788 /*
1789 * re-enable irq_work enqueuing, and call irq_work directly if
1790 * there is a pending work.
1791 */
4a859df8
EP		 1792 spin_lock_irqsave(&wl->wl_lock, flags);
1793 clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1794 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1795 run_irq_work = true;
1796 spin_unlock_irqrestore(&wl->wl_lock, flags);
9439064c 1797
725b8277
AN		 1798 mutex_lock(&wl->mutex);
1799
ea0a3cf9
AN		 1800 /* test the recovery flag before calling any SDIO functions */
1801 pending_recovery = test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1802 &wl->flags);
1803
4a859df8
EP		 1804 if (run_irq_work) {
1805 wl1271_debug(DEBUG_MAC80211,
1806 "run postponed irq_work directly");
ea0a3cf9
AN		 1807
1808 /* don't talk to the HW if recovery is pending */
725b8277
AN		 1809 if (!pending_recovery) {
1810 ret = wlcore_irq_locked(wl);
1811 if (ret)
1812 wl12xx_queue_recovery_work(wl);
1813 }
ea0a3cf9 1814
dd5512eb 1815 wlcore_enable_interrupts(wl);
f44e5868 1816 }
c56dbd57 1817
ea0a3cf9
AN		 1818 if (pending_recovery) {
1819 wl1271_warning("queuing forgotten recovery on resume");
1820 ieee80211_queue_work(wl->hw, &wl->recovery_work);
1821 goto out;
1822 }
1823
6e8cd331
EP		 1824 wl12xx_for_each_wlvif(wl, wlvif) {
1825 wl1271_configure_resume(wl, wlvif);
1826 }
ea0a3cf9
AN		 1827
1828out:
ff91afc9 1829 wl->wow_enabled = false;
9be86cf0
AN		 1830
1831 /*
1832 * Set a flag to re-init the watchdog on the first Tx after resume.
1833 * That way we avoid possible conditions where Tx-complete interrupts
1834 * fail to arrive and we perform a spurious recovery.
1835 */
1836 set_bit(WL1271_FLAG_REINIT_TX_WDOG, &wl->flags);
c56dbd57 1837 mutex_unlock(&wl->mutex);
f44e5868 1838
402e4861
EP		 1839 return 0;
1840}
f634a4e7 1841#endif
402e4861 1842
f5fc0f86 1843static int wl1271_op_start(struct ieee80211_hw *hw)
1b72aecd
JO		 1844{
1845 wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1846
1847 /*
1848 * We have to delay the booting of the hardware because
1849 * we need to know the local MAC address before downloading and
1850 * initializing the firmware. The MAC address cannot be changed
1851 * after boot, and without the proper MAC address, the firmware
1852 * will not function properly.
1853 *
1854 * The MAC address is first known when the corresponding interface
1855 * is added. That is where we will initialize the hardware.
1856 */
1857
d18da7fc 1858 return 0;
1b72aecd
JO		 1859}
1860
c24ec83b 1861static void wlcore_op_stop_locked(struct wl1271 *wl)
1b72aecd 1862{
baf6277a
EP		 1863 int i;
1864
4cc53383 1865 if (wl->state == WLCORE_STATE_OFF) {
b666bb7f
IY		 1866 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1867 &wl->flags))
1868 wlcore_enable_interrupts(wl);
1869
10c8cd01
EP		 1870 return;
1871 }
46b0cc9f 1872
baf6277a
EP		 1873 /*
1874 * this must be before the cancel_work calls below, so that the work
1875 * functions don't perform further work.
1876 */
4cc53383 1877 wl->state = WLCORE_STATE_OFF;
c24ec83b
IY		 1878
1879 /*
1880 * Use the nosync variant to disable interrupts, so the mutex could be
1881 * held while doing so without deadlocking.
1882 */
1883 wlcore_disable_interrupts_nosync(wl);
1884
10c8cd01
EP		 1885 mutex_unlock(&wl->mutex);
1886
c24ec83b 1887 wlcore_synchronize_interrupts(wl);
6dbc5fc2
EP		 1888 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1889 cancel_work_sync(&wl->recovery_work);
baf6277a
EP		 1890 wl1271_flush_deferred_work(wl);
1891 cancel_delayed_work_sync(&wl->scan_complete_work);
1892 cancel_work_sync(&wl->netstack_work);
1893 cancel_work_sync(&wl->tx_work);
baf6277a 1894 cancel_delayed_work_sync(&wl->elp_work);
55df5afb 1895 cancel_delayed_work_sync(&wl->tx_watchdog_work);
baf6277a
EP		 1896
1897 /* let's notify MAC80211 about the remaining pending TX frames */
baf6277a 1898 mutex_lock(&wl->mutex);
d935e385 1899 wl12xx_tx_reset(wl);
baf6277a
EP		 1900
1901 wl1271_power_off(wl);
b666bb7f
IY		 1902 /*
1903 * In case a recovery was scheduled, interrupts were disabled to avoid
1904 * an interrupt storm. Now that the power is down, it is safe to
1905 * re-enable interrupts to balance the disable depth
1906 */
1907 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1908 wlcore_enable_interrupts(wl);
baf6277a
EP		 1909
1910 wl->band = IEEE80211_BAND_2GHZ;
1911
1912 wl->rx_counter = 0;
1913 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
83d08d3f 1914 wl->channel_type = NL80211_CHAN_NO_HT;
baf6277a
EP		 1915 wl->tx_blocks_available = 0;
1916 wl->tx_allocated_blocks = 0;
1917 wl->tx_results_count = 0;
1918 wl->tx_packets_count = 0;
1919 wl->time_offset = 0;
baf6277a
EP		 1920 wl->ap_fw_ps_map = 0;
1921 wl->ap_ps_map = 0;
2f18cf7c 1922 wl->sleep_auth = WL1271_PSM_ILLEGAL;
baf6277a
EP		 1923 memset(wl->roles_map, 0, sizeof(wl->roles_map));
1924 memset(wl->links_map, 0, sizeof(wl->links_map));
1925 memset(wl->roc_map, 0, sizeof(wl->roc_map));
978cd3a0 1926 memset(wl->session_ids, 0, sizeof(wl->session_ids));
02d0727c 1927 memset(wl->rx_filter_enabled, 0, sizeof(wl->rx_filter_enabled));
baf6277a 1928 wl->active_sta_count = 0;
9a100968 1929 wl->active_link_count = 0;
baf6277a
EP		 1930
1931 /* The system link is always allocated */
9ebcb232
AN		 1932 wl->links[WL12XX_SYSTEM_HLID].allocated_pkts = 0;
1933 wl->links[WL12XX_SYSTEM_HLID].prev_freed_pkts = 0;
baf6277a
EP		 1934 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1935
1936 /*
1937 * this is performed after the cancel_work calls and the associated
1938 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1939 * get executed before all these vars have been reset.
1940 */
1941 wl->flags = 0;
1942
1943 wl->tx_blocks_freed = 0;
1944
1945 for (i = 0; i < NUM_TX_QUEUES; i++) {
1946 wl->tx_pkts_freed[i] = 0;
1947 wl->tx_allocated_pkts[i] = 0;
1948 }
1949
1950 wl1271_debugfs_reset(wl);
1951
75fb4df7
EP		 1952 kfree(wl->raw_fw_status);
1953 wl->raw_fw_status = NULL;
1954 kfree(wl->fw_status);
1955 wl->fw_status = NULL;
baf6277a
EP		 1956 kfree(wl->tx_res_if);
1957 wl->tx_res_if = NULL;
1958 kfree(wl->target_mem_map);
1959 wl->target_mem_map = NULL;
6b70e7eb
VG		 1960
1961 /*
1962 * FW channels must be re-calibrated after recovery,
8d3c1fd8 1963 * save current Reg-Domain channel configuration and clear it.
6b70e7eb 1964 */
8d3c1fd8
EP		 1965 memcpy(wl->reg_ch_conf_pending, wl->reg_ch_conf_last,
1966 sizeof(wl->reg_ch_conf_pending));
6b70e7eb 1967 memset(wl->reg_ch_conf_last, 0, sizeof(wl->reg_ch_conf_last));
c24ec83b
IY		 1968}
1969
1970static void wlcore_op_stop(struct ieee80211_hw *hw)
1971{
1972 struct wl1271 *wl = hw->priv;
1973
1974 wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1975
1976 mutex_lock(&wl->mutex);
1977
1978 wlcore_op_stop_locked(wl);
baf6277a
EP		 1979
1980 mutex_unlock(&wl->mutex);
1b72aecd
JO		 1981}
1982
c50a2825
EP		 1983static void wlcore_channel_switch_work(struct work_struct *work)
1984{
1985 struct delayed_work *dwork;
1986 struct wl1271 *wl;
1987 struct ieee80211_vif *vif;
1988 struct wl12xx_vif *wlvif;
1989 int ret;
1990
1991 dwork = container_of(work, struct delayed_work, work);
1992 wlvif = container_of(dwork, struct wl12xx_vif, channel_switch_work);
1993 wl = wlvif->wl;
1994
1995 wl1271_info("channel switch failed (role_id: %d).", wlvif->role_id);
1996
1997 mutex_lock(&wl->mutex);
1998
1999 if (unlikely(wl->state != WLCORE_STATE_ON))
2000 goto out;
2001
2002 /* check the channel switch is still ongoing */
2003 if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags))
2004 goto out;
2005
2006 vif = wl12xx_wlvif_to_vif(wlvif);
2007 ieee80211_chswitch_done(vif, false);
2008
2009 ret = wl1271_ps_elp_wakeup(wl);
2010 if (ret < 0)
2011 goto out;
2012
2013 wl12xx_cmd_stop_channel_switch(wl, wlvif);
2014
2015 wl1271_ps_elp_sleep(wl);
2016out:
2017 mutex_unlock(&wl->mutex);
2018}
2019
2020static void wlcore_connection_loss_work(struct work_struct *work)
2021{
2022 struct delayed_work *dwork;
2023 struct wl1271 *wl;
2024 struct ieee80211_vif *vif;
2025 struct wl12xx_vif *wlvif;
2026
2027 dwork = container_of(work, struct delayed_work, work);
2028 wlvif = container_of(dwork, struct wl12xx_vif, connection_loss_work);
2029 wl = wlvif->wl;
2030
2031 wl1271_info("Connection loss work (role_id: %d).", wlvif->role_id);
2032
2033 mutex_lock(&wl->mutex);
2034
2035 if (unlikely(wl->state != WLCORE_STATE_ON))
2036 goto out;
2037
2038 /* Call mac80211 connection loss */
2039 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2040 goto out;
2041
2042 vif = wl12xx_wlvif_to_vif(wlvif);
2043 ieee80211_connection_loss(vif);
2044out:
2045 mutex_unlock(&wl->mutex);
2046}
2047
187e52cc
AN		 2048static void wlcore_pending_auth_complete_work(struct work_struct *work)
2049{
2050 struct delayed_work *dwork;
2051 struct wl1271 *wl;
2052 struct wl12xx_vif *wlvif;
2053 unsigned long time_spare;
2054 int ret;
2055
2056 dwork = container_of(work, struct delayed_work, work);
2057 wlvif = container_of(dwork, struct wl12xx_vif,
2058 pending_auth_complete_work);
2059 wl = wlvif->wl;
2060
2061 mutex_lock(&wl->mutex);
2062
2063 if (unlikely(wl->state != WLCORE_STATE_ON))
2064 goto out;
2065
2066 /*
2067 * Make sure a second really passed since the last auth reply. Maybe
2068 * a second auth reply arrived while we were stuck on the mutex.
2069 * Check for a little less than the timeout to protect from scheduler
2070 * irregularities.
2071 */
2072 time_spare = jiffies +
2073 msecs_to_jiffies(WLCORE_PEND_AUTH_ROC_TIMEOUT - 50);
2074 if (!time_after(time_spare, wlvif->pending_auth_reply_time))
2075 goto out;
2076
2077 ret = wl1271_ps_elp_wakeup(wl);
2078 if (ret < 0)
2079 goto out;
2080
2081 /* cancel the ROC if active */
2082 wlcore_update_inconn_sta(wl, wlvif, NULL, false);
2083
2084 wl1271_ps_elp_sleep(wl);
2085out:
2086 mutex_unlock(&wl->mutex);
2087}
2088
e5a359f8
EP		 2089static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
2090{
2091 u8 policy = find_first_zero_bit(wl->rate_policies_map,
2092 WL12XX_MAX_RATE_POLICIES);
2093 if (policy >= WL12XX_MAX_RATE_POLICIES)
2094 return -EBUSY;
2095
2096 __set_bit(policy, wl->rate_policies_map);
2097 *idx = policy;
2098 return 0;
2099}
2100
2101static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
2102{
2103 if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
2104 return;
2105
2106 __clear_bit(*idx, wl->rate_policies_map);
2107 *idx = WL12XX_MAX_RATE_POLICIES;
2108}
2109
001e39a8
EP		 2110static int wlcore_allocate_klv_template(struct wl1271 *wl, u8 *idx)
2111{
2112 u8 policy = find_first_zero_bit(wl->klv_templates_map,
2113 WLCORE_MAX_KLV_TEMPLATES);
2114 if (policy >= WLCORE_MAX_KLV_TEMPLATES)
2115 return -EBUSY;
2116
2117 __set_bit(policy, wl->klv_templates_map);
2118 *idx = policy;
2119 return 0;
2120}
2121
2122static void wlcore_free_klv_template(struct wl1271 *wl, u8 *idx)
2123{
2124 if (WARN_ON(*idx >= WLCORE_MAX_KLV_TEMPLATES))
2125 return;
2126
2127 __clear_bit(*idx, wl->klv_templates_map);
2128 *idx = WLCORE_MAX_KLV_TEMPLATES;
2129}
2130
536129c8 2131static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
b78b47eb 2132{
536129c8 2133 switch (wlvif->bss_type) {
b78b47eb 2134 case BSS_TYPE_AP_BSS:
fb0e707c 2135 if (wlvif->p2p)
045c745f
EP		 2136 return WL1271_ROLE_P2P_GO;
2137 else
2138 return WL1271_ROLE_AP;
b78b47eb
EP		 2139
2140 case BSS_TYPE_STA_BSS:
fb0e707c 2141 if (wlvif->p2p)
045c745f
EP		 2142 return WL1271_ROLE_P2P_CL;
2143 else
2144 return WL1271_ROLE_STA;
b78b47eb 2145
227e81e1
EP		 2146 case BSS_TYPE_IBSS:
2147 return WL1271_ROLE_IBSS;
2148
b78b47eb 2149 default:
536129c8 2150 wl1271_error("invalid bss_type: %d", wlvif->bss_type);
b78b47eb
EP		 2151 }
2152 return WL12XX_INVALID_ROLE_TYPE;
2153}
2154
83587505 2155static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
87fbcb0f 2156{
e936bbe0 2157 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e5a359f8 2158 int i;
e936bbe0 2159
48e93e40
EP		 2160 /* clear everything but the persistent data */
2161 memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
e936bbe0
EP		 2162
2163 switch (ieee80211_vif_type_p2p(vif)) {
2164 case NL80211_IFTYPE_P2P_CLIENT:
2165 wlvif->p2p = 1;
2166 /* fall-through */
2167 case NL80211_IFTYPE_STATION:
2168 wlvif->bss_type = BSS_TYPE_STA_BSS;
2169 break;
2170 case NL80211_IFTYPE_ADHOC:
2171 wlvif->bss_type = BSS_TYPE_IBSS;
2172 break;
2173 case NL80211_IFTYPE_P2P_GO:
2174 wlvif->p2p = 1;
2175 /* fall-through */
2176 case NL80211_IFTYPE_AP:
2177 wlvif->bss_type = BSS_TYPE_AP_BSS;
2178 break;
2179 default:
2180 wlvif->bss_type = MAX_BSS_TYPE;
2181 return -EOPNOTSUPP;
2182 }
2183
0603d891 2184 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
7edebf56 2185 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
afaf8bdb 2186 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
a8ab39a4 2187
e936bbe0
EP		 2188 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2189 wlvif->bss_type == BSS_TYPE_IBSS) {
2190 /* init sta/ibss data */
2191 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 2192 wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2193 wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2194 wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
001e39a8 2195 wlcore_allocate_klv_template(wl, &wlvif->sta.klv_template_id);
15e05bc0
LC		 2196 wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2197 wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
2198 wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
e936bbe0
EP		 2199 } else {
2200 /* init ap data */
2201 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2202 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 2203 wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2204 wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2205 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2206 wl12xx_allocate_rate_policy(wl,
2207 &wlvif->ap.ucast_rate_idx[i]);
42ec1f82 2208 wlvif->basic_rate_set = CONF_TX_ENABLED_RATES;
15e05bc0
LC		 2209 /*
2210 * TODO: check if basic_rate shouldn't be
2211 * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2212 * instead (the same thing for STA above).
2213 */
42ec1f82 2214 wlvif->basic_rate = CONF_TX_ENABLED_RATES;
15e05bc0 2215 /* TODO: this seems to be used only for STA, check it */
42ec1f82 2216 wlvif->rate_set = CONF_TX_ENABLED_RATES;
e936bbe0 2217 }
a8ab39a4 2218
83587505
EP		 2219 wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2220 wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
6a899796
EP		 2221 wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
2222
1b92f15e
EP		 2223 /*
2224 * mac80211 configures some values globally, while we treat them
2225 * per-interface. thus, on init, we have to copy them from wl
2226 */
2227 wlvif->band = wl->band;
61f845f4 2228 wlvif->channel = wl->channel;
6bd65029 2229 wlvif->power_level = wl->power_level;
83d08d3f 2230 wlvif->channel_type = wl->channel_type;
1b92f15e 2231
9eb599e9
EP		 2232 INIT_WORK(&wlvif->rx_streaming_enable_work,
2233 wl1271_rx_streaming_enable_work);
2234 INIT_WORK(&wlvif->rx_streaming_disable_work,
2235 wl1271_rx_streaming_disable_work);
c50a2825
EP		 2236 INIT_DELAYED_WORK(&wlvif->channel_switch_work,
2237 wlcore_channel_switch_work);
2238 INIT_DELAYED_WORK(&wlvif->connection_loss_work,
2239 wlcore_connection_loss_work);
187e52cc
AN		 2240 INIT_DELAYED_WORK(&wlvif->pending_auth_complete_work,
2241 wlcore_pending_auth_complete_work);
87627214 2242 INIT_LIST_HEAD(&wlvif->list);
252efa4f 2243
9eb599e9
EP		 2244 setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
2245 (unsigned long) wlvif);
e936bbe0 2246 return 0;
87fbcb0f
EP		 2247}
2248
5dc283fe 2249static int wl12xx_init_fw(struct wl1271 *wl)
f5fc0f86 2250{
9ccd9217 2251 int retries = WL1271_BOOT_RETRIES;
71125abd 2252 bool booted = false;
1d095475
EP		 2253 struct wiphy *wiphy = wl->hw->wiphy;
2254 int ret;
f5fc0f86 2255
9ccd9217
JO		 2256 while (retries) {
2257 retries--;
3fcdab70 2258 ret = wl12xx_chip_wakeup(wl, false);
9ccd9217
JO		 2259 if (ret < 0)
2260 goto power_off;
f5fc0f86 2261
dd5512eb 2262 ret = wl->ops->boot(wl);
9ccd9217
JO		 2263 if (ret < 0)
2264 goto power_off;
f5fc0f86 2265
92c77c73
EP		 2266 ret = wl1271_hw_init(wl);
2267 if (ret < 0)
2268 goto irq_disable;
2269
71125abd
EP		 2270 booted = true;
2271 break;
eb5b28d0 2272
9ccd9217 2273irq_disable:
9ccd9217
JO		 2274 mutex_unlock(&wl->mutex);
2275 /* Unlocking the mutex in the middle of handling is
2276 inherently unsafe. In this case we deem it safe to do,
2277 because we need to let any possibly pending IRQ out of
4cc53383 2278 the system (and while we are WLCORE_STATE_OFF the IRQ
9ccd9217
JO		 2279 work function will not do anything.) Also, any other
2280 possible concurrent operations will fail due to the
2281 current state, hence the wl1271 struct should be safe. */
dd5512eb 2282 wlcore_disable_interrupts(wl);
a620865e
IY		 2283 wl1271_flush_deferred_work(wl);
2284 cancel_work_sync(&wl->netstack_work);
9ccd9217
JO		 2285 mutex_lock(&wl->mutex);
2286power_off:
2287 wl1271_power_off(wl);
2288 }
eb5b28d0 2289
71125abd
EP		 2290 if (!booted) {
2291 wl1271_error("firmware boot failed despite %d retries",
2292 WL1271_BOOT_RETRIES);
2293 goto out;
2294 }
2295
4b7fac77 2296 wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
71125abd
EP		 2297
2298 /* update hw/fw version info in wiphy struct */
2299 wiphy->hw_version = wl->chip.id;
4b7fac77 2300 strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
71125abd
EP		 2301 sizeof(wiphy->fw_version));
2302
fb6a6819
LC		 2303 /*
2304 * Now we know if 11a is supported (info from the NVS), so disable
2305 * 11a channels if not supported
2306 */
2307 if (!wl->enable_11a)
2308 wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;
2309
2310 wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2311 wl->enable_11a ? "" : "not ");
2312
4cc53383 2313 wl->state = WLCORE_STATE_ON;
1d095475 2314out:
5dc283fe 2315 return ret;
1d095475
EP		 2316}
2317
92e712da
EP		 2318static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2319{
2320 return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2321}
2322
4549d09c
EP		 2323/*
2324 * Check whether a fw switch (i.e. moving from one loaded
2325 * fw to another) is needed. This function is also responsible
2326 * for updating wl->last_vif_count, so it must be called before
2327 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2328 * will be used).
2329 */
2330static bool wl12xx_need_fw_change(struct wl1271 *wl,
2331 struct vif_counter_data vif_counter_data,
2332 bool add)
2333{
2334 enum wl12xx_fw_type current_fw = wl->fw_type;
2335 u8 vif_count = vif_counter_data.counter;
2336
2337 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
2338 return false;
2339
2340 /* increase the vif count if this is a new vif */
2341 if (add && !vif_counter_data.cur_vif_running)
2342 vif_count++;
2343
2344 wl->last_vif_count = vif_count;
2345
2346 /* no need for fw change if the device is OFF */
4cc53383 2347 if (wl->state == WLCORE_STATE_OFF)
4549d09c
EP		 2348 return false;
2349
9b1a0a77
EP		 2350 /* no need for fw change if a single fw is used */
2351 if (!wl->mr_fw_name)
2352 return false;
2353
4549d09c
EP		 2354 if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
2355 return true;
2356 if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
2357 return true;
2358
2359 return false;
2360}
2361
3dee4393
EP		 2362/*
2363 * Enter "forced psm". Make sure the sta is in psm against the ap,
2364 * to make the fw switch a bit more disconnection-persistent.
2365 */
2366static void wl12xx_force_active_psm(struct wl1271 *wl)
2367{
2368 struct wl12xx_vif *wlvif;
2369
2370 wl12xx_for_each_wlvif_sta(wl, wlvif) {
2371 wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
2372 }
2373}
2374
1c33db78
AN		 2375struct wlcore_hw_queue_iter_data {
2376 unsigned long hw_queue_map[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES)];
2377 /* current vif */
2378 struct ieee80211_vif *vif;
2379 /* is the current vif among those iterated */
2380 bool cur_running;
2381};
2382
2383static void wlcore_hw_queue_iter(void *data, u8 *mac,
2384 struct ieee80211_vif *vif)
2385{
2386 struct wlcore_hw_queue_iter_data *iter_data = data;
2387
2388 if (WARN_ON_ONCE(vif->hw_queue[0] == IEEE80211_INVAL_HW_QUEUE))
2389 return;
2390
2391 if (iter_data->cur_running || vif == iter_data->vif) {
2392 iter_data->cur_running = true;
2393 return;
2394 }
2395
2396 __set_bit(vif->hw_queue[0] / NUM_TX_QUEUES, iter_data->hw_queue_map);
2397}
2398
2399static int wlcore_allocate_hw_queue_base(struct wl1271 *wl,
2400 struct wl12xx_vif *wlvif)
2401{
2402 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2403 struct wlcore_hw_queue_iter_data iter_data = {};
2404 int i, q_base;
2405
2406 iter_data.vif = vif;
2407
2408 /* mark all bits taken by active interfaces */
2409 ieee80211_iterate_active_interfaces_atomic(wl->hw,
2410 IEEE80211_IFACE_ITER_RESUME_ALL,
2411 wlcore_hw_queue_iter, &iter_data);
2412
2413 /* the current vif is already running in mac80211 (resume/recovery) */
2414 if (iter_data.cur_running) {
2415 wlvif->hw_queue_base = vif->hw_queue[0];
2416 wl1271_debug(DEBUG_MAC80211,
2417 "using pre-allocated hw queue base %d",
2418 wlvif->hw_queue_base);
2419
2420 /* interface type might have changed type */
2421 goto adjust_cab_queue;
2422 }
2423
2424 q_base = find_first_zero_bit(iter_data.hw_queue_map,
2425 WLCORE_NUM_MAC_ADDRESSES);
2426 if (q_base >= WLCORE_NUM_MAC_ADDRESSES)
2427 return -EBUSY;
2428
2429 wlvif->hw_queue_base = q_base * NUM_TX_QUEUES;
2430 wl1271_debug(DEBUG_MAC80211, "allocating hw queue base: %d",
2431 wlvif->hw_queue_base);
2432
2433 for (i = 0; i < NUM_TX_QUEUES; i++) {
2434 wl->queue_stop_reasons[wlvif->hw_queue_base + i] = 0;
2435 /* register hw queues in mac80211 */
2436 vif->hw_queue[i] = wlvif->hw_queue_base + i;
2437 }
2438
2439adjust_cab_queue:
2440 /* the last places are reserved for cab queues per interface */
2441 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2442 vif->cab_queue = NUM_TX_QUEUES * WLCORE_NUM_MAC_ADDRESSES +
2443 wlvif->hw_queue_base / NUM_TX_QUEUES;
2444 else
2445 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
2446
2447 return 0;
2448}
2449
1d095475
EP		 2450static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2451 struct ieee80211_vif *vif)
2452{
2453 struct wl1271 *wl = hw->priv;
2454 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4549d09c 2455 struct vif_counter_data vif_count;
1d095475
EP		 2456 int ret = 0;
2457 u8 role_type;
1d095475 2458
dd491ffb
YS		 2459 if (wl->plt) {
2460 wl1271_error("Adding Interface not allowed while in PLT mode");
2461 return -EBUSY;
2462 }
2463
ea086359
JB		 2464 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2465 IEEE80211_VIF_SUPPORTS_CQM_RSSI;
c1288b12 2466
1d095475
EP		 2467 wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2468 ieee80211_vif_type_p2p(vif), vif->addr);
2469
4549d09c
EP		 2470 wl12xx_get_vif_count(hw, vif, &vif_count);
2471
1d095475 2472 mutex_lock(&wl->mutex);
f750c820
EP		 2473 ret = wl1271_ps_elp_wakeup(wl);
2474 if (ret < 0)
2475 goto out_unlock;
2476
1d095475
EP		 2477 /*
2478 * in some very corner case HW recovery scenarios its possible to
2479 * get here before __wl1271_op_remove_interface is complete, so
2480 * opt out if that is the case.
2481 */
10c8cd01
EP		 2482 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2483 test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
1d095475
EP		 2484 ret = -EBUSY;
2485 goto out;
2486 }
2487
3fcdab70 2488
83587505 2489 ret = wl12xx_init_vif_data(wl, vif);
1d095475
EP		 2490 if (ret < 0)
2491 goto out;
2492
2493 wlvif->wl = wl;
2494 role_type = wl12xx_get_role_type(wl, wlvif);
2495 if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2496 ret = -EINVAL;
2497 goto out;
2498 }
2499
1c33db78
AN		 2500 ret = wlcore_allocate_hw_queue_base(wl, wlvif);
2501 if (ret < 0)
2502 goto out;
2503
4549d09c 2504 if (wl12xx_need_fw_change(wl, vif_count, true)) {
3dee4393 2505 wl12xx_force_active_psm(wl);
e9ba7152 2506 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
4549d09c
EP		 2507 mutex_unlock(&wl->mutex);
2508 wl1271_recovery_work(&wl->recovery_work);
2509 return 0;
2510 }
2511
1d095475
EP		 2512 /*
2513 * TODO: after the nvs issue will be solved, move this block
2514 * to start(), and make sure here the driver is ON.
2515 */
4cc53383 2516 if (wl->state == WLCORE_STATE_OFF) {
1d095475
EP		 2517 /*
2518 * we still need this in order to configure the fw
2519 * while uploading the nvs
2520 */
5e037e74 2521 memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
1d095475 2522
5dc283fe
LC		 2523 ret = wl12xx_init_fw(wl);
2524 if (ret < 0)
1d095475 2525 goto out;
1d095475
EP		 2526 }
2527
1d095475
EP		 2528 ret = wl12xx_cmd_role_enable(wl, vif->addr,
2529 role_type, &wlvif->role_id);
2530 if (ret < 0)
2531 goto out;
2532
2533 ret = wl1271_init_vif_specific(wl, vif);
2534 if (ret < 0)
2535 goto out;
2536
87627214 2537 list_add(&wlvif->list, &wl->wlvif_list);
10c8cd01 2538 set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
a4e4130d
EP		 2539
2540 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2541 wl->ap_count++;
2542 else
2543 wl->sta_count++;
eb5b28d0 2544out:
f750c820
EP		 2545 wl1271_ps_elp_sleep(wl);
2546out_unlock:
f5fc0f86
LC		 2547 mutex_unlock(&wl->mutex);
2548
2549 return ret;
2550}
2551
7dece1c8 2552static void __wl1271_op_remove_interface(struct wl1271 *wl,
536129c8 2553 struct ieee80211_vif *vif,
7dece1c8 2554 bool reset_tx_queues)
f5fc0f86 2555{
536129c8 2556 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e5a359f8 2557 int i, ret;
2f18cf7c 2558 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
f5fc0f86 2559
1b72aecd 2560 wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
f5fc0f86 2561
10c8cd01
EP		 2562 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2563 return;
2564
13026dec 2565 /* because of hardware recovery, we may get here twice */
4cc53383 2566 if (wl->state == WLCORE_STATE_OFF)
13026dec
JO		 2567 return;
2568
1b72aecd 2569 wl1271_info("down");
f5fc0f86 2570
baf6277a 2571 if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
c50a2825 2572 wl->scan_wlvif == wlvif) {
55df5afb
AN		 2573 /*
2574 * Rearm the tx watchdog just before idling scan. This
2575 * prevents just-finished scans from triggering the watchdog
2576 */
2577 wl12xx_rearm_tx_watchdog_locked(wl);
2578
08688d6b 2579 wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c 2580 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
c50a2825 2581 wl->scan_wlvif = NULL;
b739a42c 2582 wl->scan.req = NULL;
76a029fb 2583 ieee80211_scan_completed(wl->hw, true);
f5fc0f86
LC		 2584 }
2585
5a441f5f 2586 if (wl->sched_vif == wlvif)
10199756 2587 wl->sched_vif = NULL;
10199756 2588
5d979f35
AN		 2589 if (wl->roc_vif == vif) {
2590 wl->roc_vif = NULL;
2591 ieee80211_remain_on_channel_expired(wl->hw);
2592 }
2593
b78b47eb
EP		 2594 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2595 /* disable active roles */
2596 ret = wl1271_ps_elp_wakeup(wl);
2597 if (ret < 0)
2598 goto deinit;
2599
b890f4c3
EP		 2600 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2601 wlvif->bss_type == BSS_TYPE_IBSS) {
2602 if (wl12xx_dev_role_started(wlvif))
2603 wl12xx_stop_dev(wl, wlvif);
04e8079c
EP		 2604 }
2605
0603d891 2606 ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
b78b47eb
EP		 2607 if (ret < 0)
2608 goto deinit;
2609
2610 wl1271_ps_elp_sleep(wl);
2611 }
2612deinit:
5a99610c
AN		 2613 wl12xx_tx_reset_wlvif(wl, wlvif);
2614
e51ae9be 2615 /* clear all hlids (except system_hlid) */
afaf8bdb 2616 wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
e5a359f8
EP		 2617
2618 if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2619 wlvif->bss_type == BSS_TYPE_IBSS) {
2620 wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2621 wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2622 wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2623 wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
001e39a8 2624 wlcore_free_klv_template(wl, &wlvif->sta.klv_template_id);
e5a359f8
EP		 2625 } else {
2626 wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2627 wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2628 wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2629 wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2630 for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2631 wl12xx_free_rate_policy(wl,
2632 &wlvif->ap.ucast_rate_idx[i]);
830be7e0 2633 wl1271_free_ap_keys(wl, wlvif);
e5a359f8 2634 }
b78b47eb 2635
3eba4a0e
ES		 2636 dev_kfree_skb(wlvif->probereq);
2637 wlvif->probereq = NULL;
e4120df9
EP		 2638 if (wl->last_wlvif == wlvif)
2639 wl->last_wlvif = NULL;
87627214 2640 list_del(&wlvif->list);
c7ffb902 2641 memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
0603d891 2642 wlvif->role_id = WL12XX_INVALID_ROLE_ID;
7edebf56 2643 wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
d6e19d13 2644
2f18cf7c 2645 if (is_ap)
a4e4130d
EP		 2646 wl->ap_count--;
2647 else
2648 wl->sta_count--;
2649
42066f9a
AN		 2650 /*
2651 * Last AP, have more stations. Configure sleep auth according to STA.
2652 * Don't do thin on unintended recovery.
2653 */
2654 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) &&
2655 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags))
2656 goto unlock;
2657
71e996be
EP		 2658 if (wl->ap_count == 0 && is_ap) {
2659 /* mask ap events */
2660 wl->event_mask &= ~wl->ap_event_mask;
2661 wl1271_event_unmask(wl);
2662 }
2663
2f18cf7c
AN		 2664 if (wl->ap_count == 0 && is_ap && wl->sta_count) {
2665 u8 sta_auth = wl->conf.conn.sta_sleep_auth;
2666 /* Configure for power according to debugfs */
2667 if (sta_auth != WL1271_PSM_ILLEGAL)
2668 wl1271_acx_sleep_auth(wl, sta_auth);
2f18cf7c
AN		 2669 /* Configure for ELP power saving */
2670 else
2671 wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
2672 }
2673
42066f9a 2674unlock:
baf6277a 2675 mutex_unlock(&wl->mutex);
d6bf9ada 2676
9eb599e9
EP		 2677 del_timer_sync(&wlvif->rx_streaming_timer);
2678 cancel_work_sync(&wlvif->rx_streaming_enable_work);
2679 cancel_work_sync(&wlvif->rx_streaming_disable_work);
c50a2825 2680 cancel_delayed_work_sync(&wlvif->connection_loss_work);
c838478b 2681 cancel_delayed_work_sync(&wlvif->channel_switch_work);
187e52cc 2682 cancel_delayed_work_sync(&wlvif->pending_auth_complete_work);
bd9dc49c 2683
baf6277a 2684 mutex_lock(&wl->mutex);
52a2a375 2685}
bd9dc49c 2686
52a2a375
JO		 2687static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2688 struct ieee80211_vif *vif)
2689{
2690 struct wl1271 *wl = hw->priv;
10c8cd01 2691 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
6e8cd331 2692 struct wl12xx_vif *iter;
4549d09c 2693 struct vif_counter_data vif_count;
52a2a375 2694
4549d09c 2695 wl12xx_get_vif_count(hw, vif, &vif_count);
52a2a375 2696 mutex_lock(&wl->mutex);
10c8cd01 2697
4cc53383 2698 if (wl->state == WLCORE_STATE_OFF ||
10c8cd01
EP		 2699 !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2700 goto out;
2701
67353299
JO		 2702 /*
2703 * wl->vif can be null here if someone shuts down the interface
2704 * just when hardware recovery has been started.
2705 */
6e8cd331
EP		 2706 wl12xx_for_each_wlvif(wl, iter) {
2707 if (iter != wlvif)
2708 continue;
2709
536129c8 2710 __wl1271_op_remove_interface(wl, vif, true);
6e8cd331 2711 break;
67353299 2712 }
6e8cd331 2713 WARN_ON(iter != wlvif);
4549d09c 2714 if (wl12xx_need_fw_change(wl, vif_count, false)) {
3dee4393 2715 wl12xx_force_active_psm(wl);
e9ba7152 2716 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
4549d09c 2717 wl12xx_queue_recovery_work(wl);
4549d09c 2718 }
10c8cd01 2719out:
67353299 2720 mutex_unlock(&wl->mutex);
f5fc0f86
LC		 2721}
2722
c0fad1b7
EP		 2723static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2724 struct ieee80211_vif *vif,
2725 enum nl80211_iftype new_type, bool p2p)
2726{
4549d09c
EP		 2727 struct wl1271 *wl = hw->priv;
2728 int ret;
2729
2730 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
c0fad1b7
EP		 2731 wl1271_op_remove_interface(hw, vif);
2732
249e9698 2733 vif->type = new_type;
c0fad1b7 2734 vif->p2p = p2p;
4549d09c
EP		 2735 ret = wl1271_op_add_interface(hw, vif);
2736
2737 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2738 return ret;
c0fad1b7
EP		 2739}
2740
3230f35e 2741static int wlcore_join(struct wl1271 *wl, struct wl12xx_vif *wlvif)
82429d32
JO		 2742{
2743 int ret;
536129c8 2744 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
82429d32 2745
69e5434c
JO		 2746 /*
2747 * One of the side effects of the JOIN command is that is clears
2748 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2749 * to a WPA/WPA2 access point will therefore kill the data-path.
8bf69aae
OBC		 2750 * Currently the only valid scenario for JOIN during association
2751 * is on roaming, in which case we will also be given new keys.
2752 * Keep the below message for now, unless it starts bothering
2753 * users who really like to roam a lot :)
69e5434c 2754 */
ba8447f6 2755 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
69e5434c
JO		 2756 wl1271_info("JOIN while associated.");
2757
5ec8a448
EP		 2758 /* clear encryption type */
2759 wlvif->encryption_type = KEY_NONE;
2760
227e81e1 2761 if (is_ibss)
87fbcb0f 2762 ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
18eab430
EP		 2763 else {
2764 if (wl->quirks & WLCORE_QUIRK_START_STA_FAILS) {
2765 /*
2766 * TODO: this is an ugly workaround for wl12xx fw
2767 * bug - we are not able to tx/rx after the first
2768 * start_sta, so make dummy start+stop calls,
2769 * and then call start_sta again.
2770 * this should be fixed in the fw.
2771 */
2772 wl12xx_cmd_role_start_sta(wl, wlvif);
2773 wl12xx_cmd_role_stop_sta(wl, wlvif);
2774 }
2775
87fbcb0f 2776 ret = wl12xx_cmd_role_start_sta(wl, wlvif);
18eab430 2777 }
3230f35e
EP		 2778
2779 return ret;
2780}
2781
2782static int wl1271_ssid_set(struct wl12xx_vif *wlvif, struct sk_buff *skb,
2783 int offset)
2784{
2785 u8 ssid_len;
2786 const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2787 skb->len - offset);
2788
2789 if (!ptr) {
2790 wl1271_error("No SSID in IEs!");
2791 return -ENOENT;
2792 }
2793
2794 ssid_len = ptr[1];
2795 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2796 wl1271_error("SSID is too long!");
2797 return -EINVAL;
2798 }
2799
2800 wlvif->ssid_len = ssid_len;
2801 memcpy(wlvif->ssid, ptr+2, ssid_len);
2802 return 0;
2803}
2804
2805static int wlcore_set_ssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2806{
2807 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2808 struct sk_buff *skb;
2809 int ieoffset;
2810
2811 /* we currently only support setting the ssid from the ap probe req */
2812 if (wlvif->bss_type != BSS_TYPE_STA_BSS)
2813 return -EINVAL;
2814
2815 skb = ieee80211_ap_probereq_get(wl->hw, vif);
2816 if (!skb)
2817 return -EINVAL;
2818
2819 ieoffset = offsetof(struct ieee80211_mgmt,
2820 u.probe_req.variable);
2821 wl1271_ssid_set(wlvif, skb, ieoffset);
2822 dev_kfree_skb(skb);
2823
2824 return 0;
2825}
2826
2827static int wlcore_set_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ec87011a
EP		 2828 struct ieee80211_bss_conf *bss_conf,
2829 u32 sta_rate_set)
3230f35e
EP		 2830{
2831 int ieoffset;
2832 int ret;
2833
2834 wlvif->aid = bss_conf->aid;
aaabee8b 2835 wlvif->channel_type = cfg80211_get_chandef_type(&bss_conf->chandef);
3230f35e 2836 wlvif->beacon_int = bss_conf->beacon_int;
d50529c0 2837 wlvif->wmm_enabled = bss_conf->qos;
3230f35e
EP		 2838
2839 set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2840
2841 /*
2842 * with wl1271, we don't need to update the
2843 * beacon_int and dtim_period, because the firmware
2844 * updates it by itself when the first beacon is
2845 * received after a join.
2846 */
2847 ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
82429d32 2848 if (ret < 0)
3230f35e 2849 return ret;
82429d32 2850
3230f35e
EP		 2851 /*
2852 * Get a template for hardware connection maintenance
2853 */
2854 dev_kfree_skb(wlvif->probereq);
2855 wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
2856 wlvif,
2857 NULL);
2858 ieoffset = offsetof(struct ieee80211_mgmt,
2859 u.probe_req.variable);
2860 wl1271_ssid_set(wlvif, wlvif->probereq, ieoffset);
2861
2862 /* enable the connection monitoring feature */
2863 ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
2864 if (ret < 0)
2865 return ret;
82429d32
JO		 2866
2867 /*
2868 * The join command disable the keep-alive mode, shut down its process,
2869 * and also clear the template config, so we need to reset it all after
2870 * the join. The acx_aid starts the keep-alive process, and the order
2871 * of the commands below is relevant.
2872 */
0603d891 2873 ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
82429d32 2874 if (ret < 0)
3230f35e 2875 return ret;
82429d32 2876
0603d891 2877 ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
82429d32 2878 if (ret < 0)
3230f35e 2879 return ret;
82429d32 2880
d2d66c56 2881 ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
82429d32 2882 if (ret < 0)
3230f35e 2883 return ret;
82429d32 2884
0603d891 2885 ret = wl1271_acx_keep_alive_config(wl, wlvif,
001e39a8 2886 wlvif->sta.klv_template_id,
82429d32
JO		 2887 ACX_KEEP_ALIVE_TPL_VALID);
2888 if (ret < 0)
3230f35e 2889 return ret;
82429d32 2890
6c7b5194
EP		 2891 /*
2892 * The default fw psm configuration is AUTO, while mac80211 default
2893 * setting is off (ACTIVE), so sync the fw with the correct value.
2894 */
2895 ret = wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE);
ec87011a
EP		 2896 if (ret < 0)
2897 return ret;
2898
2899 if (sta_rate_set) {
2900 wlvif->rate_set =
2901 wl1271_tx_enabled_rates_get(wl,
2902 sta_rate_set,
2903 wlvif->band);
2904 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2905 if (ret < 0)
2906 return ret;
2907 }
82429d32 2908
82429d32
JO		 2909 return ret;
2910}
2911
3230f35e 2912static int wlcore_unset_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
c7f43e45
LC		 2913{
2914 int ret;
3230f35e
EP		 2915 bool sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
2916
2917 /* make sure we are connected (sta) joined */
2918 if (sta &&
2919 !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2920 return false;
2921
2922 /* make sure we are joined (ibss) */
2923 if (!sta &&
2924 test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags))
2925 return false;
2926
2927 if (sta) {
2928 /* use defaults when not associated */
2929 wlvif->aid = 0;
2930
2931 /* free probe-request template */
2932 dev_kfree_skb(wlvif->probereq);
2933 wlvif->probereq = NULL;
2934
2935 /* disable connection monitor features */
2936 ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
2937 if (ret < 0)
2938 return ret;
2939
2940 /* Disable the keep-alive feature */
2941 ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
2942 if (ret < 0)
2943 return ret;
d881fa2c
EP		 2944
2945 /* disable beacon filtering */
2946 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
2947 if (ret < 0)
2948 return ret;
3230f35e 2949 }
c7f43e45 2950
52630c5d 2951 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
6e8cd331
EP		 2952 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2953
fcab1890 2954 wl12xx_cmd_stop_channel_switch(wl, wlvif);
6e8cd331 2955 ieee80211_chswitch_done(vif, false);
c50a2825 2956 cancel_delayed_work(&wlvif->channel_switch_work);
6d158ff3
SL		 2957 }
2958
4137c17c
EP		 2959 /* invalidate keep-alive template */
2960 wl1271_acx_keep_alive_config(wl, wlvif,
001e39a8 2961 wlvif->sta.klv_template_id,
4137c17c
EP		 2962 ACX_KEEP_ALIVE_TPL_INVALID);
2963
3230f35e 2964 return 0;
c7f43e45
LC		 2965}
2966
87fbcb0f 2967static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ebba60c6 2968{
1b92f15e 2969 wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
30d0c8fd 2970 wlvif->rate_set = wlvif->basic_rate_set;
ebba60c6
JO		 2971}
2972
b0ed8a4d
AN		 2973static void wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2974 bool idle)
2975{
2976 bool cur_idle = !test_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
2977
2978 if (idle == cur_idle)
2979 return;
2980
2981 if (idle) {
2982 clear_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
2983 } else {
2984 /* The current firmware only supports sched_scan in idle */
2985 if (wl->sched_vif == wlvif)
2986 wl->ops->sched_scan_stop(wl, wlvif);
2987
2988 set_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
2989 }
2990}
2991
9f259c4e
EP		 2992static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2993 struct ieee80211_conf *conf, u32 changed)
0d58cbff
JO		 2994{
2995 int ret;
2996
6bd65029 2997 if (conf->power_level != wlvif->power_level) {
0603d891 2998 ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
0d58cbff 2999 if (ret < 0)
9f259c4e 3000 return ret;
33c2c06c 3001
6bd65029 3002 wlvif->power_level = conf->power_level;
0d58cbff
JO		 3003 }
3004
9f259c4e 3005 return 0;
0d58cbff
JO		 3006}
3007
9f259c4e 3008static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
f5fc0f86 3009{
9f259c4e
EP		 3010 struct wl1271 *wl = hw->priv;
3011 struct wl12xx_vif *wlvif;
3012 struct ieee80211_conf *conf = &hw->conf;
b6970ee5 3013 int ret = 0;
f5fc0f86 3014
b6970ee5 3015 wl1271_debug(DEBUG_MAC80211, "mac80211 config psm %s power %d %s"
9f259c4e 3016 " changed 0x%x",
9f259c4e
EP		 3017 conf->flags & IEEE80211_CONF_PS ? "on" : "off",
3018 conf->power_level,
3019 conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
3020 changed);
3021
9f259c4e
EP		 3022 mutex_lock(&wl->mutex);
3023
9f259c4e
EP		 3024 if (changed & IEEE80211_CONF_CHANGE_POWER)
3025 wl->power_level = conf->power_level;
3026
4cc53383 3027 if (unlikely(wl->state != WLCORE_STATE_ON))
9f259c4e
EP		 3028 goto out;
3029
3030 ret = wl1271_ps_elp_wakeup(wl);
3031 if (ret < 0)
3032 goto out;
3033
3034 /* configure each interface */
3035 wl12xx_for_each_wlvif(wl, wlvif) {
3036 ret = wl12xx_config_vif(wl, wlvif, conf, changed);
3037 if (ret < 0)
3038 goto out_sleep;
3039 }
3040
f5fc0f86
LC		 3041out_sleep:
3042 wl1271_ps_elp_sleep(wl);
3043
3044out:
3045 mutex_unlock(&wl->mutex);
3046
3047 return ret;
3048}
3049
b54853f1
JO		 3050struct wl1271_filter_params {
3051 bool enabled;
3052 int mc_list_length;
3053 u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
3054};
3055
22bedad3
JP		 3056static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
3057 struct netdev_hw_addr_list *mc_list)
c87dec9f 3058{
c87dec9f 3059 struct wl1271_filter_params *fp;
22bedad3 3060 struct netdev_hw_addr *ha;
c87dec9f 3061
74441130 3062 fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
c87dec9f
JO		 3063 if (!fp) {
3064 wl1271_error("Out of memory setting filters.");
3065 return 0;
3066 }
3067
3068 /* update multicast filtering parameters */
c87dec9f 3069 fp->mc_list_length = 0;
22bedad3
JP		 3070 if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
3071 fp->enabled = false;
3072 } else {
3073 fp->enabled = true;
3074 netdev_hw_addr_list_for_each(ha, mc_list) {
c87dec9f 3075 memcpy(fp->mc_list[fp->mc_list_length],
22bedad3 3076 ha->addr, ETH_ALEN);
c87dec9f 3077 fp->mc_list_length++;
22bedad3 3078 }
c87dec9f
JO		 3079 }
3080
b54853f1 3081 return (u64)(unsigned long)fp;
c87dec9f 3082}
f5fc0f86 3083
b54853f1
JO		 3084#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
3085 FIF_ALLMULTI | \
3086 FIF_FCSFAIL | \
3087 FIF_BCN_PRBRESP_PROMISC | \
3088 FIF_CONTROL | \
3089 FIF_OTHER_BSS)
3090
f5fc0f86
LC		 3091static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
3092 unsigned int changed,
c87dec9f 3093 unsigned int *total, u64 multicast)
f5fc0f86 3094{
b54853f1 3095 struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
f5fc0f86 3096 struct wl1271 *wl = hw->priv;
6e8cd331 3097 struct wl12xx_vif *wlvif;
536129c8 3098
b54853f1 3099 int ret;
f5fc0f86 3100
7d057869
AN		 3101 wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
3102 " total %x", changed, *total);
f5fc0f86 3103
b54853f1
JO		 3104 mutex_lock(&wl->mutex);
3105
2c10bb9c
SD		 3106 *total &= WL1271_SUPPORTED_FILTERS;
3107 changed &= WL1271_SUPPORTED_FILTERS;
3108
4cc53383 3109 if (unlikely(wl->state != WLCORE_STATE_ON))
b54853f1
JO		 3110 goto out;
3111
a620865e 3112 ret = wl1271_ps_elp_wakeup(wl);
b54853f1
JO		 3113 if (ret < 0)
3114 goto out;
3115
6e8cd331
EP		 3116 wl12xx_for_each_wlvif(wl, wlvif) {
3117 if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
3118 if (*total & FIF_ALLMULTI)
3119 ret = wl1271_acx_group_address_tbl(wl, wlvif,
3120 false,
3121 NULL, 0);
3122 else if (fp)
3123 ret = wl1271_acx_group_address_tbl(wl, wlvif,
3124 fp->enabled,
3125 fp->mc_list,
3126 fp->mc_list_length);
3127 if (ret < 0)
3128 goto out_sleep;
3129 }
7d057869 3130 }
f5fc0f86 3131
08c1d1c7
EP		 3132 /*
3133 * the fw doesn't provide an api to configure the filters. instead,
3134 * the filters configuration is based on the active roles / ROC
3135 * state.
3136 */
b54853f1
JO		 3137
3138out_sleep:
3139 wl1271_ps_elp_sleep(wl);
3140
3141out:
3142 mutex_unlock(&wl->mutex);
14b228a0 3143 kfree(fp);
f5fc0f86
LC		 3144}
3145
170d0e67
EP		 3146static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3147 u8 id, u8 key_type, u8 key_size,
3148 const u8 *key, u8 hlid, u32 tx_seq_32,
3149 u16 tx_seq_16)
7f179b46
AN		 3150{
3151 struct wl1271_ap_key *ap_key;
3152 int i;
3153
3154 wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
3155
3156 if (key_size > MAX_KEY_SIZE)
3157 return -EINVAL;
3158
3159 /*
3160 * Find next free entry in ap_keys. Also check we are not replacing
3161 * an existing key.
3162 */
3163 for (i = 0; i < MAX_NUM_KEYS; i++) {
170d0e67 3164 if (wlvif->ap.recorded_keys[i] == NULL)
7f179b46
AN		 3165 break;
3166
170d0e67 3167 if (wlvif->ap.recorded_keys[i]->id == id) {
7f179b46
AN		 3168 wl1271_warning("trying to record key replacement");
3169 return -EINVAL;
3170 }
3171 }
3172
3173 if (i == MAX_NUM_KEYS)
3174 return -EBUSY;
3175
3176 ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
3177 if (!ap_key)
3178 return -ENOMEM;
3179
3180 ap_key->id = id;
3181 ap_key->key_type = key_type;
3182 ap_key->key_size = key_size;
3183 memcpy(ap_key->key, key, key_size);
3184 ap_key->hlid = hlid;
3185 ap_key->tx_seq_32 = tx_seq_32;
3186 ap_key->tx_seq_16 = tx_seq_16;
3187
170d0e67 3188 wlvif->ap.recorded_keys[i] = ap_key;
7f179b46
AN		 3189 return 0;
3190}
3191
170d0e67 3192static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
7f179b46
AN		 3193{
3194 int i;
3195
3196 for (i = 0; i < MAX_NUM_KEYS; i++) {
170d0e67
EP		 3197 kfree(wlvif->ap.recorded_keys[i]);
3198 wlvif->ap.recorded_keys[i] = NULL;
7f179b46
AN		 3199 }
3200}
3201
a8ab39a4 3202static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
7f179b46
AN		 3203{
3204 int i, ret = 0;
3205 struct wl1271_ap_key *key;
3206 bool wep_key_added = false;
3207
3208 for (i = 0; i < MAX_NUM_KEYS; i++) {
7f97b487 3209 u8 hlid;
170d0e67 3210 if (wlvif->ap.recorded_keys[i] == NULL)
7f179b46
AN		 3211 break;
3212
170d0e67 3213 key = wlvif->ap.recorded_keys[i];
7f97b487
EP		 3214 hlid = key->hlid;
3215 if (hlid == WL12XX_INVALID_LINK_ID)
a8ab39a4 3216 hlid = wlvif->ap.bcast_hlid;
7f97b487 3217
a8ab39a4 3218 ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
7f179b46
AN		 3219 key->id, key->key_type,
3220 key->key_size, key->key,
7f97b487 3221 hlid, key->tx_seq_32,
7f179b46
AN		 3222 key->tx_seq_16);
3223 if (ret < 0)
3224 goto out;
3225
3226 if (key->key_type == KEY_WEP)
3227 wep_key_added = true;
3228 }
3229
3230 if (wep_key_added) {
f75c753f 3231 ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
a8ab39a4 3232 wlvif->ap.bcast_hlid);
7f179b46
AN		 3233 if (ret < 0)
3234 goto out;
3235 }
3236
3237out:
170d0e67 3238 wl1271_free_ap_keys(wl, wlvif);
7f179b46
AN		 3239 return ret;
3240}
3241
536129c8
EP		 3242static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3243 u16 action, u8 id, u8 key_type,
7f179b46
AN		 3244 u8 key_size, const u8 *key, u32 tx_seq_32,
3245 u16 tx_seq_16, struct ieee80211_sta *sta)
3246{
3247 int ret;
536129c8 3248 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
7f179b46
AN		 3249
3250 if (is_ap) {
3251 struct wl1271_station *wl_sta;
3252 u8 hlid;
3253
3254 if (sta) {
3255 wl_sta = (struct wl1271_station *)sta->drv_priv;
3256 hlid = wl_sta->hlid;
3257 } else {
a8ab39a4 3258 hlid = wlvif->ap.bcast_hlid;
7f179b46
AN		 3259 }
3260
53d40d0b 3261 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
7f179b46
AN		 3262 /*
3263 * We do not support removing keys after AP shutdown.
3264 * Pretend we do to make mac80211 happy.
3265 */
3266 if (action != KEY_ADD_OR_REPLACE)
3267 return 0;
3268
170d0e67 3269 ret = wl1271_record_ap_key(wl, wlvif, id,
7f179b46
AN		 3270 key_type, key_size,
3271 key, hlid, tx_seq_32,
3272 tx_seq_16);
3273 } else {
a8ab39a4 3274 ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
7f179b46
AN		 3275 id, key_type, key_size,
3276 key, hlid, tx_seq_32,
3277 tx_seq_16);
3278 }
3279
3280 if (ret < 0)
3281 return ret;
3282 } else {
3283 const u8 *addr;
3284 static const u8 bcast_addr[ETH_ALEN] = {
3285 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
3286 };
3287
3288 addr = sta ? sta->addr : bcast_addr;
3289
3290 if (is_zero_ether_addr(addr)) {
3291 /* We dont support TX only encryption */
3292 return -EOPNOTSUPP;
3293 }
3294
3295 /* The wl1271 does not allow to remove unicast keys - they
3296 will be cleared automatically on next CMD_JOIN. Ignore the
3297 request silently, as we dont want the mac80211 to emit
3298 an error message. */
3299 if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
3300 return 0;
3301
010d3d30
EP		 3302 /* don't remove key if hlid was already deleted */
3303 if (action == KEY_REMOVE &&
154da67c 3304 wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
010d3d30
EP		 3305 return 0;
3306
a8ab39a4 3307 ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
7f179b46
AN		 3308 id, key_type, key_size,
3309 key, addr, tx_seq_32,
3310 tx_seq_16);
3311 if (ret < 0)
3312 return ret;
3313
7f179b46
AN		 3314 }
3315
3316 return 0;
3317}
3318
a1c597f2 3319static int wlcore_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
f5fc0f86
LC		 3320 struct ieee80211_vif *vif,
3321 struct ieee80211_sta *sta,
3322 struct ieee80211_key_conf *key_conf)
3323{
3324 struct wl1271 *wl = hw->priv;
af390f4d
EP		 3325 int ret;
3326 bool might_change_spare =
3327 key_conf->cipher == WL1271_CIPHER_SUITE_GEM ||
3328 key_conf->cipher == WLAN_CIPHER_SUITE_TKIP;
3329
3330 if (might_change_spare) {
3331 /*
3332 * stop the queues and flush to ensure the next packets are
3333 * in sync with FW spare block accounting
3334 */
af390f4d 3335 wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
af390f4d
EP		 3336 wl1271_tx_flush(wl);
3337 }
3338
3339 mutex_lock(&wl->mutex);
3340
3341 if (unlikely(wl->state != WLCORE_STATE_ON)) {
3342 ret = -EAGAIN;
3343 goto out_wake_queues;
3344 }
a1c597f2 3345
af390f4d
EP		 3346 ret = wl1271_ps_elp_wakeup(wl);
3347 if (ret < 0)
3348 goto out_wake_queues;
3349
3350 ret = wlcore_hw_set_key(wl, cmd, vif, sta, key_conf);
3351
3352 wl1271_ps_elp_sleep(wl);
3353
3354out_wake_queues:
3355 if (might_change_spare)
3356 wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
3357
3358 mutex_unlock(&wl->mutex);
3359
3360 return ret;
a1c597f2
AN		 3361}
3362
3363int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
3364 struct ieee80211_vif *vif,
3365 struct ieee80211_sta *sta,
3366 struct ieee80211_key_conf *key_conf)
3367{
536129c8 3368 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
f5fc0f86 3369 int ret;
ac4e4ce5
JO		 3370 u32 tx_seq_32 = 0;
3371 u16 tx_seq_16 = 0;
f5fc0f86 3372 u8 key_type;
93d5d100 3373 u8 hlid;
f5fc0f86 3374
f5fc0f86
LC		 3375 wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
3376
7f179b46 3377 wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
f5fc0f86 3378 wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
97359d12 3379 key_conf->cipher, key_conf->keyidx,
f5fc0f86
LC		 3380 key_conf->keylen, key_conf->flags);
3381 wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
3382
93d5d100
AN		 3383 if (wlvif->bss_type == BSS_TYPE_AP_BSS)
3384 if (sta) {
3385 struct wl1271_station *wl_sta = (void *)sta->drv_priv;
3386 hlid = wl_sta->hlid;
3387 } else {
3388 hlid = wlvif->ap.bcast_hlid;
3389 }
3390 else
3391 hlid = wlvif->sta.hlid;
3392
3393 if (hlid != WL12XX_INVALID_LINK_ID) {
3394 u64 tx_seq = wl->links[hlid].total_freed_pkts;
3395 tx_seq_32 = WL1271_TX_SECURITY_HI32(tx_seq);
3396 tx_seq_16 = WL1271_TX_SECURITY_LO16(tx_seq);
3397 }
3398
97359d12
JB		 3399 switch (key_conf->cipher) {
3400 case WLAN_CIPHER_SUITE_WEP40:
3401 case WLAN_CIPHER_SUITE_WEP104:
f5fc0f86
LC		 3402 key_type = KEY_WEP;
3403
3404 key_conf->hw_key_idx = key_conf->keyidx;
3405 break;
97359d12 3406 case WLAN_CIPHER_SUITE_TKIP:
f5fc0f86 3407 key_type = KEY_TKIP;
f5fc0f86
LC		 3408 key_conf->hw_key_idx = key_conf->keyidx;
3409 break;
97359d12 3410 case WLAN_CIPHER_SUITE_CCMP:
f5fc0f86 3411 key_type = KEY_AES;
12d4b975 3412 key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
f5fc0f86 3413 break;
7a55724e
JO		 3414 case WL1271_CIPHER_SUITE_GEM:
3415 key_type = KEY_GEM;
7a55724e 3416 break;
f5fc0f86 3417 default:
97359d12 3418 wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
f5fc0f86 3419
af390f4d 3420 return -EOPNOTSUPP;
f5fc0f86
LC		 3421 }
3422
3423 switch (cmd) {
3424 case SET_KEY:
536129c8 3425 ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
7f179b46
AN		 3426 key_conf->keyidx, key_type,
3427 key_conf->keylen, key_conf->key,
3428 tx_seq_32, tx_seq_16, sta);
f5fc0f86
LC		 3429 if (ret < 0) {
3430 wl1271_error("Could not add or replace key");
af390f4d 3431 return ret;
f5fc0f86 3432 }
5ec8a448
EP		 3433
3434 /*
3435 * reconfiguring arp response if the unicast (or common)
3436 * encryption key type was changed
3437 */
3438 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
3439 (sta || key_type == KEY_WEP) &&
3440 wlvif->encryption_type != key_type) {
3441 wlvif->encryption_type = key_type;
3442 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3443 if (ret < 0) {
3444 wl1271_warning("build arp rsp failed: %d", ret);
af390f4d 3445 return ret;
5ec8a448
EP		 3446 }
3447 }
f5fc0f86
LC		 3448 break;
3449
3450 case DISABLE_KEY:
536129c8 3451 ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
7f179b46
AN		 3452 key_conf->keyidx, key_type,
3453 key_conf->keylen, key_conf->key,
3454 0, 0, sta);
f5fc0f86
LC		 3455 if (ret < 0) {
3456 wl1271_error("Could not remove key");
af390f4d 3457 return ret;
f5fc0f86
LC		 3458 }
3459 break;
3460
3461 default:
3462 wl1271_error("Unsupported key cmd 0x%x", cmd);
af390f4d 3463 return -EOPNOTSUPP;
f5fc0f86
LC		 3464 }
3465
f5fc0f86
LC		 3466 return ret;
3467}
a1c597f2 3468EXPORT_SYMBOL_GPL(wlcore_set_key);
f5fc0f86 3469
ba1e6eb9
YD		 3470static void wl1271_op_set_default_key_idx(struct ieee80211_hw *hw,
3471 struct ieee80211_vif *vif,
3472 int key_idx)
3473{
3474 struct wl1271 *wl = hw->priv;
3475 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3476 int ret;
3477
3478 wl1271_debug(DEBUG_MAC80211, "mac80211 set default key idx %d",
3479 key_idx);
3480
bf4e5f1a
EP		 3481 /* we don't handle unsetting of default key */
3482 if (key_idx == -1)
3483 return;
3484
ba1e6eb9
YD		 3485 mutex_lock(&wl->mutex);
3486
3487 if (unlikely(wl->state != WLCORE_STATE_ON)) {
3488 ret = -EAGAIN;
3489 goto out_unlock;
3490 }
3491
3492 ret = wl1271_ps_elp_wakeup(wl);
3493 if (ret < 0)
3494 goto out_unlock;
3495
3496 wlvif->default_key = key_idx;
3497
3498 /* the default WEP key needs to be configured at least once */
3499 if (wlvif->encryption_type == KEY_WEP) {
3500 ret = wl12xx_cmd_set_default_wep_key(wl,
3501 key_idx,
3502 wlvif->sta.hlid);
3503 if (ret < 0)
3504 goto out_sleep;
3505 }
3506
3507out_sleep:
3508 wl1271_ps_elp_sleep(wl);
3509
3510out_unlock:
3511 mutex_unlock(&wl->mutex);
3512}
3513
6b70e7eb
VG		 3514void wlcore_regdomain_config(struct wl1271 *wl)
3515{
3516 int ret;
3517
3518 if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
3519 return;
3520
3521 mutex_lock(&wl->mutex);
75592be5
AN		 3522
3523 if (unlikely(wl->state != WLCORE_STATE_ON))
3524 goto out;
3525
6b70e7eb
VG		 3526 ret = wl1271_ps_elp_wakeup(wl);
3527 if (ret < 0)
3528 goto out;
3529
3530 ret = wlcore_cmd_regdomain_config_locked(wl);
3531 if (ret < 0) {
3532 wl12xx_queue_recovery_work(wl);
3533 goto out;
3534 }
3535
3536 wl1271_ps_elp_sleep(wl);
3537out:
3538 mutex_unlock(&wl->mutex);
3539}
3540
f5fc0f86 3541static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
a060bbfe 3542 struct ieee80211_vif *vif,
f5fc0f86
LC		 3543 struct cfg80211_scan_request *req)
3544{
3545 struct wl1271 *wl = hw->priv;
3546 int ret;
3547 u8 *ssid = NULL;
abb0b3bf 3548 size_t len = 0;
f5fc0f86
LC		 3549
3550 wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3551
3552 if (req->n_ssids) {
3553 ssid = req->ssids[0].ssid;
abb0b3bf 3554 len = req->ssids[0].ssid_len;
f5fc0f86
LC		 3555 }
3556
3557 mutex_lock(&wl->mutex);
3558
4cc53383 3559 if (unlikely(wl->state != WLCORE_STATE_ON)) {
b739a42c
JO		 3560 /*
3561 * We cannot return -EBUSY here because cfg80211 will expect
3562 * a call to ieee80211_scan_completed if we do - in this case
3563 * there won't be any call.
3564 */
3565 ret = -EAGAIN;
3566 goto out;
3567 }
3568
a620865e 3569 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 3570 if (ret < 0)
3571 goto out;
3572
97fd311a
EP		 3573 /* fail if there is any role in ROC */
3574 if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
92e712da
EP		 3575 /* don't allow scanning right now */
3576 ret = -EBUSY;
3577 goto out_sleep;
3578 }
3579
78e28062 3580 ret = wlcore_scan(hw->priv, vif, ssid, len, req);
251c177f 3581out_sleep:
f5fc0f86 3582 wl1271_ps_elp_sleep(wl);
f5fc0f86
LC		 3583out:
3584 mutex_unlock(&wl->mutex);
3585
3586 return ret;
3587}
3588
73ecce31
EP		 3589static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3590 struct ieee80211_vif *vif)
3591{
3592 struct wl1271 *wl = hw->priv;
78e28062 3593 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
73ecce31
EP		 3594 int ret;
3595
3596 wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3597
3598 mutex_lock(&wl->mutex);
3599
4cc53383 3600 if (unlikely(wl->state != WLCORE_STATE_ON))
73ecce31
EP		 3601 goto out;
3602
3603 if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3604 goto out;
3605
3606 ret = wl1271_ps_elp_wakeup(wl);
3607 if (ret < 0)
3608 goto out;
3609
3610 if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
78e28062 3611 ret = wl->ops->scan_stop(wl, wlvif);
73ecce31
EP		 3612 if (ret < 0)
3613 goto out_sleep;
3614 }
55df5afb
AN		 3615
3616 /*
3617 * Rearm the tx watchdog just before idling scan. This
3618 * prevents just-finished scans from triggering the watchdog
3619 */
3620 wl12xx_rearm_tx_watchdog_locked(wl);
3621
73ecce31
EP		 3622 wl->scan.state = WL1271_SCAN_STATE_IDLE;
3623 memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
c50a2825 3624 wl->scan_wlvif = NULL;
73ecce31
EP		 3625 wl->scan.req = NULL;
3626 ieee80211_scan_completed(wl->hw, true);
3627
3628out_sleep:
3629 wl1271_ps_elp_sleep(wl);
3630out:
3631 mutex_unlock(&wl->mutex);
3632
3633 cancel_delayed_work_sync(&wl->scan_complete_work);
3634}
3635
33c2c06c
LC		 3636static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3637 struct ieee80211_vif *vif,
3638 struct cfg80211_sched_scan_request *req,
3639 struct ieee80211_sched_scan_ies *ies)
3640{
3641 struct wl1271 *wl = hw->priv;
536129c8 3642 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
33c2c06c
LC		 3643 int ret;
3644
3645 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3646
3647 mutex_lock(&wl->mutex);
3648
4cc53383 3649 if (unlikely(wl->state != WLCORE_STATE_ON)) {
9e0dc890
PF		 3650 ret = -EAGAIN;
3651 goto out;
3652 }
3653
33c2c06c
LC		 3654 ret = wl1271_ps_elp_wakeup(wl);
3655 if (ret < 0)
3656 goto out;
3657
78e28062 3658 ret = wl->ops->sched_scan_start(wl, wlvif, req, ies);
33c2c06c
LC		 3659 if (ret < 0)
3660 goto out_sleep;
3661
10199756 3662 wl->sched_vif = wlvif;
33c2c06c
LC		 3663
3664out_sleep:
3665 wl1271_ps_elp_sleep(wl);
3666out:
3667 mutex_unlock(&wl->mutex);
3668 return ret;
3669}
3670
3671static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3672 struct ieee80211_vif *vif)
3673{
3674 struct wl1271 *wl = hw->priv;
78f85f50 3675 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
33c2c06c
LC		 3676 int ret;
3677
3678 wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3679
3680 mutex_lock(&wl->mutex);
3681
4cc53383 3682 if (unlikely(wl->state != WLCORE_STATE_ON))
9e0dc890
PF		 3683 goto out;
3684
33c2c06c
LC		 3685 ret = wl1271_ps_elp_wakeup(wl);
3686 if (ret < 0)
3687 goto out;
3688
78e28062 3689 wl->ops->sched_scan_stop(wl, wlvif);
33c2c06c
LC		 3690
3691 wl1271_ps_elp_sleep(wl);
3692out:
3693 mutex_unlock(&wl->mutex);
3694}
3695
68d069c4
AN		 3696static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3697{
3698 struct wl1271 *wl = hw->priv;
3699 int ret = 0;
3700
3701 mutex_lock(&wl->mutex);
3702
4cc53383 3703 if (unlikely(wl->state != WLCORE_STATE_ON)) {
68d069c4
AN		 3704 ret = -EAGAIN;
3705 goto out;
3706 }
3707
a620865e 3708 ret = wl1271_ps_elp_wakeup(wl);
68d069c4
AN		 3709 if (ret < 0)
3710 goto out;
3711
5f704d18 3712 ret = wl1271_acx_frag_threshold(wl, value);
68d069c4
AN		 3713 if (ret < 0)
3714 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3715
3716 wl1271_ps_elp_sleep(wl);
3717
3718out:
3719 mutex_unlock(&wl->mutex);
3720
3721 return ret;
3722}
3723
f5fc0f86
LC		 3724static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3725{
3726 struct wl1271 *wl = hw->priv;
6e8cd331 3727 struct wl12xx_vif *wlvif;
aecb0565 3728 int ret = 0;
f5fc0f86
LC		 3729
3730 mutex_lock(&wl->mutex);
3731
4cc53383 3732 if (unlikely(wl->state != WLCORE_STATE_ON)) {
f8d9802f 3733 ret = -EAGAIN;
aecb0565 3734 goto out;
f8d9802f 3735 }
aecb0565 3736
a620865e 3737 ret = wl1271_ps_elp_wakeup(wl);
f5fc0f86
LC		 3738 if (ret < 0)
3739 goto out;
3740
6e8cd331
EP		 3741 wl12xx_for_each_wlvif(wl, wlvif) {
3742 ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3743 if (ret < 0)
3744 wl1271_warning("set rts threshold failed: %d", ret);
3745 }
f5fc0f86
LC		 3746 wl1271_ps_elp_sleep(wl);
3747
3748out:
3749 mutex_unlock(&wl->mutex);
3750
3751 return ret;
3752}
3753
d48055d9
EP		 3754static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3755{
3756 int len;
3757 const u8 *next, *end = skb->data + skb->len;
3758 u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3759 skb->len - ieoffset);
3760 if (!ie)
3761 return;
3762 len = ie[1] + 2;
3763 next = ie + len;
3764 memmove(ie, next, end - next);
3765 skb_trim(skb, skb->len - len);
3766}
3767
26b4bf2e
EP		 3768static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3769 unsigned int oui, u8 oui_type,
3770 int ieoffset)
3771{
3772 int len;
3773 const u8 *next, *end = skb->data + skb->len;
3774 u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3775 skb->data + ieoffset,
3776 skb->len - ieoffset);
3777 if (!ie)
3778 return;
3779 len = ie[1] + 2;
3780 next = ie + len;
3781 memmove(ie, next, end - next);
3782 skb_trim(skb, skb->len - len);
3783}
3784
341f2c11
AN		 3785static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3786 struct ieee80211_vif *vif)
560f0024 3787{
cdaac628 3788 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
560f0024
AN		 3789 struct sk_buff *skb;
3790 int ret;
3791
341f2c11 3792 skb = ieee80211_proberesp_get(wl->hw, vif);
560f0024 3793 if (!skb)
341f2c11 3794 return -EOPNOTSUPP;
560f0024 3795
cdaac628 3796 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
560f0024
AN		 3797 CMD_TEMPL_AP_PROBE_RESPONSE,
3798 skb->data,
3799 skb->len, 0,
3800 rates);
560f0024 3801 dev_kfree_skb(skb);
62c2e579
LC		 3802
3803 if (ret < 0)
3804 goto out;
3805
3806 wl1271_debug(DEBUG_AP, "probe response updated");
3807 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3808
3809out:
560f0024
AN		 3810 return ret;
3811}
3812
3813static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3814 struct ieee80211_vif *vif,
3815 u8 *probe_rsp_data,
3816 size_t probe_rsp_len,
3817 u32 rates)
68eaaf6e 3818{
1fe9f161
EP		 3819 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3820 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
68eaaf6e
AN		 3821 u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3822 int ssid_ie_offset, ie_offset, templ_len;
3823 const u8 *ptr;
3824
3825 /* no need to change probe response if the SSID is set correctly */
1fe9f161 3826 if (wlvif->ssid_len > 0)
cdaac628 3827 return wl1271_cmd_template_set(wl, wlvif->role_id,
68eaaf6e
AN		 3828 CMD_TEMPL_AP_PROBE_RESPONSE,
3829 probe_rsp_data,
3830 probe_rsp_len, 0,
3831 rates);
3832
3833 if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3834 wl1271_error("probe_rsp template too big");
3835 return -EINVAL;
3836 }
3837
3838 /* start searching from IE offset */
3839 ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3840
3841 ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3842 probe_rsp_len - ie_offset);
3843 if (!ptr) {
3844 wl1271_error("No SSID in beacon!");
3845 return -EINVAL;
3846 }
3847
3848 ssid_ie_offset = ptr - probe_rsp_data;
3849 ptr += (ptr[1] + 2);
3850
3851 memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3852
3853 /* insert SSID from bss_conf */
3854 probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3855 probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
3856 memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3857 bss_conf->ssid, bss_conf->ssid_len);
3858 templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;
3859
3860 memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
3861 ptr, probe_rsp_len - (ptr - probe_rsp_data));
3862 templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3863
cdaac628 3864 return wl1271_cmd_template_set(wl, wlvif->role_id,
68eaaf6e
AN		 3865 CMD_TEMPL_AP_PROBE_RESPONSE,
3866 probe_rsp_templ,
3867 templ_len, 0,
3868 rates);
3869}
3870
e78a287a 3871static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
0603d891 3872 struct ieee80211_vif *vif,
f5fc0f86
LC		 3873 struct ieee80211_bss_conf *bss_conf,
3874 u32 changed)
3875{
0603d891 3876 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 3877 int ret = 0;
f5fc0f86 3878
e78a287a
AN		 3879 if (changed & BSS_CHANGED_ERP_SLOT) {
3880 if (bss_conf->use_short_slot)
0603d891 3881 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
e78a287a 3882 else
0603d891 3883 ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
e78a287a
AN		 3884 if (ret < 0) {
3885 wl1271_warning("Set slot time failed %d", ret);
3886 goto out;
3887 }
3888 }
f5fc0f86 3889
e78a287a
AN		 3890 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3891 if (bss_conf->use_short_preamble)
0603d891 3892 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
e78a287a 3893 else
0603d891 3894 wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
e78a287a 3895 }
f5fc0f86 3896
e78a287a
AN		 3897 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3898 if (bss_conf->use_cts_prot)
0603d891
EP		 3899 ret = wl1271_acx_cts_protect(wl, wlvif,
3900 CTSPROTECT_ENABLE);
e78a287a 3901 else
0603d891
EP		 3902 ret = wl1271_acx_cts_protect(wl, wlvif,
3903 CTSPROTECT_DISABLE);
e78a287a
AN		 3904 if (ret < 0) {
3905 wl1271_warning("Set ctsprotect failed %d", ret);
3906 goto out;
3907 }
3908 }
f8d9802f 3909
e78a287a
AN		 3910out:
3911 return ret;
3912}
f5fc0f86 3913
62c2e579
LC		 3914static int wlcore_set_beacon_template(struct wl1271 *wl,
3915 struct ieee80211_vif *vif,
3916 bool is_ap)
3917{
3918 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3919 struct ieee80211_hdr *hdr;
3920 u32 min_rate;
3921 int ret;
8f6ac537 3922 int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
62c2e579
LC		 3923 struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
3924 u16 tmpl_id;
3925
3926 if (!beacon) {
3927 ret = -EINVAL;
3928 goto out;
3929 }
3930
3931 wl1271_debug(DEBUG_MASTER, "beacon updated");
3932
3230f35e 3933 ret = wl1271_ssid_set(wlvif, beacon, ieoffset);
62c2e579
LC		 3934 if (ret < 0) {
3935 dev_kfree_skb(beacon);
3936 goto out;
3937 }
3938 min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3939 tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
3940 CMD_TEMPL_BEACON;
3941 ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
3942 beacon->data,
3943 beacon->len, 0,
3944 min_rate);
3945 if (ret < 0) {
3946 dev_kfree_skb(beacon);
3947 goto out;
3948 }
3949
d50529c0
EP		 3950 wlvif->wmm_enabled =
3951 cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
3952 WLAN_OUI_TYPE_MICROSOFT_WMM,
3953 beacon->data + ieoffset,
3954 beacon->len - ieoffset);
3955
62c2e579
LC		 3956 /*
3957 * In case we already have a probe-resp beacon set explicitly
3958 * by usermode, don't use the beacon data.
3959 */
3960 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
3961 goto end_bcn;
3962
3963 /* remove TIM ie from probe response */
3964 wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
3965
3966 /*
3967 * remove p2p ie from probe response.
3968 * the fw reponds to probe requests that don't include
3969 * the p2p ie. probe requests with p2p ie will be passed,
3970 * and will be responded by the supplicant (the spec
3971 * forbids including the p2p ie when responding to probe
3972 * requests that didn't include it).
3973 */
3974 wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
3975 WLAN_OUI_TYPE_WFA_P2P, ieoffset);
3976
3977 hdr = (struct ieee80211_hdr *) beacon->data;
3978 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3979 IEEE80211_STYPE_PROBE_RESP);
3980 if (is_ap)
3981 ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3982 beacon->data,
3983 beacon->len,
3984 min_rate);
3985 else
3986 ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3987 CMD_TEMPL_PROBE_RESPONSE,
3988 beacon->data,
3989 beacon->len, 0,
3990 min_rate);
3991end_bcn:
3992 dev_kfree_skb(beacon);
3993 if (ret < 0)
3994 goto out;
3995
3996out:
3997 return ret;
3998}
3999
e78a287a
AN		 4000static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
4001 struct ieee80211_vif *vif,
4002 struct ieee80211_bss_conf *bss_conf,
4003 u32 changed)
4004{
87fbcb0f 4005 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
536129c8 4006 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 4007 int ret = 0;
4008
48af2eb0 4009 if (changed & BSS_CHANGED_BEACON_INT) {
e78a287a 4010 wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
60e84c2e
JO		 4011 bss_conf->beacon_int);
4012
6a899796 4013 wlvif->beacon_int = bss_conf->beacon_int;
60e84c2e
JO		 4014 }
4015
560f0024
AN		 4016 if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
4017 u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
62c2e579
LC		 4018
4019 wl1271_ap_set_probe_resp_tmpl(wl, rate, vif);
560f0024
AN		 4020 }
4021
48af2eb0 4022 if (changed & BSS_CHANGED_BEACON) {
62c2e579 4023 ret = wlcore_set_beacon_template(wl, vif, is_ap);
e78a287a
AN		 4024 if (ret < 0)
4025 goto out;
4026 }
4027
4028out:
560f0024
AN		 4029 if (ret != 0)
4030 wl1271_error("beacon info change failed: %d", ret);
e78a287a
AN		 4031 return ret;
4032}
4033
4034/* AP mode changes */
4035static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
4036 struct ieee80211_vif *vif,
4037 struct ieee80211_bss_conf *bss_conf,
4038 u32 changed)
4039{
87fbcb0f 4040 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
e78a287a 4041 int ret = 0;
e0d8bbf0 4042
b6970ee5 4043 if (changed & BSS_CHANGED_BASIC_RATES) {
e78a287a 4044 u32 rates = bss_conf->basic_rates;
5da11dcd 4045
87fbcb0f 4046 wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 4047 wlvif->band);
d2d66c56 4048 wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
87fbcb0f 4049 wlvif->basic_rate_set);
70f47424 4050
87fbcb0f 4051 ret = wl1271_init_ap_rates(wl, wlvif);
e78a287a 4052 if (ret < 0) {
70f47424 4053 wl1271_error("AP rate policy change failed %d", ret);
e78a287a
AN		 4054 goto out;
4055 }
c45a85b5 4056
784f694d 4057 ret = wl1271_ap_init_templates(wl, vif);
c45a85b5
AN		 4058 if (ret < 0)
4059 goto out;
62c2e579
LC		 4060
4061 ret = wl1271_ap_set_probe_resp_tmpl(wl, wlvif->basic_rate, vif);
4062 if (ret < 0)
4063 goto out;
4064
4065 ret = wlcore_set_beacon_template(wl, vif, true);
4066 if (ret < 0)
4067 goto out;
e78a287a 4068 }
2f6724b2 4069
e78a287a
AN		 4070 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
4071 if (ret < 0)
4072 goto out;
30240fc7 4073
48af2eb0 4074 if (changed & BSS_CHANGED_BEACON_ENABLED) {
e78a287a 4075 if (bss_conf->enable_beacon) {
53d40d0b 4076 if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
87fbcb0f 4077 ret = wl12xx_cmd_role_start_ap(wl, wlvif);
e78a287a
AN		 4078 if (ret < 0)
4079 goto out;
e0d8bbf0 4080
a8ab39a4 4081 ret = wl1271_ap_init_hwenc(wl, wlvif);
7f179b46
AN		 4082 if (ret < 0)
4083 goto out;
cf42039f 4084
53d40d0b 4085 set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
cf42039f 4086 wl1271_debug(DEBUG_AP, "started AP");
e0d8bbf0 4087 }
e78a287a 4088 } else {
53d40d0b 4089 if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
187e52cc
AN		 4090 /*
4091 * AP might be in ROC in case we have just
4092 * sent auth reply. handle it.
4093 */
4094 if (test_bit(wlvif->role_id, wl->roc_map))
4095 wl12xx_croc(wl, wlvif->role_id);
4096
0603d891 4097 ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
e78a287a
AN		 4098 if (ret < 0)
4099 goto out;
e0d8bbf0 4100
53d40d0b 4101 clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
560f0024
AN		 4102 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
4103 &wlvif->flags);
e78a287a
AN		 4104 wl1271_debug(DEBUG_AP, "stopped AP");
4105 }
4106 }
4107 }
e0d8bbf0 4108
0603d891 4109 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 4110 if (ret < 0)
4111 goto out;
0b932ab9
AN		 4112
4113 /* Handle HT information change */
4114 if ((changed & BSS_CHANGED_HT) &&
4bf88530 4115 (bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT)) {
0603d891 4116 ret = wl1271_acx_set_ht_information(wl, wlvif,
0b932ab9
AN		 4117 bss_conf->ht_operation_mode);
4118 if (ret < 0) {
4119 wl1271_warning("Set ht information failed %d", ret);
4120 goto out;
4121 }
4122 }
4123
e78a287a
AN		 4124out:
4125 return;
4126}
8bf29b0e 4127
3230f35e
EP		 4128static int wlcore_set_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
4129 struct ieee80211_bss_conf *bss_conf,
4130 u32 sta_rate_set)
4131{
4132 u32 rates;
4133 int ret;
4134
4135 wl1271_debug(DEBUG_MAC80211,
4136 "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
4137 bss_conf->bssid, bss_conf->aid,
4138 bss_conf->beacon_int,
4139 bss_conf->basic_rates, sta_rate_set);
4140
4141 wlvif->beacon_int = bss_conf->beacon_int;
4142 rates = bss_conf->basic_rates;
4143 wlvif->basic_rate_set =
4144 wl1271_tx_enabled_rates_get(wl, rates,
4145 wlvif->band);
4146 wlvif->basic_rate =
4147 wl1271_tx_min_rate_get(wl,
4148 wlvif->basic_rate_set);
4149
4150 if (sta_rate_set)
4151 wlvif->rate_set =
4152 wl1271_tx_enabled_rates_get(wl,
4153 sta_rate_set,
4154 wlvif->band);
4155
4156 /* we only support sched_scan while not connected */
10199756 4157 if (wl->sched_vif == wlvif)
78e28062 4158 wl->ops->sched_scan_stop(wl, wlvif);
3230f35e
EP		 4159
4160 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4161 if (ret < 0)
4162 return ret;
4163
4164 ret = wl12xx_cmd_build_null_data(wl, wlvif);
4165 if (ret < 0)
4166 return ret;
4167
4168 ret = wl1271_build_qos_null_data(wl, wl12xx_wlvif_to_vif(wlvif));
4169 if (ret < 0)
4170 return ret;
4171
4172 wlcore_set_ssid(wl, wlvif);
4173
4174 set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4175
4176 return 0;
4177}
4178
4179static int wlcore_clear_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
4180{
4181 int ret;
4182
4183 /* revert back to minimum rates for the current band */
4184 wl1271_set_band_rate(wl, wlvif);
4185 wlvif->basic_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4186
4187 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4188 if (ret < 0)
4189 return ret;
4190
4191 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4192 test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) {
4193 ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
4194 if (ret < 0)
4195 return ret;
4196 }
4197
4198 clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4199 return 0;
4200}
e78a287a
AN		 4201/* STA/IBSS mode changes */
4202static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
4203 struct ieee80211_vif *vif,
4204 struct ieee80211_bss_conf *bss_conf,
4205 u32 changed)
4206{
87fbcb0f 4207 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3230f35e 4208 bool do_join = false;
536129c8 4209 bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
227e81e1 4210 bool ibss_joined = false;
72c2d9e5 4211 u32 sta_rate_set = 0;
e78a287a 4212 int ret;
2d6e4e76 4213 struct ieee80211_sta *sta;
a100885d
AN		 4214 bool sta_exists = false;
4215 struct ieee80211_sta_ht_cap sta_ht_cap;
e78a287a
AN		 4216
4217 if (is_ibss) {
4218 ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
4219 changed);
4220 if (ret < 0)
4221 goto out;
e0d8bbf0
JO		 4222 }
4223
227e81e1
EP		 4224 if (changed & BSS_CHANGED_IBSS) {
4225 if (bss_conf->ibss_joined) {
eee514e3 4226 set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
227e81e1
EP		 4227 ibss_joined = true;
4228 } else {
3230f35e
EP		 4229 wlcore_unset_assoc(wl, wlvif);
4230 wl12xx_cmd_role_stop_sta(wl, wlvif);
227e81e1
EP		 4231 }
4232 }
4233
4234 if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
e78a287a
AN		 4235 do_join = true;
4236
4237 /* Need to update the SSID (for filtering etc) */
227e81e1 4238 if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
e78a287a
AN		 4239 do_join = true;
4240
227e81e1 4241 if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
5da11dcd
JO		 4242 wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
4243 bss_conf->enable_beacon ? "enabled" : "disabled");
4244
5da11dcd
JO		 4245 do_join = true;
4246 }
4247
b0ed8a4d
AN		 4248 if (changed & BSS_CHANGED_IDLE && !is_ibss)
4249 wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
4250
48af2eb0 4251 if (changed & BSS_CHANGED_CQM) {
00236aed
JO		 4252 bool enable = false;
4253 if (bss_conf->cqm_rssi_thold)
4254 enable = true;
0603d891 4255 ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
00236aed
JO		 4256 bss_conf->cqm_rssi_thold,
4257 bss_conf->cqm_rssi_hyst);
4258 if (ret < 0)
4259 goto out;
04324d99 4260 wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
00236aed
JO		 4261 }
4262
ec87011a
EP		 4263 if (changed & (BSS_CHANGED_BSSID | BSS_CHANGED_HT |
4264 BSS_CHANGED_ASSOC)) {
0f9c8250
AN		 4265 rcu_read_lock();
4266 sta = ieee80211_find_sta(vif, bss_conf->bssid);
ef08d028
LC		 4267 if (sta) {
4268 u8 *rx_mask = sta->ht_cap.mcs.rx_mask;
4269
4270 /* save the supp_rates of the ap */
4271 sta_rate_set = sta->supp_rates[wlvif->band];
4272 if (sta->ht_cap.ht_supported)
4273 sta_rate_set |=
4274 (rx_mask[0] << HW_HT_RATES_OFFSET) |
4275 (rx_mask[1] << HW_MIMO_RATES_OFFSET);
4276 sta_ht_cap = sta->ht_cap;
4277 sta_exists = true;
4278 }
4279
0f9c8250 4280 rcu_read_unlock();
72c2d9e5 4281 }
72c2d9e5 4282
3230f35e
EP		 4283 if (changed & BSS_CHANGED_BSSID) {
4284 if (!is_zero_ether_addr(bss_conf->bssid)) {
4285 ret = wlcore_set_bssid(wl, wlvif, bss_conf,
4286 sta_rate_set);
f5fc0f86 4287 if (ret < 0)
e78a287a 4288 goto out;
f5fc0f86 4289
3230f35e
EP		 4290 /* Need to update the BSSID (for filtering etc) */
4291 do_join = true;
d94cd297 4292 } else {
3230f35e 4293 ret = wlcore_clear_bssid(wl, wlvif);
6ccbb92e 4294 if (ret < 0)
e78a287a 4295 goto out;
f5fc0f86 4296 }
f5fc0f86
LC		 4297 }
4298
d192d268
EP		 4299 if (changed & BSS_CHANGED_IBSS) {
4300 wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
4301 bss_conf->ibss_joined);
4302
4303 if (bss_conf->ibss_joined) {
4304 u32 rates = bss_conf->basic_rates;
87fbcb0f 4305 wlvif->basic_rate_set =
af7fbb28 4306 wl1271_tx_enabled_rates_get(wl, rates,
1b92f15e 4307 wlvif->band);
d2d66c56 4308 wlvif->basic_rate =
87fbcb0f
EP		 4309 wl1271_tx_min_rate_get(wl,
4310 wlvif->basic_rate_set);
d192d268 4311
06b660e1 4312 /* by default, use 11b + OFDM rates */
30d0c8fd
EP		 4313 wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
4314 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
d192d268
EP		 4315 if (ret < 0)
4316 goto out;
4317 }
4318 }
4319
d881fa2c
EP		 4320 if ((changed & BSS_CHANGED_BEACON_INFO) && bss_conf->dtim_period) {
4321 /* enable beacon filtering */
4322 ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
4323 if (ret < 0)
4324 goto out;
4325 }
4326
0603d891 4327 ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
e78a287a
AN		 4328 if (ret < 0)
4329 goto out;
f5fc0f86 4330
8bf29b0e 4331 if (do_join) {
3230f35e 4332 ret = wlcore_join(wl, wlvif);
8bf29b0e
JO		 4333 if (ret < 0) {
4334 wl1271_warning("cmd join failed %d", ret);
e78a287a 4335 goto out;
8bf29b0e 4336 }
3230f35e 4337 }
251c177f 4338
3230f35e
EP		 4339 if (changed & BSS_CHANGED_ASSOC) {
4340 if (bss_conf->assoc) {
ec87011a
EP		 4341 ret = wlcore_set_assoc(wl, wlvif, bss_conf,
4342 sta_rate_set);
251c177f
EP		 4343 if (ret < 0)
4344 goto out;
4345
9fd6f21b
EP		 4346 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
4347 wl12xx_set_authorized(wl, wlvif);
3230f35e
EP		 4348 } else {
4349 wlcore_unset_assoc(wl, wlvif);
251c177f 4350 }
c1899554
JO		 4351 }
4352
518b680a
EP		 4353 if (changed & BSS_CHANGED_PS) {
4354 if ((bss_conf->ps) &&
4355 test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
4356 !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4357 int ps_mode;
4358 char *ps_mode_str;
4359
4360 if (wl->conf.conn.forced_ps) {
4361 ps_mode = STATION_POWER_SAVE_MODE;
4362 ps_mode_str = "forced";
4363 } else {
4364 ps_mode = STATION_AUTO_PS_MODE;
4365 ps_mode_str = "auto";
4366 }
4367
4368 wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
4369
4370 ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
251c177f 4371 if (ret < 0)
518b680a
EP		 4372 wl1271_warning("enter %s ps failed %d",
4373 ps_mode_str, ret);
4374 } else if (!bss_conf->ps &&
4375 test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4376 wl1271_debug(DEBUG_PSM, "auto ps disabled");
4377
4378 ret = wl1271_ps_set_mode(wl, wlvif,
4379 STATION_ACTIVE_MODE);
4380 if (ret < 0)
4381 wl1271_warning("exit auto ps failed %d", ret);
251c177f 4382 }
c1899554
JO		 4383 }
4384
0b932ab9 4385 /* Handle new association with HT. Do this after join. */
6f0b1bb2 4386 if (sta_exists) {
58321b29 4387 bool enabled =
aaabee8b 4388 bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT;
58321b29 4389
530abe19
EP		 4390 ret = wlcore_hw_set_peer_cap(wl,
4391 &sta_ht_cap,
4392 enabled,
4393 wlvif->rate_set,
4394 wlvif->sta.hlid);
58321b29
EP		 4395 if (ret < 0) {
4396 wl1271_warning("Set ht cap failed %d", ret);
4397 goto out;
4398
0f9c8250 4399 }
58321b29
EP		 4400
4401 if (enabled) {
4402 ret = wl1271_acx_set_ht_information(wl, wlvif,
4403 bss_conf->ht_operation_mode);
0f9c8250 4404 if (ret < 0) {
58321b29 4405 wl1271_warning("Set ht information failed %d",
0f9c8250
AN		 4406 ret);
4407 goto out;
4408 }
4409 }
4410 }
4411
76a74c8a
EP		 4412 /* Handle arp filtering. Done after join. */
4413 if ((changed & BSS_CHANGED_ARP_FILTER) ||
4414 (!is_ibss && (changed & BSS_CHANGED_QOS))) {
4415 __be32 addr = bss_conf->arp_addr_list[0];
4416 wlvif->sta.qos = bss_conf->qos;
4417 WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
4418
0f19b41e 4419 if (bss_conf->arp_addr_cnt == 1 && bss_conf->assoc) {
76a74c8a
EP		 4420 wlvif->ip_addr = addr;
4421 /*
4422 * The template should have been configured only upon
4423 * association. however, it seems that the correct ip
4424 * isn't being set (when sending), so we have to
4425 * reconfigure the template upon every ip change.
4426 */
4427 ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
4428 if (ret < 0) {
4429 wl1271_warning("build arp rsp failed: %d", ret);
4430 goto out;
4431 }
4432
4433 ret = wl1271_acx_arp_ip_filter(wl, wlvif,
4434 (ACX_ARP_FILTER_ARP_FILTERING |
4435 ACX_ARP_FILTER_AUTO_ARP),
4436 addr);
4437 } else {
4438 wlvif->ip_addr = 0;
4439 ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
4440 }
4441
4442 if (ret < 0)
4443 goto out;
4444 }
4445
e78a287a
AN		 4446out:
4447 return;
4448}
4449
4450static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
4451 struct ieee80211_vif *vif,
4452 struct ieee80211_bss_conf *bss_conf,
4453 u32 changed)
4454{
4455 struct wl1271 *wl = hw->priv;
536129c8
EP		 4456 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4457 bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
e78a287a
AN		 4458 int ret;
4459
d3f5a1b5
EP		 4460 wl1271_debug(DEBUG_MAC80211, "mac80211 bss info role %d changed 0x%x",
4461 wlvif->role_id, (int)changed);
e78a287a 4462
6b8bf5bc
AN		 4463 /*
4464 * make sure to cancel pending disconnections if our association
4465 * state changed
4466 */
4467 if (!is_ap && (changed & BSS_CHANGED_ASSOC))
c50a2825 4468 cancel_delayed_work_sync(&wlvif->connection_loss_work);
6b8bf5bc 4469
b515d83a
EP		 4470 if (is_ap && (changed & BSS_CHANGED_BEACON_ENABLED) &&
4471 !bss_conf->enable_beacon)
4472 wl1271_tx_flush(wl);
4473
e78a287a
AN		 4474 mutex_lock(&wl->mutex);
4475
4cc53383 4476 if (unlikely(wl->state != WLCORE_STATE_ON))
e78a287a
AN		 4477 goto out;
4478
10c8cd01
EP		 4479 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4480 goto out;
4481
a620865e 4482 ret = wl1271_ps_elp_wakeup(wl);
e78a287a
AN		 4483 if (ret < 0)
4484 goto out;
4485
b30d49b2
AG		 4486 if ((changed & BSS_CHANGED_TXPOWER) &&
4487 bss_conf->txpower != wlvif->power_level) {
4488
4489 ret = wl1271_acx_tx_power(wl, wlvif, bss_conf->txpower);
4490 if (ret < 0)
4491 goto out;
4492
4493 wlvif->power_level = bss_conf->txpower;
4494 }
4495
e78a287a
AN		 4496 if (is_ap)
4497 wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
4498 else
4499 wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
4500
f5fc0f86
LC		 4501 wl1271_ps_elp_sleep(wl);
4502
4503out:
4504 mutex_unlock(&wl->mutex);
4505}
4506
b6970ee5
EP		 4507static int wlcore_op_add_chanctx(struct ieee80211_hw *hw,
4508 struct ieee80211_chanctx_conf *ctx)
4509{
4510 wl1271_debug(DEBUG_MAC80211, "mac80211 add chanctx %d (type %d)",
aaabee8b
LC		 4511 ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4512 cfg80211_get_chandef_type(&ctx->def));
b6970ee5
EP		 4513 return 0;
4514}
4515
4516static void wlcore_op_remove_chanctx(struct ieee80211_hw *hw,
4517 struct ieee80211_chanctx_conf *ctx)
4518{
4519 wl1271_debug(DEBUG_MAC80211, "mac80211 remove chanctx %d (type %d)",
aaabee8b
LC		 4520 ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4521 cfg80211_get_chandef_type(&ctx->def));
b6970ee5
EP		 4522}
4523
4524static void wlcore_op_change_chanctx(struct ieee80211_hw *hw,
4525 struct ieee80211_chanctx_conf *ctx,
4526 u32 changed)
4527{
4528 wl1271_debug(DEBUG_MAC80211,
4529 "mac80211 change chanctx %d (type %d) changed 0x%x",
aaabee8b
LC		 4530 ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4531 cfg80211_get_chandef_type(&ctx->def), changed);
b6970ee5
EP		 4532}
4533
4534static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw *hw,
4535 struct ieee80211_vif *vif,
4536 struct ieee80211_chanctx_conf *ctx)
4537{
4538 struct wl1271 *wl = hw->priv;
4539 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4540 int channel = ieee80211_frequency_to_channel(
aaabee8b 4541 ctx->def.chan->center_freq);
b6970ee5
EP		 4542
4543 wl1271_debug(DEBUG_MAC80211,
4544 "mac80211 assign chanctx (role %d) %d (type %d)",
aaabee8b 4545 wlvif->role_id, channel, cfg80211_get_chandef_type(&ctx->def));
b6970ee5
EP		 4546
4547 mutex_lock(&wl->mutex);
4548
aaabee8b 4549 wlvif->band = ctx->def.chan->band;
b6970ee5 4550 wlvif->channel = channel;
aaabee8b 4551 wlvif->channel_type = cfg80211_get_chandef_type(&ctx->def);
b6970ee5
EP		 4552
4553 /* update default rates according to the band */
4554 wl1271_set_band_rate(wl, wlvif);
4555
4556 mutex_unlock(&wl->mutex);
4557
4558 return 0;
4559}
4560
4561static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
4562 struct ieee80211_vif *vif,
4563 struct ieee80211_chanctx_conf *ctx)
4564{
4565 struct wl1271 *wl = hw->priv;
4566 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4567
4568 wl1271_debug(DEBUG_MAC80211,
4569 "mac80211 unassign chanctx (role %d) %d (type %d)",
4570 wlvif->role_id,
aaabee8b
LC		 4571 ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4572 cfg80211_get_chandef_type(&ctx->def));
b6970ee5
EP		 4573
4574 wl1271_tx_flush(wl);
4575}
4576
8a3a3c85
EP		 4577static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
4578 struct ieee80211_vif *vif, u16 queue,
c6999d83
KV		 4579 const struct ieee80211_tx_queue_params *params)
4580{
4581 struct wl1271 *wl = hw->priv;
0603d891 4582 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4695dc91 4583 u8 ps_scheme;
488fc540 4584 int ret = 0;
c6999d83
KV		 4585
4586 mutex_lock(&wl->mutex);
4587
4588 wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
4589
4695dc91
KV		 4590 if (params->uapsd)
4591 ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
4592 else
4593 ps_scheme = CONF_PS_SCHEME_LEGACY;
4594
5b37ddfe 4595 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
c1b193eb 4596 goto out;
488fc540 4597
c1b193eb
EP		 4598 ret = wl1271_ps_elp_wakeup(wl);
4599 if (ret < 0)
4600 goto out;
488fc540 4601
c1b193eb
EP		 4602 /*
4603 * the txop is confed in units of 32us by the mac80211,
4604 * we need us
4605 */
0603d891 4606 ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4607 params->cw_min, params->cw_max,
4608 params->aifs, params->txop << 5);
4609 if (ret < 0)
4610 goto out_sleep;
4611
0603d891 4612 ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
c1b193eb
EP		 4613 CONF_CHANNEL_TYPE_EDCF,
4614 wl1271_tx_get_queue(queue),
4615 ps_scheme, CONF_ACK_POLICY_LEGACY,
4616 0, 0);
c82c1dde
KV		 4617
4618out_sleep:
c1b193eb 4619 wl1271_ps_elp_sleep(wl);
c6999d83
KV		 4620
4621out:
4622 mutex_unlock(&wl->mutex);
4623
4624 return ret;
4625}
4626
37a41b4a
EP		 4627static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4628 struct ieee80211_vif *vif)
bbbb538e
JO		 4629{
4630
4631 struct wl1271 *wl = hw->priv;
9c531149 4632 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
bbbb538e
JO		 4633 u64 mactime = ULLONG_MAX;
4634 int ret;
4635
4636 wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4637
4638 mutex_lock(&wl->mutex);
4639
4cc53383 4640 if (unlikely(wl->state != WLCORE_STATE_ON))
f8d9802f
JO		 4641 goto out;
4642
a620865e 4643 ret = wl1271_ps_elp_wakeup(wl);
bbbb538e
JO		 4644 if (ret < 0)
4645 goto out;
4646
9c531149 4647 ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
bbbb538e
JO		 4648 if (ret < 0)
4649 goto out_sleep;
4650
4651out_sleep:
4652 wl1271_ps_elp_sleep(wl);
4653
4654out:
4655 mutex_unlock(&wl->mutex);
4656 return mactime;
4657}
f5fc0f86 4658
ece550d0
JL		 4659static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4660 struct survey_info *survey)
4661{
ece550d0 4662 struct ieee80211_conf *conf = &hw->conf;
b739a42c 4663
ece550d0
JL		 4664 if (idx != 0)
4665 return -ENOENT;
b739a42c 4666
675a0b04 4667 survey->channel = conf->chandef.chan;
add779a0 4668 survey->filled = 0;
ece550d0
JL		 4669 return 0;
4670}
4671
409622ec 4672static int wl1271_allocate_sta(struct wl1271 *wl,
c7ffb902
EP		 4673 struct wl12xx_vif *wlvif,
4674 struct ieee80211_sta *sta)
f84f7d78
AN		 4675{
4676 struct wl1271_station *wl_sta;
c7ffb902 4677 int ret;
f84f7d78 4678
c7ffb902 4679
32f0fd5b 4680 if (wl->active_sta_count >= wl->max_ap_stations) {
f84f7d78
AN		 4681 wl1271_warning("could not allocate HLID - too much stations");
4682 return -EBUSY;
4683 }
4684
4685 wl_sta = (struct wl1271_station *)sta->drv_priv;
c7ffb902
EP		 4686 ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4687 if (ret < 0) {
4688 wl1271_warning("could not allocate HLID - too many links");
4689 return -EBUSY;
4690 }
4691
0e752df6
AN		 4692 /* use the previous security seq, if this is a recovery/resume */
4693 wl->links[wl_sta->hlid].total_freed_pkts = wl_sta->total_freed_pkts;
4694
c7ffb902 4695 set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
b622d992 4696 memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
da03209e 4697 wl->active_sta_count++;
f84f7d78
AN		 4698 return 0;
4699}
4700
c7ffb902 4701void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
f84f7d78 4702{
0e752df6
AN		 4703 struct wl1271_station *wl_sta;
4704 struct ieee80211_sta *sta;
4705 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4706
c7ffb902 4707 if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
f1acea9a
AN		 4708 return;
4709
c7ffb902 4710 clear_bit(hlid, wlvif->ap.sta_hlid_map);
b622d992
AN		 4711 __clear_bit(hlid, &wl->ap_ps_map);
4712 __clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
0e752df6
AN		 4713
4714 /*
4715 * save the last used PN in the private part of iee80211_sta,
4716 * in case of recovery/suspend
4717 */
4718 rcu_read_lock();
4719 sta = ieee80211_find_sta(vif, wl->links[hlid].addr);
4720 if (sta) {
4721 wl_sta = (void *)sta->drv_priv;
4722 wl_sta->total_freed_pkts = wl->links[hlid].total_freed_pkts;
4723
4724 /*
4725 * increment the initial seq number on recovery to account for
4726 * transmitted packets that we haven't yet got in the FW status
4727 */
4728 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
4729 wl_sta->total_freed_pkts +=
4730 WL1271_TX_SQN_POST_RECOVERY_PADDING;
4731 }
4732 rcu_read_unlock();
4733
c7ffb902 4734 wl12xx_free_link(wl, wlvif, &hlid);
da03209e 4735 wl->active_sta_count--;
55df5afb
AN		 4736
4737 /*
4738 * rearm the tx watchdog when the last STA is freed - give the FW a
4739 * chance to return STA-buffered packets before complaining.
4740 */
4741 if (wl->active_sta_count == 0)
4742 wl12xx_rearm_tx_watchdog_locked(wl);
f84f7d78
AN		 4743}
4744
2d6cf2b5
EP		 4745static int wl12xx_sta_add(struct wl1271 *wl,
4746 struct wl12xx_vif *wlvif,
4747 struct ieee80211_sta *sta)
f84f7d78 4748{
c7ffb902 4749 struct wl1271_station *wl_sta;
f84f7d78
AN		 4750 int ret = 0;
4751 u8 hlid;
4752
f84f7d78
AN		 4753 wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
4754
c7ffb902 4755 ret = wl1271_allocate_sta(wl, wlvif, sta);
f84f7d78 4756 if (ret < 0)
2d6cf2b5 4757 return ret;
f84f7d78 4758
c7ffb902
EP		 4759 wl_sta = (struct wl1271_station *)sta->drv_priv;
4760 hlid = wl_sta->hlid;
4761
1b92f15e 4762 ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
f84f7d78 4763 if (ret < 0)
2d6cf2b5 4764 wl1271_free_sta(wl, wlvif, hlid);
f84f7d78 4765
2d6cf2b5
EP		 4766 return ret;
4767}
b67476ef 4768
2d6cf2b5
EP		 4769static int wl12xx_sta_remove(struct wl1271 *wl,
4770 struct wl12xx_vif *wlvif,
4771 struct ieee80211_sta *sta)
4772{
4773 struct wl1271_station *wl_sta;
4774 int ret = 0, id;
0b932ab9 4775
2d6cf2b5
EP		 4776 wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
4777
4778 wl_sta = (struct wl1271_station *)sta->drv_priv;
4779 id = wl_sta->hlid;
4780 if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
4781 return -EINVAL;
f84f7d78 4782
028e7243 4783 ret = wl12xx_cmd_remove_peer(wl, wlvif, wl_sta->hlid);
409622ec 4784 if (ret < 0)
2d6cf2b5 4785 return ret;
409622ec 4786
2d6cf2b5 4787 wl1271_free_sta(wl, wlvif, wl_sta->hlid);
f84f7d78
AN		 4788 return ret;
4789}
4790
426001a6
EP		 4791static void wlcore_roc_if_possible(struct wl1271 *wl,
4792 struct wl12xx_vif *wlvif)
4793{
4794 if (find_first_bit(wl->roc_map,
4795 WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)
4796 return;
4797
4798 if (WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID))
4799 return;
4800
4801 wl12xx_roc(wl, wlvif, wlvif->role_id, wlvif->band, wlvif->channel);
4802}
4803
187e52cc
AN		 4804/*
4805 * when wl_sta is NULL, we treat this call as if coming from a
4806 * pending auth reply.
4807 * wl->mutex must be taken and the FW must be awake when the call
4808 * takes place.
4809 */
4810void wlcore_update_inconn_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif,
4811 struct wl1271_station *wl_sta, bool in_conn)
426001a6 4812{
187e52cc
AN		 4813 if (in_conn) {
4814 if (WARN_ON(wl_sta && wl_sta->in_connection))
426001a6 4815 return;
187e52cc
AN		 4816
4817 if (!wlvif->ap_pending_auth_reply &&
4818 !wlvif->inconn_count)
426001a6 4819 wlcore_roc_if_possible(wl, wlvif);
187e52cc
AN		 4820
4821 if (wl_sta) {
4822 wl_sta->in_connection = true;
4823 wlvif->inconn_count++;
4824 } else {
4825 wlvif->ap_pending_auth_reply = true;
4826 }
426001a6 4827 } else {
187e52cc 4828 if (wl_sta && !wl_sta->in_connection)
426001a6
EP		 4829 return;
4830
187e52cc 4831 if (WARN_ON(!wl_sta && !wlvif->ap_pending_auth_reply))
426001a6
EP		 4832 return;
4833
187e52cc
AN		 4834 if (WARN_ON(wl_sta && !wlvif->inconn_count))
4835 return;
4836
4837 if (wl_sta) {
4838 wl_sta->in_connection = false;
4839 wlvif->inconn_count--;
4840 } else {
4841 wlvif->ap_pending_auth_reply = false;
4842 }
4843
4844 if (!wlvif->inconn_count && !wlvif->ap_pending_auth_reply &&
4845 test_bit(wlvif->role_id, wl->roc_map))
4846 wl12xx_croc(wl, wlvif->role_id);
426001a6
EP		 4847 }
4848}
4849
2d6cf2b5
EP		 4850static int wl12xx_update_sta_state(struct wl1271 *wl,
4851 struct wl12xx_vif *wlvif,
4852 struct ieee80211_sta *sta,
4853 enum ieee80211_sta_state old_state,
4854 enum ieee80211_sta_state new_state)
f84f7d78 4855{
f84f7d78 4856 struct wl1271_station *wl_sta;
2d6cf2b5
EP		 4857 bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
4858 bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
4859 int ret;
f84f7d78 4860
2d6cf2b5 4861 wl_sta = (struct wl1271_station *)sta->drv_priv;
f84f7d78 4862
2d6cf2b5
EP		 4863 /* Add station (AP mode) */
4864 if (is_ap &&
4865 old_state == IEEE80211_STA_NOTEXIST &&
29936266
EP		 4866 new_state == IEEE80211_STA_NONE) {
4867 ret = wl12xx_sta_add(wl, wlvif, sta);
4868 if (ret)
4869 return ret;
426001a6
EP		 4870
4871 wlcore_update_inconn_sta(wl, wlvif, wl_sta, true);
29936266 4872 }
2d6cf2b5
EP		 4873
4874 /* Remove station (AP mode) */
4875 if (is_ap &&
4876 old_state == IEEE80211_STA_NONE &&
4877 new_state == IEEE80211_STA_NOTEXIST) {
4878 /* must not fail */
4879 wl12xx_sta_remove(wl, wlvif, sta);
426001a6
EP		 4880
4881 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
2d6cf2b5 4882 }
f84f7d78 4883
2d6cf2b5
EP		 4884 /* Authorize station (AP mode) */
4885 if (is_ap &&
4886 new_state == IEEE80211_STA_AUTHORIZED) {
2fec3d27 4887 ret = wl12xx_cmd_set_peer_state(wl, wlvif, wl_sta->hlid);
2d6cf2b5
EP		 4888 if (ret < 0)
4889 return ret;
f84f7d78 4890
2d6cf2b5 4891 ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
2fec3d27 4892 wl_sta->hlid);
29936266
EP		 4893 if (ret)
4894 return ret;
426001a6
EP		 4895
4896 wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
2d6cf2b5 4897 }
f84f7d78 4898
9fd6f21b
EP		 4899 /* Authorize station */
4900 if (is_sta &&
4901 new_state == IEEE80211_STA_AUTHORIZED) {
4902 set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
29936266
EP		 4903 ret = wl12xx_set_authorized(wl, wlvif);
4904 if (ret)
4905 return ret;
9fd6f21b
EP		 4906 }
4907
4908 if (is_sta &&
4909 old_state == IEEE80211_STA_AUTHORIZED &&
4910 new_state == IEEE80211_STA_ASSOC) {
4911 clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
3230f35e 4912 clear_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags);
9fd6f21b
EP		 4913 }
4914
29936266
EP		 4915 /* clear ROCs on failure or authorization */
4916 if (is_sta &&
4917 (new_state == IEEE80211_STA_AUTHORIZED ||
4918 new_state == IEEE80211_STA_NOTEXIST)) {
4919 if (test_bit(wlvif->role_id, wl->roc_map))
4920 wl12xx_croc(wl, wlvif->role_id);
9fd6f21b
EP		 4921 }
4922
29936266
EP		 4923 if (is_sta &&
4924 old_state == IEEE80211_STA_NOTEXIST &&
4925 new_state == IEEE80211_STA_NONE) {
4926 if (find_first_bit(wl->roc_map,
4927 WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) {
4928 WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID);
4929 wl12xx_roc(wl, wlvif, wlvif->role_id,
4930 wlvif->band, wlvif->channel);
4931 }
4932 }
2d6cf2b5
EP		 4933 return 0;
4934}
4935
4936static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
4937 struct ieee80211_vif *vif,
4938 struct ieee80211_sta *sta,
4939 enum ieee80211_sta_state old_state,
4940 enum ieee80211_sta_state new_state)
4941{
4942 struct wl1271 *wl = hw->priv;
4943 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4944 int ret;
4945
4946 wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
4947 sta->aid, old_state, new_state);
4948
4949 mutex_lock(&wl->mutex);
4950
4cc53383 4951 if (unlikely(wl->state != WLCORE_STATE_ON)) {
2d6cf2b5 4952 ret = -EBUSY;
f84f7d78 4953 goto out;
2d6cf2b5 4954 }
f84f7d78 4955
a620865e 4956 ret = wl1271_ps_elp_wakeup(wl);
f84f7d78
AN		 4957 if (ret < 0)
4958 goto out;
4959
2d6cf2b5 4960 ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
f84f7d78 4961
f84f7d78 4962 wl1271_ps_elp_sleep(wl);
f84f7d78
AN		 4963out:
4964 mutex_unlock(&wl->mutex);
2d6cf2b5
EP		 4965 if (new_state < old_state)
4966 return 0;
f84f7d78
AN		 4967 return ret;
4968}
4969
4623ec7d
LC		 4970static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
4971 struct ieee80211_vif *vif,
4972 enum ieee80211_ampdu_mlme_action action,
4973 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4974 u8 buf_size)
bbba3e68
LS		 4975{
4976 struct wl1271 *wl = hw->priv;
536129c8 4977 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
bbba3e68 4978 int ret;
0f9c8250
AN		 4979 u8 hlid, *ba_bitmap;
4980
4981 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
4982 tid);
4983
4984 /* sanity check - the fields in FW are only 8bits wide */
4985 if (WARN_ON(tid > 0xFF))
4986 return -ENOTSUPP;
bbba3e68
LS		 4987
4988 mutex_lock(&wl->mutex);
4989
4cc53383 4990 if (unlikely(wl->state != WLCORE_STATE_ON)) {
bbba3e68
LS		 4991 ret = -EAGAIN;
4992 goto out;
4993 }
4994
536129c8 4995 if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
154da67c 4996 hlid = wlvif->sta.hlid;
536129c8 4997 } else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
0f9c8250
AN		 4998 struct wl1271_station *wl_sta;
4999
5000 wl_sta = (struct wl1271_station *)sta->drv_priv;
5001 hlid = wl_sta->hlid;
0f9c8250
AN		 5002 } else {
5003 ret = -EINVAL;
5004 goto out;
5005 }
5006
9ae5d8d4
AN		 5007 ba_bitmap = &wl->links[hlid].ba_bitmap;
5008
a620865e 5009 ret = wl1271_ps_elp_wakeup(wl);
bbba3e68
LS		 5010 if (ret < 0)
5011 goto out;
5012
70559a06
SL		 5013 wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
5014 tid, action);
5015
bbba3e68
LS		 5016 switch (action) {
5017 case IEEE80211_AMPDU_RX_START:
d0802abd 5018 if (!wlvif->ba_support || !wlvif->ba_allowed) {
bbba3e68 5019 ret = -ENOTSUPP;
0f9c8250
AN		 5020 break;
5021 }
5022
d21553f8 5023 if (wl->ba_rx_session_count >= wl->ba_rx_session_count_max) {
0f9c8250
AN		 5024 ret = -EBUSY;
5025 wl1271_error("exceeded max RX BA sessions");
5026 break;
5027 }
5028
5029 if (*ba_bitmap & BIT(tid)) {
5030 ret = -EINVAL;
5031 wl1271_error("cannot enable RX BA session on active "
5032 "tid: %d", tid);
5033 break;
5034 }
5035
5036 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
5037 hlid);
5038 if (!ret) {
5039 *ba_bitmap |= BIT(tid);
5040 wl->ba_rx_session_count++;
bbba3e68
LS		 5041 }
5042 break;
5043
5044 case IEEE80211_AMPDU_RX_STOP:
0f9c8250 5045 if (!(*ba_bitmap & BIT(tid))) {
c954910b
AN		 5046 /*
5047 * this happens on reconfig - so only output a debug
5048 * message for now, and don't fail the function.
5049 */
5050 wl1271_debug(DEBUG_MAC80211,
5051 "no active RX BA session on tid: %d",
0f9c8250 5052 tid);
c954910b 5053 ret = 0;
0f9c8250
AN		 5054 break;
5055 }
5056
5057 ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
5058 hlid);
5059 if (!ret) {
5060 *ba_bitmap &= ~BIT(tid);
5061 wl->ba_rx_session_count--;
5062 }
bbba3e68
LS		 5063 break;
5064
5065 /*
5066 * The BA initiator session management in FW independently.
5067 * Falling break here on purpose for all TX APDU commands.
5068 */
5069 case IEEE80211_AMPDU_TX_START:
18b559d5
JB		 5070 case IEEE80211_AMPDU_TX_STOP_CONT:
5071 case IEEE80211_AMPDU_TX_STOP_FLUSH:
5072 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
bbba3e68
LS		 5073 case IEEE80211_AMPDU_TX_OPERATIONAL:
5074 ret = -EINVAL;
5075 break;
5076
5077 default:
5078 wl1271_error("Incorrect ampdu action id=%x\n", action);
5079 ret = -EINVAL;
5080 }
5081
5082 wl1271_ps_elp_sleep(wl);
5083
5084out:
5085 mutex_unlock(&wl->mutex);
5086
5087 return ret;
5088}
5089
af7fbb28
EP		 5090static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
5091 struct ieee80211_vif *vif,
5092 const struct cfg80211_bitrate_mask *mask)
5093{
83587505 5094 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
af7fbb28 5095 struct wl1271 *wl = hw->priv;
d6fa37c9 5096 int i, ret = 0;
af7fbb28
EP		 5097
5098 wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
5099 mask->control[NL80211_BAND_2GHZ].legacy,
5100 mask->control[NL80211_BAND_5GHZ].legacy);
5101
5102 mutex_lock(&wl->mutex);
5103
091185d6 5104 for (i = 0; i < WLCORE_NUM_BANDS; i++)
83587505 5105 wlvif->bitrate_masks[i] =
af7fbb28
EP		 5106 wl1271_tx_enabled_rates_get(wl,
5107 mask->control[i].legacy,
5108 i);
d6fa37c9 5109
4cc53383 5110 if (unlikely(wl->state != WLCORE_STATE_ON))
d6fa37c9
EP		 5111 goto out;
5112
5113 if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
5114 !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
5115
5116 ret = wl1271_ps_elp_wakeup(wl);
5117 if (ret < 0)
5118 goto out;
5119
5120 wl1271_set_band_rate(wl, wlvif);
5121 wlvif->basic_rate =
5122 wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
5123 ret = wl1271_acx_sta_rate_policies(wl, wlvif);
5124
5125 wl1271_ps_elp_sleep(wl);
5126 }
5127out:
af7fbb28
EP		 5128 mutex_unlock(&wl->mutex);
5129
d6fa37c9 5130 return ret;
af7fbb28
EP		 5131}
5132
6d158ff3
SL		 5133static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
5134 struct ieee80211_channel_switch *ch_switch)
5135{
5136 struct wl1271 *wl = hw->priv;
52630c5d 5137 struct wl12xx_vif *wlvif;
6d158ff3
SL		 5138 int ret;
5139
5140 wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
5141
b9239b66
AN		 5142 wl1271_tx_flush(wl);
5143
6d158ff3
SL		 5144 mutex_lock(&wl->mutex);
5145
4cc53383 5146 if (unlikely(wl->state == WLCORE_STATE_OFF)) {
6e8cd331
EP		 5147 wl12xx_for_each_wlvif_sta(wl, wlvif) {
5148 struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
5149 ieee80211_chswitch_done(vif, false);
5150 }
5151 goto out;
4cc53383
IY		 5152 } else if (unlikely(wl->state != WLCORE_STATE_ON)) {
5153 goto out;
6d158ff3
SL		 5154 }
5155
5156 ret = wl1271_ps_elp_wakeup(wl);
5157 if (ret < 0)
5158 goto out;
5159
52630c5d
EP		 5160 /* TODO: change mac80211 to pass vif as param */
5161 wl12xx_for_each_wlvif_sta(wl, wlvif) {
c50a2825 5162 unsigned long delay_usec;
6d158ff3 5163
fcab1890 5164 ret = wl->ops->channel_switch(wl, wlvif, ch_switch);
c50a2825
EP		 5165 if (ret)
5166 goto out_sleep;
6d158ff3 5167
c50a2825
EP		 5168 set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
5169
5170 /* indicate failure 5 seconds after channel switch time */
5171 delay_usec = ieee80211_tu_to_usec(wlvif->beacon_int) *
5172 ch_switch->count;
5173 ieee80211_queue_delayed_work(hw, &wlvif->channel_switch_work,
5174 usecs_to_jiffies(delay_usec) +
5175 msecs_to_jiffies(5000));
52630c5d 5176 }
6d158ff3 5177
c50a2825 5178out_sleep:
6d158ff3
SL		 5179 wl1271_ps_elp_sleep(wl);
5180
5181out:
5182 mutex_unlock(&wl->mutex);
5183}
5184
39ecc01d 5185static void wlcore_op_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
d8ae5a25
EP		 5186{
5187 struct wl1271 *wl = hw->priv;
5188
5189 wl1271_tx_flush(wl);
5190}
5191
dabf37db
EP		 5192static int wlcore_op_remain_on_channel(struct ieee80211_hw *hw,
5193 struct ieee80211_vif *vif,
5194 struct ieee80211_channel *chan,
d339d5ca
IP		 5195 int duration,
5196 enum ieee80211_roc_type type)
dabf37db
EP		 5197{
5198 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5199 struct wl1271 *wl = hw->priv;
5200 int channel, ret = 0;
5201
5202 channel = ieee80211_frequency_to_channel(chan->center_freq);
5203
5204 wl1271_debug(DEBUG_MAC80211, "mac80211 roc %d (%d)",
5205 channel, wlvif->role_id);
5206
5207 mutex_lock(&wl->mutex);
5208
5209 if (unlikely(wl->state != WLCORE_STATE_ON))
5210 goto out;
5211
5212 /* return EBUSY if we can't ROC right now */
5213 if (WARN_ON(wl->roc_vif ||
5214 find_first_bit(wl->roc_map,
5215 WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)) {
5216 ret = -EBUSY;
5217 goto out;
5218 }
5219
5220 ret = wl1271_ps_elp_wakeup(wl);
5221 if (ret < 0)
5222 goto out;
5223
5224 ret = wl12xx_start_dev(wl, wlvif, chan->band, channel);
5225 if (ret < 0)
5226 goto out_sleep;
5227
5228 wl->roc_vif = vif;
5229 ieee80211_queue_delayed_work(hw, &wl->roc_complete_work,
5230 msecs_to_jiffies(duration));
5231out_sleep:
5232 wl1271_ps_elp_sleep(wl);
5233out:
5234 mutex_unlock(&wl->mutex);
5235 return ret;
5236}
5237
5238static int __wlcore_roc_completed(struct wl1271 *wl)
5239{
5240 struct wl12xx_vif *wlvif;
5241 int ret;
5242
5243 /* already completed */
5244 if (unlikely(!wl->roc_vif))
5245 return 0;
5246
5247 wlvif = wl12xx_vif_to_data(wl->roc_vif);
5248
5249 if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
5250 return -EBUSY;
5251
5252 ret = wl12xx_stop_dev(wl, wlvif);
5253 if (ret < 0)
5254 return ret;
5255
5256 wl->roc_vif = NULL;
5257
5258 return 0;
5259}
5260
5261static int wlcore_roc_completed(struct wl1271 *wl)
5262{
5263 int ret;
5264
5265 wl1271_debug(DEBUG_MAC80211, "roc complete");
5266
5267 mutex_lock(&wl->mutex);
5268
5269 if (unlikely(wl->state != WLCORE_STATE_ON)) {
5270 ret = -EBUSY;
5271 goto out;
5272 }
5273
5274 ret = wl1271_ps_elp_wakeup(wl);
5275 if (ret < 0)
5276 goto out;
5277
5278 ret = __wlcore_roc_completed(wl);
5279
5280 wl1271_ps_elp_sleep(wl);
5281out:
5282 mutex_unlock(&wl->mutex);
5283
5284 return ret;
5285}
5286
5287static void wlcore_roc_complete_work(struct work_struct *work)
5288{
5289 struct delayed_work *dwork;
5290 struct wl1271 *wl;
5291 int ret;
5292
5293 dwork = container_of(work, struct delayed_work, work);
5294 wl = container_of(dwork, struct wl1271, roc_complete_work);
5295
5296 ret = wlcore_roc_completed(wl);
5297 if (!ret)
5298 ieee80211_remain_on_channel_expired(wl->hw);
5299}
5300
5301static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw *hw)
5302{
5303 struct wl1271 *wl = hw->priv;
5304
5305 wl1271_debug(DEBUG_MAC80211, "mac80211 croc");
5306
5307 /* TODO: per-vif */
5308 wl1271_tx_flush(wl);
5309
5310 /*
5311 * we can't just flush_work here, because it might deadlock
5312 * (as we might get called from the same workqueue)
5313 */
5314 cancel_delayed_work_sync(&wl->roc_complete_work);
5315 wlcore_roc_completed(wl);
5316
5317 return 0;
5318}
5319
5f9b6777
AN		 5320static void wlcore_op_sta_rc_update(struct ieee80211_hw *hw,
5321 struct ieee80211_vif *vif,
5322 struct ieee80211_sta *sta,
5323 u32 changed)
5324{
5325 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5326 struct wl1271 *wl = hw->priv;
5327
5328 wlcore_hw_sta_rc_update(wl, wlvif, sta, changed);
5329}
5330
0a9ffac0
NZ		 5331static int wlcore_op_get_rssi(struct ieee80211_hw *hw,
5332 struct ieee80211_vif *vif,
5333 struct ieee80211_sta *sta,
5334 s8 *rssi_dbm)
5335{
5336 struct wl1271 *wl = hw->priv;
5337 struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5338 int ret = 0;
5339
5340 wl1271_debug(DEBUG_MAC80211, "mac80211 get_rssi");
5341
5342 mutex_lock(&wl->mutex);
5343
5344 if (unlikely(wl->state != WLCORE_STATE_ON))
5345 goto out;
5346
5347 ret = wl1271_ps_elp_wakeup(wl);
5348 if (ret < 0)
5349 goto out_sleep;
5350
5351 ret = wlcore_acx_average_rssi(wl, wlvif, rssi_dbm);
5352 if (ret < 0)
5353 goto out_sleep;
5354
5355out_sleep:
5356 wl1271_ps_elp_sleep(wl);
5357
5358out:
5359 mutex_unlock(&wl->mutex);
5360
5361 return ret;
5362}
5363
33437893
AN		 5364static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
5365{
5366 struct wl1271 *wl = hw->priv;
5367 bool ret = false;
5368
5369 mutex_lock(&wl->mutex);
5370
4cc53383 5371 if (unlikely(wl->state != WLCORE_STATE_ON))
33437893
AN		 5372 goto out;
5373
5374 /* packets are considered pending if in the TX queue or the FW */
f1a46384 5375 ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
33437893
AN		 5376out:
5377 mutex_unlock(&wl->mutex);
5378
5379 return ret;
5380}
5381
f5fc0f86
LC		 5382/* can't be const, mac80211 writes to this */
5383static struct ieee80211_rate wl1271_rates[] = {
5384 { .bitrate = 10,
2b60100b
JO		 5385 .hw_value = CONF_HW_BIT_RATE_1MBPS,
5386 .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
f5fc0f86 5387 { .bitrate = 20,
2b60100b
JO		 5388 .hw_value = CONF_HW_BIT_RATE_2MBPS,
5389 .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
f5fc0f86
LC		 5390 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5391 { .bitrate = 55,
2b60100b
JO		 5392 .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
5393 .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
f5fc0f86
LC		 5394 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5395 { .bitrate = 110,
2b60100b
JO		 5396 .hw_value = CONF_HW_BIT_RATE_11MBPS,
5397 .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
f5fc0f86
LC		 5398 .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5399 { .bitrate = 60,
2b60100b
JO		 5400 .hw_value = CONF_HW_BIT_RATE_6MBPS,
5401 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
f5fc0f86 5402 { .bitrate = 90,
2b60100b
JO		 5403 .hw_value = CONF_HW_BIT_RATE_9MBPS,
5404 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
f5fc0f86 5405 { .bitrate = 120,
2b60100b
JO		 5406 .hw_value = CONF_HW_BIT_RATE_12MBPS,
5407 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
f5fc0f86 5408 { .bitrate = 180,
2b60100b
JO		 5409 .hw_value = CONF_HW_BIT_RATE_18MBPS,
5410 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
f5fc0f86 5411 { .bitrate = 240,
2b60100b
JO		 5412 .hw_value = CONF_HW_BIT_RATE_24MBPS,
5413 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
f5fc0f86 5414 { .bitrate = 360,
2b60100b
JO		 5415 .hw_value = CONF_HW_BIT_RATE_36MBPS,
5416 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
f5fc0f86 5417 { .bitrate = 480,
2b60100b
JO		 5418 .hw_value = CONF_HW_BIT_RATE_48MBPS,
5419 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
f5fc0f86 5420 { .bitrate = 540,
2b60100b
JO		 5421 .hw_value = CONF_HW_BIT_RATE_54MBPS,
5422 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
f5fc0f86
LC		 5423};
5424
fa97f46b 5425/* can't be const, mac80211 writes to this */
f5fc0f86 5426static struct ieee80211_channel wl1271_channels[] = {
583f8164
VG		 5427 { .hw_value = 1, .center_freq = 2412, .max_power = WLCORE_MAX_TXPWR },
5428 { .hw_value = 2, .center_freq = 2417, .max_power = WLCORE_MAX_TXPWR },
5429 { .hw_value = 3, .center_freq = 2422, .max_power = WLCORE_MAX_TXPWR },
5430 { .hw_value = 4, .center_freq = 2427, .max_power = WLCORE_MAX_TXPWR },
5431 { .hw_value = 5, .center_freq = 2432, .max_power = WLCORE_MAX_TXPWR },
5432 { .hw_value = 6, .center_freq = 2437, .max_power = WLCORE_MAX_TXPWR },
5433 { .hw_value = 7, .center_freq = 2442, .max_power = WLCORE_MAX_TXPWR },
5434 { .hw_value = 8, .center_freq = 2447, .max_power = WLCORE_MAX_TXPWR },
5435 { .hw_value = 9, .center_freq = 2452, .max_power = WLCORE_MAX_TXPWR },
5436 { .hw_value = 10, .center_freq = 2457, .max_power = WLCORE_MAX_TXPWR },
5437 { .hw_value = 11, .center_freq = 2462, .max_power = WLCORE_MAX_TXPWR },
5438 { .hw_value = 12, .center_freq = 2467, .max_power = WLCORE_MAX_TXPWR },
5439 { .hw_value = 13, .center_freq = 2472, .max_power = WLCORE_MAX_TXPWR },
5440 { .hw_value = 14, .center_freq = 2484, .max_power = WLCORE_MAX_TXPWR },
f5fc0f86
LC		 5441};
5442
5443/* can't be const, mac80211 writes to this */
5444static struct ieee80211_supported_band wl1271_band_2ghz = {
5445 .channels = wl1271_channels,
5446 .n_channels = ARRAY_SIZE(wl1271_channels),
5447 .bitrates = wl1271_rates,
5448 .n_bitrates = ARRAY_SIZE(wl1271_rates),
5449};
5450
1ebec3d7
TP		 5451/* 5 GHz data rates for WL1273 */
5452static struct ieee80211_rate wl1271_rates_5ghz[] = {
5453 { .bitrate = 60,
5454 .hw_value = CONF_HW_BIT_RATE_6MBPS,
5455 .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
5456 { .bitrate = 90,
5457 .hw_value = CONF_HW_BIT_RATE_9MBPS,
5458 .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
5459 { .bitrate = 120,
5460 .hw_value = CONF_HW_BIT_RATE_12MBPS,
5461 .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
5462 { .bitrate = 180,
5463 .hw_value = CONF_HW_BIT_RATE_18MBPS,
5464 .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
5465 { .bitrate = 240,
5466 .hw_value = CONF_HW_BIT_RATE_24MBPS,
5467 .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
5468 { .bitrate = 360,
5469 .hw_value = CONF_HW_BIT_RATE_36MBPS,
5470 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
5471 { .bitrate = 480,
5472 .hw_value = CONF_HW_BIT_RATE_48MBPS,
5473 .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
5474 { .bitrate = 540,
5475 .hw_value = CONF_HW_BIT_RATE_54MBPS,
5476 .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
5477};
5478
fa97f46b 5479/* 5 GHz band channels for WL1273 */
1ebec3d7 5480static struct ieee80211_channel wl1271_channels_5ghz[] = {
583f8164 5481 { .hw_value = 8, .center_freq = 5040, .max_power = WLCORE_MAX_TXPWR },
583f8164
VG		 5482 { .hw_value = 12, .center_freq = 5060, .max_power = WLCORE_MAX_TXPWR },
5483 { .hw_value = 16, .center_freq = 5080, .max_power = WLCORE_MAX_TXPWR },
5484 { .hw_value = 34, .center_freq = 5170, .max_power = WLCORE_MAX_TXPWR },
5485 { .hw_value = 36, .center_freq = 5180, .max_power = WLCORE_MAX_TXPWR },
5486 { .hw_value = 38, .center_freq = 5190, .max_power = WLCORE_MAX_TXPWR },
5487 { .hw_value = 40, .center_freq = 5200, .max_power = WLCORE_MAX_TXPWR },
5488 { .hw_value = 42, .center_freq = 5210, .max_power = WLCORE_MAX_TXPWR },
5489 { .hw_value = 44, .center_freq = 5220, .max_power = WLCORE_MAX_TXPWR },
5490 { .hw_value = 46, .center_freq = 5230, .max_power = WLCORE_MAX_TXPWR },
5491 { .hw_value = 48, .center_freq = 5240, .max_power = WLCORE_MAX_TXPWR },
5492 { .hw_value = 52, .center_freq = 5260, .max_power = WLCORE_MAX_TXPWR },
5493 { .hw_value = 56, .center_freq = 5280, .max_power = WLCORE_MAX_TXPWR },
5494 { .hw_value = 60, .center_freq = 5300, .max_power = WLCORE_MAX_TXPWR },
5495 { .hw_value = 64, .center_freq = 5320, .max_power = WLCORE_MAX_TXPWR },
5496 { .hw_value = 100, .center_freq = 5500, .max_power = WLCORE_MAX_TXPWR },
5497 { .hw_value = 104, .center_freq = 5520, .max_power = WLCORE_MAX_TXPWR },
5498 { .hw_value = 108, .center_freq = 5540, .max_power = WLCORE_MAX_TXPWR },
5499 { .hw_value = 112, .center_freq = 5560, .max_power = WLCORE_MAX_TXPWR },
5500 { .hw_value = 116, .center_freq = 5580, .max_power = WLCORE_MAX_TXPWR },
5501 { .hw_value = 120, .center_freq = 5600, .max_power = WLCORE_MAX_TXPWR },
5502 { .hw_value = 124, .center_freq = 5620, .max_power = WLCORE_MAX_TXPWR },
5503 { .hw_value = 128, .center_freq = 5640, .max_power = WLCORE_MAX_TXPWR },
5504 { .hw_value = 132, .center_freq = 5660, .max_power = WLCORE_MAX_TXPWR },
5505 { .hw_value = 136, .center_freq = 5680, .max_power = WLCORE_MAX_TXPWR },
5506 { .hw_value = 140, .center_freq = 5700, .max_power = WLCORE_MAX_TXPWR },
5507 { .hw_value = 149, .center_freq = 5745, .max_power = WLCORE_MAX_TXPWR },
5508 { .hw_value = 153, .center_freq = 5765, .max_power = WLCORE_MAX_TXPWR },
5509 { .hw_value = 157, .center_freq = 5785, .max_power = WLCORE_MAX_TXPWR },
5510 { .hw_value = 161, .center_freq = 5805, .max_power = WLCORE_MAX_TXPWR },
5511 { .hw_value = 165, .center_freq = 5825, .max_power = WLCORE_MAX_TXPWR },
1ebec3d7
TP		 5512};
5513
1ebec3d7
TP		 5514static struct ieee80211_supported_band wl1271_band_5ghz = {
5515 .channels = wl1271_channels_5ghz,
5516 .n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
5517 .bitrates = wl1271_rates_5ghz,
5518 .n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
f876bb9a
JO		 5519};
5520
f5fc0f86
LC		 5521static const struct ieee80211_ops wl1271_ops = {
5522 .start = wl1271_op_start,
c24ec83b 5523 .stop = wlcore_op_stop,
f5fc0f86
LC		 5524 .add_interface = wl1271_op_add_interface,
5525 .remove_interface = wl1271_op_remove_interface,
c0fad1b7 5526 .change_interface = wl12xx_op_change_interface,
f634a4e7 5527#ifdef CONFIG_PM
402e4861
EP		 5528 .suspend = wl1271_op_suspend,
5529 .resume = wl1271_op_resume,
f634a4e7 5530#endif
f5fc0f86 5531 .config = wl1271_op_config,
c87dec9f 5532 .prepare_multicast = wl1271_op_prepare_multicast,
f5fc0f86
LC		 5533 .configure_filter = wl1271_op_configure_filter,
5534 .tx = wl1271_op_tx,
a1c597f2 5535 .set_key = wlcore_op_set_key,
f5fc0f86 5536 .hw_scan = wl1271_op_hw_scan,
73ecce31 5537 .cancel_hw_scan = wl1271_op_cancel_hw_scan,
33c2c06c
LC		 5538 .sched_scan_start = wl1271_op_sched_scan_start,
5539 .sched_scan_stop = wl1271_op_sched_scan_stop,
f5fc0f86 5540 .bss_info_changed = wl1271_op_bss_info_changed,
68d069c4 5541 .set_frag_threshold = wl1271_op_set_frag_threshold,
f5fc0f86 5542 .set_rts_threshold = wl1271_op_set_rts_threshold,
c6999d83 5543 .conf_tx = wl1271_op_conf_tx,
bbbb538e 5544 .get_tsf = wl1271_op_get_tsf,
ece550d0 5545 .get_survey = wl1271_op_get_survey,
2d6cf2b5 5546 .sta_state = wl12xx_op_sta_state,
bbba3e68 5547 .ampdu_action = wl1271_op_ampdu_action,
33437893 5548 .tx_frames_pending = wl1271_tx_frames_pending,
af7fbb28 5549 .set_bitrate_mask = wl12xx_set_bitrate_mask,
ba1e6eb9 5550 .set_default_unicast_key = wl1271_op_set_default_key_idx,
6d158ff3 5551 .channel_switch = wl12xx_op_channel_switch,
d8ae5a25 5552 .flush = wlcore_op_flush,
dabf37db
EP		 5553 .remain_on_channel = wlcore_op_remain_on_channel,
5554 .cancel_remain_on_channel = wlcore_op_cancel_remain_on_channel,
b6970ee5
EP		 5555 .add_chanctx = wlcore_op_add_chanctx,
5556 .remove_chanctx = wlcore_op_remove_chanctx,
5557 .change_chanctx = wlcore_op_change_chanctx,
5558 .assign_vif_chanctx = wlcore_op_assign_vif_chanctx,
5559 .unassign_vif_chanctx = wlcore_op_unassign_vif_chanctx,
5f9b6777 5560 .sta_rc_update = wlcore_op_sta_rc_update,
0a9ffac0 5561 .get_rssi = wlcore_op_get_rssi,
c8c90873 5562 CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
f5fc0f86
LC		 5563};
5564
f876bb9a 5565
43a8bc5a 5566u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
f876bb9a
JO		 5567{
5568 u8 idx;
5569
43a8bc5a 5570 BUG_ON(band >= 2);
f876bb9a 5571
43a8bc5a 5572 if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
f876bb9a
JO		 5573 wl1271_error("Illegal RX rate from HW: %d", rate);
5574 return 0;
5575 }
5576
43a8bc5a 5577 idx = wl->band_rate_to_idx[band][rate];
f876bb9a
JO		 5578 if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
5579 wl1271_error("Unsupported RX rate from HW: %d", rate);
5580 return 0;
5581 }
5582
5583 return idx;
5584}
5585
f4afbed9 5586static void wl12xx_derive_mac_addresses(struct wl1271 *wl, u32 oui, u32 nic)
5e037e74
LC		 5587{
5588 int i;
5589
f4afbed9
AN		 5590 wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x",
5591 oui, nic);
5e037e74 5592
f4afbed9 5593 if (nic + WLCORE_NUM_MAC_ADDRESSES - wl->num_mac_addr > 0xffffff)
5e037e74
LC		 5594 wl1271_warning("NIC part of the MAC address wraps around!");
5595
f4afbed9 5596 for (i = 0; i < wl->num_mac_addr; i++) {
5e037e74
LC		 5597 wl->addresses[i].addr[0] = (u8)(oui >> 16);
5598 wl->addresses[i].addr[1] = (u8)(oui >> 8);
5599 wl->addresses[i].addr[2] = (u8) oui;
5600 wl->addresses[i].addr[3] = (u8)(nic >> 16);
5601 wl->addresses[i].addr[4] = (u8)(nic >> 8);
5602 wl->addresses[i].addr[5] = (u8) nic;
5603 nic++;
5604 }
5605
f4afbed9
AN		 5606 /* we may be one address short at the most */
5607 WARN_ON(wl->num_mac_addr + 1 < WLCORE_NUM_MAC_ADDRESSES);
5608
5609 /*
5610 * turn on the LAA bit in the first address and use it as
5611 * the last address.
5612 */
5613 if (wl->num_mac_addr < WLCORE_NUM_MAC_ADDRESSES) {
5614 int idx = WLCORE_NUM_MAC_ADDRESSES - 1;
5615 memcpy(&wl->addresses[idx], &wl->addresses[0],
5616 sizeof(wl->addresses[0]));
5617 /* LAA bit */
5618 wl->addresses[idx].addr[2] |= BIT(1);
5619 }
5620
5621 wl->hw->wiphy->n_addresses = WLCORE_NUM_MAC_ADDRESSES;
5e037e74
LC		 5622 wl->hw->wiphy->addresses = wl->addresses;
5623}
5624
30c5dbd1
LC		 5625static int wl12xx_get_hw_info(struct wl1271 *wl)
5626{
5627 int ret;
30c5dbd1
LC		 5628
5629 ret = wl12xx_set_power_on(wl);
5630 if (ret < 0)
4fb4e0be 5631 return ret;
30c5dbd1 5632
6134323f
IY		 5633 ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &wl->chip.id);
5634 if (ret < 0)
5635 goto out;
30c5dbd1 5636
00782136
LC		 5637 wl->fuse_oui_addr = 0;
5638 wl->fuse_nic_addr = 0;
30c5dbd1 5639
6134323f
IY		 5640 ret = wl->ops->get_pg_ver(wl, &wl->hw_pg_ver);
5641 if (ret < 0)
5642 goto out;
30c5dbd1 5643
30d9b4a5 5644 if (wl->ops->get_mac)
6134323f 5645 ret = wl->ops->get_mac(wl);
5e037e74 5646
30c5dbd1 5647out:
6134323f 5648 wl1271_power_off(wl);
30c5dbd1
LC		 5649 return ret;
5650}
5651
4b32a2c9 5652static int wl1271_register_hw(struct wl1271 *wl)
f5fc0f86
LC		 5653{
5654 int ret;
5e037e74 5655 u32 oui_addr = 0, nic_addr = 0;
f5fc0f86
LC		 5656
5657 if (wl->mac80211_registered)
5658 return 0;
5659
6f8d6b20 5660 if (wl->nvs_len >= 12) {
bc765bf3
SL		 5661 /* NOTE: The wl->nvs->nvs element must be first, in
5662 * order to simplify the casting, we assume it is at
5663 * the beginning of the wl->nvs structure.
5664 */
5665 u8 *nvs_ptr = (u8 *)wl->nvs;
31d26ec6 5666
5e037e74
LC		 5667 oui_addr =
5668 (nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
5669 nic_addr =
5670 (nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
5671 }
5672
5673 /* if the MAC address is zeroed in the NVS derive from fuse */
5674 if (oui_addr == 0 && nic_addr == 0) {
5675 oui_addr = wl->fuse_oui_addr;
5676 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
5677 nic_addr = wl->fuse_nic_addr + 1;
31d26ec6
AN		 5678 }
5679
f4afbed9 5680 wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr);
f5fc0f86
LC		 5681
5682 ret = ieee80211_register_hw(wl->hw);
5683 if (ret < 0) {
5684 wl1271_error("unable to register mac80211 hw: %d", ret);
30c5dbd1 5685 goto out;
f5fc0f86
LC		 5686 }
5687
5688 wl->mac80211_registered = true;
5689
d60080ae
EP		 5690 wl1271_debugfs_init(wl);
5691
f5fc0f86
LC		 5692 wl1271_notice("loaded");
5693
30c5dbd1
LC		 5694out:
5695 return ret;
f5fc0f86
LC		 5696}
5697
4b32a2c9 5698static void wl1271_unregister_hw(struct wl1271 *wl)
3b56dd6a 5699{
3fcdab70 5700 if (wl->plt)
f3df1331 5701 wl1271_plt_stop(wl);
4ae3fa87 5702
3b56dd6a
TP		 5703 ieee80211_unregister_hw(wl->hw);
5704 wl->mac80211_registered = false;
5705
5706}
3b56dd6a 5707
4b32a2c9 5708static int wl1271_init_ieee80211(struct wl1271 *wl)
f5fc0f86 5709{
583f8164 5710 int i;
7a55724e
JO		 5711 static const u32 cipher_suites[] = {
5712 WLAN_CIPHER_SUITE_WEP40,
5713 WLAN_CIPHER_SUITE_WEP104,
5714 WLAN_CIPHER_SUITE_TKIP,
5715 WLAN_CIPHER_SUITE_CCMP,
5716 WL1271_CIPHER_SUITE_GEM,
5717 };
5718
2c0133a4
AN		 5719 /* The tx descriptor buffer */
5720 wl->hw->extra_tx_headroom = sizeof(struct wl1271_tx_hw_descr);
5721
5722 if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE)
5723 wl->hw->extra_tx_headroom += WL1271_EXTRA_SPACE_TKIP;
f5fc0f86
LC		 5724
5725 /* unit us */
5726 /* FIXME: find a proper value */
50c500ad 5727 wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
f5fc0f86
LC		 5728
5729 wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
0a34332f 5730 IEEE80211_HW_SUPPORTS_PS |
f1d63a59 5731 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4695dc91 5732 IEEE80211_HW_SUPPORTS_UAPSD |
a9af092b 5733 IEEE80211_HW_HAS_RATE_CONTROL |
00236aed 5734 IEEE80211_HW_CONNECTION_MONITOR |
25eaea30 5735 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
fcd23b63 5736 IEEE80211_HW_SPECTRUM_MGMT |
93f8c8e0
AN		 5737 IEEE80211_HW_AP_LINK_PS |
5738 IEEE80211_HW_AMPDU_AGGREGATION |
79aba1ba 5739 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
1c33db78 5740 IEEE80211_HW_QUEUE_CONTROL;
f5fc0f86 5741
7a55724e
JO		 5742 wl->hw->wiphy->cipher_suites = cipher_suites;
5743 wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
5744
e0d8bbf0 5745 wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
045c745f
EP		 5746 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
5747 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
f5fc0f86 5748 wl->hw->wiphy->max_scan_ssids = 1;
221737d2
LC		 5749 wl->hw->wiphy->max_sched_scan_ssids = 16;
5750 wl->hw->wiphy->max_match_sets = 16;
ea559b46
GE		 5751 /*
5752 * Maximum length of elements in scanning probe request templates
5753 * should be the maximum length possible for a template, without
5754 * the IEEE80211 header of the template
5755 */
c08e371a 5756 wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
ea559b46 5757 sizeof(struct ieee80211_header);
a8aaaf53 5758
c08e371a 5759 wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
c9e79a47
LC		 5760 sizeof(struct ieee80211_header);
5761
dabf37db
EP		 5762 wl->hw->wiphy->max_remain_on_channel_duration = 5000;
5763
81ddbb5c 5764 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
1fb90260
JB		 5765 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
5766 WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
1ec23f7f 5767
4a31c11c
LC		 5768 /* make sure all our channels fit in the scanned_ch bitmask */
5769 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
5770 ARRAY_SIZE(wl1271_channels_5ghz) >
5771 WL1271_MAX_CHANNELS);
583f8164
VG		 5772 /*
5773 * clear channel flags from the previous usage
5774 * and restore max_power & max_antenna_gain values.
5775 */
5776 for (i = 0; i < ARRAY_SIZE(wl1271_channels); i++) {
5777 wl1271_band_2ghz.channels[i].flags = 0;
5778 wl1271_band_2ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
5779 wl1271_band_2ghz.channels[i].max_antenna_gain = 0;
5780 }
5781
5782 for (i = 0; i < ARRAY_SIZE(wl1271_channels_5ghz); i++) {
5783 wl1271_band_5ghz.channels[i].flags = 0;
5784 wl1271_band_5ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
5785 wl1271_band_5ghz.channels[i].max_antenna_gain = 0;
5786 }
5787
a8aaaf53
LC		 5788 /*
5789 * We keep local copies of the band structs because we need to
5790 * modify them on a per-device basis.
5791 */
5792 memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
5793 sizeof(wl1271_band_2ghz));
bfb92ca1
EP		 5794 memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap,
5795 &wl->ht_cap[IEEE80211_BAND_2GHZ],
5796 sizeof(*wl->ht_cap));
a8aaaf53
LC		 5797 memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
5798 sizeof(wl1271_band_5ghz));
bfb92ca1
EP		 5799 memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap,
5800 &wl->ht_cap[IEEE80211_BAND_5GHZ],
5801 sizeof(*wl->ht_cap));
a8aaaf53
LC		 5802
5803 wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
5804 &wl->bands[IEEE80211_BAND_2GHZ];
5805 wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
5806 &wl->bands[IEEE80211_BAND_5GHZ];
1ebec3d7 5807
1c33db78
AN		 5808 /*
5809 * allow 4 queues per mac address we support +
5810 * 1 cab queue per mac + one global offchannel Tx queue
5811 */
5812 wl->hw->queues = (NUM_TX_QUEUES + 1) * WLCORE_NUM_MAC_ADDRESSES + 1;
5813
5814 /* the last queue is the offchannel queue */
5815 wl->hw->offchannel_tx_hw_queue = wl->hw->queues - 1;
31627dc5 5816 wl->hw->max_rates = 1;
12bd8949 5817
b7417d93
JO		 5818 wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
5819
9c1b190b
AN		 5820 /* the FW answers probe-requests in AP-mode */
5821 wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
5822 wl->hw->wiphy->probe_resp_offload =
5823 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
5824 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
5825 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
5826
bcab320b 5827 /* allowed interface combinations */
abf0b249
EP		 5828 wl->hw->wiphy->iface_combinations = wl->iface_combinations;
5829 wl->hw->wiphy->n_iface_combinations = wl->n_iface_combinations;
bcab320b 5830
a390e85c 5831 SET_IEEE80211_DEV(wl->hw, wl->dev);
f5fc0f86 5832
f84f7d78 5833 wl->hw->sta_data_size = sizeof(struct wl1271_station);
87fbcb0f 5834 wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
f84f7d78 5835
ba421f8f 5836 wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
4c9cfa78 5837
f5fc0f86
LC		 5838 return 0;
5839}
5840
c50a2825
EP		 5841struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size,
5842 u32 mbox_size)
f5fc0f86 5843{
f5fc0f86
LC		 5844 struct ieee80211_hw *hw;
5845 struct wl1271 *wl;
a8c0ddb5 5846 int i, j, ret;
1f37cbc9 5847 unsigned int order;
f5fc0f86
LC		 5848
5849 hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
5850 if (!hw) {
5851 wl1271_error("could not alloc ieee80211_hw");
a1dd8187 5852 ret = -ENOMEM;
3b56dd6a
TP		 5853 goto err_hw_alloc;
5854 }
5855
f5fc0f86
LC		 5856 wl = hw->priv;
5857 memset(wl, 0, sizeof(*wl));
5858
96e0c683
AN		 5859 wl->priv = kzalloc(priv_size, GFP_KERNEL);
5860 if (!wl->priv) {
5861 wl1271_error("could not alloc wl priv");
5862 ret = -ENOMEM;
5863 goto err_priv_alloc;
5864 }
5865
87627214 5866 INIT_LIST_HEAD(&wl->wlvif_list);
01c09162 5867
f5fc0f86 5868 wl->hw = hw;
f5fc0f86 5869
da08fdfa
EP		 5870 /*
5871 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS.
5872 * we don't allocate any additional resource here, so that's fine.
5873 */
a8c0ddb5 5874 for (i = 0; i < NUM_TX_QUEUES; i++)
da08fdfa 5875 for (j = 0; j < WLCORE_MAX_LINKS; j++)
a8c0ddb5
AN		 5876 skb_queue_head_init(&wl->links[j].tx_queue[i]);
5877
a620865e
IY		 5878 skb_queue_head_init(&wl->deferred_rx_queue);
5879 skb_queue_head_init(&wl->deferred_tx_queue);
5880
37b70a81 5881 INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
a620865e 5882 INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
117b38d0
JO		 5883 INIT_WORK(&wl->tx_work, wl1271_tx_work);
5884 INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
5885 INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
dabf37db 5886 INIT_DELAYED_WORK(&wl->roc_complete_work, wlcore_roc_complete_work);
55df5afb 5887 INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
77ddaa10 5888
92ef8960
EP		 5889 wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
5890 if (!wl->freezable_wq) {
5891 ret = -ENOMEM;
5892 goto err_hw;
5893 }
5894
8f6ac537 5895 wl->channel = 0;
f5fc0f86 5896 wl->rx_counter = 0;
f5fc0f86 5897 wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
8a5a37a6 5898 wl->band = IEEE80211_BAND_2GHZ;
83d08d3f 5899 wl->channel_type = NL80211_CHAN_NO_HT;
830fb67b 5900 wl->flags = 0;
7fc3a864 5901 wl->sg_enabled = true;
66340e5b 5902 wl->sleep_auth = WL1271_PSM_ILLEGAL;
c108c905 5903 wl->recovery_count = 0;
d717fd61 5904 wl->hw_pg_ver = -1;
b622d992
AN		 5905 wl->ap_ps_map = 0;
5906 wl->ap_fw_ps_map = 0;
606ea9fa 5907 wl->quirks = 0;
341b7cde 5908 wl->platform_quirks = 0;
f4df1bd5 5909 wl->system_hlid = WL12XX_SYSTEM_HLID;
da03209e 5910 wl->active_sta_count = 0;
9a100968 5911 wl->active_link_count = 0;
95dac04f
IY		 5912 wl->fwlog_size = 0;
5913 init_waitqueue_head(&wl->fwlog_waitq);
f5fc0f86 5914
f4df1bd5
EP		 5915 /* The system link is always allocated */
5916 __set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
5917
25eeb9e3 5918 memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
72b0624f 5919 for (i = 0; i < wl->num_tx_desc; i++)
f5fc0f86
LC		 5920 wl->tx_frames[i] = NULL;
5921
5922 spin_lock_init(&wl->wl_lock);
5923
4cc53383 5924 wl->state = WLCORE_STATE_OFF;
3fcdab70 5925 wl->fw_type = WL12XX_FW_TYPE_NONE;
f5fc0f86 5926 mutex_init(&wl->mutex);
2c38849f 5927 mutex_init(&wl->flush_mutex);
6f8d6b20 5928 init_completion(&wl->nvs_loading_complete);
f5fc0f86 5929
26a309c7 5930 order = get_order(aggr_buf_size);
1f37cbc9
IY		 5931 wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
5932 if (!wl->aggr_buf) {
5933 ret = -ENOMEM;
92ef8960 5934 goto err_wq;
1f37cbc9 5935 }
26a309c7 5936 wl->aggr_buf_size = aggr_buf_size;
1f37cbc9 5937
990f5de7
IY		 5938 wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
5939 if (!wl->dummy_packet) {
5940 ret = -ENOMEM;
5941 goto err_aggr;
5942 }
5943
95dac04f
IY		 5944 /* Allocate one page for the FW log */
5945 wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
5946 if (!wl->fwlog) {
5947 ret = -ENOMEM;
5948 goto err_dummy_packet;
5949 }
5950
c50a2825
EP		 5951 wl->mbox_size = mbox_size;
5952 wl->mbox = kmalloc(wl->mbox_size, GFP_KERNEL | GFP_DMA);
690142e9
MG		 5953 if (!wl->mbox) {
5954 ret = -ENOMEM;
5955 goto err_fwlog;
5956 }
5957
2e07d028
IY		 5958 wl->buffer_32 = kmalloc(sizeof(*wl->buffer_32), GFP_KERNEL);
5959 if (!wl->buffer_32) {
5960 ret = -ENOMEM;
5961 goto err_mbox;
5962 }
5963
c332a4b8 5964 return hw;
a1dd8187 5965
2e07d028
IY		 5966err_mbox:
5967 kfree(wl->mbox);
5968
690142e9
MG		 5969err_fwlog:
5970 free_page((unsigned long)wl->fwlog);
5971
990f5de7
IY		 5972err_dummy_packet:
5973 dev_kfree_skb(wl->dummy_packet);
5974
1f37cbc9
IY		 5975err_aggr:
5976 free_pages((unsigned long)wl->aggr_buf, order);
5977
92ef8960
EP		 5978err_wq:
5979 destroy_workqueue(wl->freezable_wq);
5980
a1dd8187 5981err_hw:
3b56dd6a 5982 wl1271_debugfs_exit(wl);
96e0c683
AN		 5983 kfree(wl->priv);
5984
5985err_priv_alloc:
3b56dd6a
TP		 5986 ieee80211_free_hw(hw);
5987
5988err_hw_alloc:
a1dd8187 5989
a1dd8187 5990 return ERR_PTR(ret);
c332a4b8 5991}
ffeb501c 5992EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
c332a4b8 5993
ffeb501c 5994int wlcore_free_hw(struct wl1271 *wl)
c332a4b8 5995{
95dac04f
IY		 5996 /* Unblock any fwlog readers */
5997 mutex_lock(&wl->mutex);
5998 wl->fwlog_size = -1;
5999 wake_up_interruptible_all(&wl->fwlog_waitq);
6000 mutex_unlock(&wl->mutex);
6001
33cab57a 6002 wlcore_sysfs_free(wl);
6f07b72a 6003
2e07d028 6004 kfree(wl->buffer_32);
a8e27820 6005 kfree(wl->mbox);
95dac04f 6006 free_page((unsigned long)wl->fwlog);
990f5de7 6007 dev_kfree_skb(wl->dummy_packet);
26a309c7 6008 free_pages((unsigned long)wl->aggr_buf, get_order(wl->aggr_buf_size));
c332a4b8
TP		 6009
6010 wl1271_debugfs_exit(wl);
6011
c332a4b8
TP		 6012 vfree(wl->fw);
6013 wl->fw = NULL;
3fcdab70 6014 wl->fw_type = WL12XX_FW_TYPE_NONE;
c332a4b8
TP		 6015 kfree(wl->nvs);
6016 wl->nvs = NULL;
6017
75fb4df7
EP		 6018 kfree(wl->raw_fw_status);
6019 kfree(wl->fw_status);
c332a4b8 6020 kfree(wl->tx_res_if);
92ef8960 6021 destroy_workqueue(wl->freezable_wq);
c332a4b8 6022
96e0c683 6023 kfree(wl->priv);
c332a4b8
TP		 6024 ieee80211_free_hw(wl->hw);
6025
6026 return 0;
6027}
ffeb501c 6028EXPORT_SYMBOL_GPL(wlcore_free_hw);
50b3eb4b 6029
964dc9e2
JB		 6030#ifdef CONFIG_PM
6031static const struct wiphy_wowlan_support wlcore_wowlan_support = {
6032 .flags = WIPHY_WOWLAN_ANY,
6033 .n_patterns = WL1271_MAX_RX_FILTERS,
6034 .pattern_min_len = 1,
6035 .pattern_max_len = WL1271_RX_FILTER_MAX_PATTERN_SIZE,
6036};
6037#endif
6038
f2cede49
AN		 6039static irqreturn_t wlcore_hardirq(int irq, void *cookie)
6040{
6041 return IRQ_WAKE_THREAD;
6042}
6043
6f8d6b20 6044static void wlcore_nvs_cb(const struct firmware *fw, void *context)
ce2a217c 6045{
6f8d6b20
IY		 6046 struct wl1271 *wl = context;
6047 struct platform_device *pdev = wl->pdev;
90650625 6048 struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
afb43e6d 6049 struct wl12xx_platform_data *pdata = pdev_data->pdata;
a390e85c 6050 unsigned long irqflags;
ffeb501c 6051 int ret;
f2cede49 6052 irq_handler_t hardirq_fn = NULL;
a390e85c 6053
6f8d6b20
IY		 6054 if (fw) {
6055 wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
6056 if (!wl->nvs) {
6057 wl1271_error("Could not allocate nvs data");
6058 goto out;
6059 }
6060 wl->nvs_len = fw->size;
6061 } else {
6062 wl1271_debug(DEBUG_BOOT, "Could not get nvs file %s",
6063 WL12XX_NVS_NAME);
6064 wl->nvs = NULL;
6065 wl->nvs_len = 0;
a390e85c
FB		 6066 }
6067
3992eb2b
IY		 6068 ret = wl->ops->setup(wl);
6069 if (ret < 0)
6f8d6b20 6070 goto out_free_nvs;
3992eb2b 6071
72b0624f
AN		 6072 BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);
6073
e87288f0
LC		 6074 /* adjust some runtime configuration parameters */
6075 wlcore_adjust_conf(wl);
6076
a390e85c 6077 wl->irq = platform_get_irq(pdev, 0);
a390e85c 6078 wl->platform_quirks = pdata->platform_quirks;
afb43e6d 6079 wl->if_ops = pdev_data->if_ops;
a390e85c 6080
f2cede49 6081 if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ) {
a390e85c 6082 irqflags = IRQF_TRIGGER_RISING;
f2cede49
AN		 6083 hardirq_fn = wlcore_hardirq;
6084 } else {
a390e85c 6085 irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;
f2cede49 6086 }
a390e85c 6087
f2cede49 6088 ret = request_threaded_irq(wl->irq, hardirq_fn, wlcore_irq,
97236a06 6089 irqflags, pdev->name, wl);
a390e85c
FB		 6090 if (ret < 0) {
6091 wl1271_error("request_irq() failed: %d", ret);
6f8d6b20 6092 goto out_free_nvs;
a390e85c
FB		 6093 }
6094
dfb89c56 6095#ifdef CONFIG_PM
a390e85c
FB		 6096 ret = enable_irq_wake(wl->irq);
6097 if (!ret) {
6098 wl->irq_wake_enabled = true;
6099 device_init_wakeup(wl->dev, 1);
964dc9e2
JB		 6100 if (pdata->pwr_in_suspend)
6101 wl->hw->wiphy->wowlan = &wlcore_wowlan_support;
a390e85c 6102 }
dfb89c56 6103#endif
a390e85c
FB		 6104 disable_irq(wl->irq);
6105
4afc37a0
LC		 6106 ret = wl12xx_get_hw_info(wl);
6107 if (ret < 0) {
6108 wl1271_error("couldn't get hw info");
8b425e62 6109 goto out_irq;
4afc37a0
LC		 6110 }
6111
6112 ret = wl->ops->identify_chip(wl);
6113 if (ret < 0)
8b425e62 6114 goto out_irq;
4afc37a0 6115
a390e85c
FB		 6116 ret = wl1271_init_ieee80211(wl);
6117 if (ret)
6118 goto out_irq;
6119
6120 ret = wl1271_register_hw(wl);
6121 if (ret)
6122 goto out_irq;
6123
33cab57a
LC		 6124 ret = wlcore_sysfs_init(wl);
6125 if (ret)
8b425e62 6126 goto out_unreg;
f79f890c 6127
6f8d6b20 6128 wl->initialized = true;
ffeb501c 6129 goto out;
a390e85c 6130
8b425e62
LC		 6131out_unreg:
6132 wl1271_unregister_hw(wl);
6133
a390e85c
FB		 6134out_irq:
6135 free_irq(wl->irq, wl);
6136
6f8d6b20
IY		 6137out_free_nvs:
6138 kfree(wl->nvs);
6139
a390e85c 6140out:
6f8d6b20
IY		 6141 release_firmware(fw);
6142 complete_all(&wl->nvs_loading_complete);
6143}
6144
b74324d1 6145int wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
6f8d6b20
IY		 6146{
6147 int ret;
6148
6149 if (!wl->ops || !wl->ptable)
6150 return -EINVAL;
6151
6152 wl->dev = &pdev->dev;
6153 wl->pdev = pdev;
6154 platform_set_drvdata(pdev, wl);
6155
6156 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
6157 WL12XX_NVS_NAME, &pdev->dev, GFP_KERNEL,
6158 wl, wlcore_nvs_cb);
6159 if (ret < 0) {
6160 wl1271_error("request_firmware_nowait failed: %d", ret);
6161 complete_all(&wl->nvs_loading_complete);
6162 }
6163
a390e85c 6164 return ret;
ce2a217c 6165}
b2ba99ff 6166EXPORT_SYMBOL_GPL(wlcore_probe);
ce2a217c 6167
b74324d1 6168int wlcore_remove(struct platform_device *pdev)
ce2a217c 6169{
a390e85c
FB		 6170 struct wl1271 *wl = platform_get_drvdata(pdev);
6171
6f8d6b20
IY		 6172 wait_for_completion(&wl->nvs_loading_complete);
6173 if (!wl->initialized)
6174 return 0;
6175
a390e85c
FB		 6176 if (wl->irq_wake_enabled) {
6177 device_init_wakeup(wl->dev, 0);
6178 disable_irq_wake(wl->irq);
6179 }
6180 wl1271_unregister_hw(wl);
6181 free_irq(wl->irq, wl);
ffeb501c 6182 wlcore_free_hw(wl);
a390e85c 6183
ce2a217c
FB		 6184 return 0;
6185}
b2ba99ff 6186EXPORT_SYMBOL_GPL(wlcore_remove);
ce2a217c 6187
491bbd6b 6188u32 wl12xx_debug_level = DEBUG_NONE;
17c1755c 6189EXPORT_SYMBOL_GPL(wl12xx_debug_level);
491bbd6b 6190module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
17c1755c
EP		 6191MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
6192
95dac04f 6193module_param_named(fwlog, fwlog_param, charp, 0);
2c882fa4 6194MODULE_PARM_DESC(fwlog,
95dac04f
IY		 6195 "FW logger options: continuous, ondemand, dbgpins or disable");
6196
93ac8488
IR		 6197module_param(fwlog_mem_blocks, int, S_IRUSR | S_IWUSR);
6198MODULE_PARM_DESC(fwlog_mem_blocks, "fwlog mem_blocks");
6199
7230341f 6200module_param(bug_on_recovery, int, S_IRUSR | S_IWUSR);
2a5bff09
EP		 6201MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
6202
7230341f 6203module_param(no_recovery, int, S_IRUSR | S_IWUSR);
34785be5
AN		 6204MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");
6205
50b3eb4b 6206MODULE_LICENSE("GPL");
b1a48cab 6207MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
50b3eb4b 6208MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
0635ad45 6209MODULE_FIRMWARE(WL12XX_NVS_NAME);
Linux kernel - Deliverables
This page took 1.099991 seconds and 5 git commands to generate.