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