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