2 * This file is part of wlcore
4 * Copyright (C) 2008-2010 Nokia Corporation
5 * Copyright (C) 2011-2013 Texas Instruments Inc.
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
23 #include <linux/module.h>
24 #include <linux/firmware.h>
25 #include <linux/etherdevice.h>
26 #include <linux/vmalloc.h>
27 #include <linux/interrupt.h>
28 #include <linux/irq.h>
32 #include "wl12xx_80211.h"
39 #include "vendor_cmd.h"
44 #define WL1271_BOOT_RETRIES 3
46 static char *fwlog_param
;
47 static int fwlog_mem_blocks
= -1;
48 static int bug_on_recovery
= -1;
49 static int no_recovery
= -1;
51 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
52 struct ieee80211_vif
*vif
,
53 bool reset_tx_queues
);
54 static void wlcore_op_stop_locked(struct wl1271
*wl
);
55 static void wl1271_free_ap_keys(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
);
57 static int wl12xx_set_authorized(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
61 if (WARN_ON(wlvif
->bss_type
!= BSS_TYPE_STA_BSS
))
64 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
67 if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT
, &wlvif
->flags
))
70 ret
= wl12xx_cmd_set_peer_state(wl
, wlvif
, wlvif
->sta
.hlid
);
74 wl1271_info("Association completed.");
78 static void wl1271_reg_notify(struct wiphy
*wiphy
,
79 struct regulatory_request
*request
)
81 struct ieee80211_hw
*hw
= wiphy_to_ieee80211_hw(wiphy
);
82 struct wl1271
*wl
= hw
->priv
;
84 /* copy the current dfs region */
86 wl
->dfs_region
= request
->dfs_region
;
88 wlcore_regdomain_config(wl
);
91 static int wl1271_set_rx_streaming(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
96 /* we should hold wl->mutex */
97 ret
= wl1271_acx_ps_rx_streaming(wl
, wlvif
, enable
);
102 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
);
104 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
);
110 * this function is being called when the rx_streaming interval
111 * has beed changed or rx_streaming should be disabled
113 int wl1271_recalc_rx_streaming(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
116 int period
= wl
->conf
.rx_streaming
.interval
;
118 /* don't reconfigure if rx_streaming is disabled */
119 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
))
122 /* reconfigure/disable according to new streaming_period */
124 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) &&
125 (wl
->conf
.rx_streaming
.always
||
126 test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
127 ret
= wl1271_set_rx_streaming(wl
, wlvif
, true);
129 ret
= wl1271_set_rx_streaming(wl
, wlvif
, false);
130 /* don't cancel_work_sync since we might deadlock */
131 del_timer_sync(&wlvif
->rx_streaming_timer
);
137 static void wl1271_rx_streaming_enable_work(struct work_struct
*work
)
140 struct wl12xx_vif
*wlvif
= container_of(work
, struct wl12xx_vif
,
141 rx_streaming_enable_work
);
142 struct wl1271
*wl
= wlvif
->wl
;
144 mutex_lock(&wl
->mutex
);
146 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
) ||
147 !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) ||
148 (!wl
->conf
.rx_streaming
.always
&&
149 !test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
152 if (!wl
->conf
.rx_streaming
.interval
)
155 ret
= wl1271_ps_elp_wakeup(wl
);
159 ret
= wl1271_set_rx_streaming(wl
, wlvif
, true);
163 /* stop it after some time of inactivity */
164 mod_timer(&wlvif
->rx_streaming_timer
,
165 jiffies
+ msecs_to_jiffies(wl
->conf
.rx_streaming
.duration
));
168 wl1271_ps_elp_sleep(wl
);
170 mutex_unlock(&wl
->mutex
);
173 static void wl1271_rx_streaming_disable_work(struct work_struct
*work
)
176 struct wl12xx_vif
*wlvif
= container_of(work
, struct wl12xx_vif
,
177 rx_streaming_disable_work
);
178 struct wl1271
*wl
= wlvif
->wl
;
180 mutex_lock(&wl
->mutex
);
182 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
))
185 ret
= wl1271_ps_elp_wakeup(wl
);
189 ret
= wl1271_set_rx_streaming(wl
, wlvif
, false);
194 wl1271_ps_elp_sleep(wl
);
196 mutex_unlock(&wl
->mutex
);
199 static void wl1271_rx_streaming_timer(unsigned long data
)
201 struct wl12xx_vif
*wlvif
= (struct wl12xx_vif
*)data
;
202 struct wl1271
*wl
= wlvif
->wl
;
203 ieee80211_queue_work(wl
->hw
, &wlvif
->rx_streaming_disable_work
);
206 /* wl->mutex must be taken */
207 void wl12xx_rearm_tx_watchdog_locked(struct wl1271
*wl
)
209 /* if the watchdog is not armed, don't do anything */
210 if (wl
->tx_allocated_blocks
== 0)
213 cancel_delayed_work(&wl
->tx_watchdog_work
);
214 ieee80211_queue_delayed_work(wl
->hw
, &wl
->tx_watchdog_work
,
215 msecs_to_jiffies(wl
->conf
.tx
.tx_watchdog_timeout
));
218 static void wlcore_rc_update_work(struct work_struct
*work
)
221 struct wl12xx_vif
*wlvif
= container_of(work
, struct wl12xx_vif
,
223 struct wl1271
*wl
= wlvif
->wl
;
224 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
226 mutex_lock(&wl
->mutex
);
228 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
231 ret
= wl1271_ps_elp_wakeup(wl
);
235 if (ieee80211_vif_is_mesh(vif
)) {
236 ret
= wl1271_acx_set_ht_capabilities(wl
, &wlvif
->rc_ht_cap
,
237 true, wlvif
->sta
.hlid
);
241 wlcore_hw_sta_rc_update(wl
, wlvif
);
245 wl1271_ps_elp_sleep(wl
);
247 mutex_unlock(&wl
->mutex
);
250 static void wl12xx_tx_watchdog_work(struct work_struct
*work
)
252 struct delayed_work
*dwork
;
255 dwork
= to_delayed_work(work
);
256 wl
= container_of(dwork
, struct wl1271
, tx_watchdog_work
);
258 mutex_lock(&wl
->mutex
);
260 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
263 /* Tx went out in the meantime - everything is ok */
264 if (unlikely(wl
->tx_allocated_blocks
== 0))
268 * if a ROC is in progress, we might not have any Tx for a long
269 * time (e.g. pending Tx on the non-ROC channels)
271 if (find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
) {
272 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms due to ROC",
273 wl
->conf
.tx
.tx_watchdog_timeout
);
274 wl12xx_rearm_tx_watchdog_locked(wl
);
279 * if a scan is in progress, we might not have any Tx for a long
282 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
283 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms due to scan",
284 wl
->conf
.tx
.tx_watchdog_timeout
);
285 wl12xx_rearm_tx_watchdog_locked(wl
);
290 * AP might cache a frame for a long time for a sleeping station,
291 * so rearm the timer if there's an AP interface with stations. If
292 * Tx is genuinely stuck we will most hopefully discover it when all
293 * stations are removed due to inactivity.
295 if (wl
->active_sta_count
) {
296 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms. AP has "
298 wl
->conf
.tx
.tx_watchdog_timeout
,
299 wl
->active_sta_count
);
300 wl12xx_rearm_tx_watchdog_locked(wl
);
304 wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
305 wl
->conf
.tx
.tx_watchdog_timeout
);
306 wl12xx_queue_recovery_work(wl
);
309 mutex_unlock(&wl
->mutex
);
312 static void wlcore_adjust_conf(struct wl1271
*wl
)
316 if (!strcmp(fwlog_param
, "continuous")) {
317 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
318 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_HOST
;
319 } else if (!strcmp(fwlog_param
, "dbgpins")) {
320 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
321 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_DBG_PINS
;
322 } else if (!strcmp(fwlog_param
, "disable")) {
323 wl
->conf
.fwlog
.mem_blocks
= 0;
324 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_NONE
;
326 wl1271_error("Unknown fwlog parameter %s", fwlog_param
);
330 if (bug_on_recovery
!= -1)
331 wl
->conf
.recovery
.bug_on_recovery
= (u8
) bug_on_recovery
;
333 if (no_recovery
!= -1)
334 wl
->conf
.recovery
.no_recovery
= (u8
) no_recovery
;
337 static void wl12xx_irq_ps_regulate_link(struct wl1271
*wl
,
338 struct wl12xx_vif
*wlvif
,
343 fw_ps
= test_bit(hlid
, &wl
->ap_fw_ps_map
);
346 * Wake up from high level PS if the STA is asleep with too little
347 * packets in FW or if the STA is awake.
349 if (!fw_ps
|| tx_pkts
< WL1271_PS_STA_MAX_PACKETS
)
350 wl12xx_ps_link_end(wl
, wlvif
, hlid
);
353 * Start high-level PS if the STA is asleep with enough blocks in FW.
354 * Make an exception if this is the only connected link. In this
355 * case FW-memory congestion is less of a problem.
356 * Note that a single connected STA means 2*ap_count + 1 active links,
357 * since we must account for the global and broadcast AP links
358 * for each AP. The "fw_ps" check assures us the other link is a STA
359 * connected to the AP. Otherwise the FW would not set the PSM bit.
361 else if (wl
->active_link_count
> (wl
->ap_count
*2 + 1) && fw_ps
&&
362 tx_pkts
>= WL1271_PS_STA_MAX_PACKETS
)
363 wl12xx_ps_link_start(wl
, wlvif
, hlid
, true);
366 static void wl12xx_irq_update_links_status(struct wl1271
*wl
,
367 struct wl12xx_vif
*wlvif
,
368 struct wl_fw_status
*status
)
370 unsigned long cur_fw_ps_map
;
373 cur_fw_ps_map
= status
->link_ps_bitmap
;
374 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
375 wl1271_debug(DEBUG_PSM
,
376 "link ps prev 0x%lx cur 0x%lx changed 0x%lx",
377 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
378 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
380 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
383 for_each_set_bit(hlid
, wlvif
->ap
.sta_hlid_map
, wl
->num_links
)
384 wl12xx_irq_ps_regulate_link(wl
, wlvif
, hlid
,
385 wl
->links
[hlid
].allocated_pkts
);
388 static int wlcore_fw_status(struct wl1271
*wl
, struct wl_fw_status
*status
)
390 struct wl12xx_vif
*wlvif
;
392 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
393 int avail
, freed_blocks
;
396 struct wl1271_link
*lnk
;
398 ret
= wlcore_raw_read_data(wl
, REG_RAW_FW_STATUS_ADDR
,
400 wl
->fw_status_len
, false);
404 wlcore_hw_convert_fw_status(wl
, wl
->raw_fw_status
, wl
->fw_status
);
406 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
407 "drv_rx_counter = %d, tx_results_counter = %d)",
409 status
->fw_rx_counter
,
410 status
->drv_rx_counter
,
411 status
->tx_results_counter
);
413 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
414 /* prevent wrap-around in freed-packets counter */
415 wl
->tx_allocated_pkts
[i
] -=
416 (status
->counters
.tx_released_pkts
[i
] -
417 wl
->tx_pkts_freed
[i
]) & 0xff;
419 wl
->tx_pkts_freed
[i
] = status
->counters
.tx_released_pkts
[i
];
423 for_each_set_bit(i
, wl
->links_map
, wl
->num_links
) {
427 /* prevent wrap-around in freed-packets counter */
428 diff
= (status
->counters
.tx_lnk_free_pkts
[i
] -
429 lnk
->prev_freed_pkts
) & 0xff;
434 lnk
->allocated_pkts
-= diff
;
435 lnk
->prev_freed_pkts
= status
->counters
.tx_lnk_free_pkts
[i
];
437 /* accumulate the prev_freed_pkts counter */
438 lnk
->total_freed_pkts
+= diff
;
441 /* prevent wrap-around in total blocks counter */
442 if (likely(wl
->tx_blocks_freed
<= status
->total_released_blks
))
443 freed_blocks
= status
->total_released_blks
-
446 freed_blocks
= 0x100000000LL
- wl
->tx_blocks_freed
+
447 status
->total_released_blks
;
449 wl
->tx_blocks_freed
= status
->total_released_blks
;
451 wl
->tx_allocated_blocks
-= freed_blocks
;
454 * If the FW freed some blocks:
455 * If we still have allocated blocks - re-arm the timer, Tx is
456 * not stuck. Otherwise, cancel the timer (no Tx currently).
459 if (wl
->tx_allocated_blocks
)
460 wl12xx_rearm_tx_watchdog_locked(wl
);
462 cancel_delayed_work(&wl
->tx_watchdog_work
);
465 avail
= status
->tx_total
- wl
->tx_allocated_blocks
;
468 * The FW might change the total number of TX memblocks before
469 * we get a notification about blocks being released. Thus, the
470 * available blocks calculation might yield a temporary result
471 * which is lower than the actual available blocks. Keeping in
472 * mind that only blocks that were allocated can be moved from
473 * TX to RX, tx_blocks_available should never decrease here.
475 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
478 /* if more blocks are available now, tx work can be scheduled */
479 if (wl
->tx_blocks_available
> old_tx_blk_count
)
480 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
482 /* for AP update num of allocated TX blocks per link and ps status */
483 wl12xx_for_each_wlvif_ap(wl
, wlvif
) {
484 wl12xx_irq_update_links_status(wl
, wlvif
, status
);
487 /* update the host-chipset time offset */
489 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
490 (s64
)(status
->fw_localtime
);
492 wl
->fw_fast_lnk_map
= status
->link_fast_bitmap
;
497 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
501 /* Pass all received frames to the network stack */
502 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
503 ieee80211_rx_ni(wl
->hw
, skb
);
505 /* Return sent skbs to the network stack */
506 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
507 ieee80211_tx_status_ni(wl
->hw
, skb
);
510 static void wl1271_netstack_work(struct work_struct
*work
)
513 container_of(work
, struct wl1271
, netstack_work
);
516 wl1271_flush_deferred_work(wl
);
517 } while (skb_queue_len(&wl
->deferred_rx_queue
));
520 #define WL1271_IRQ_MAX_LOOPS 256
522 static int wlcore_irq_locked(struct wl1271
*wl
)
526 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
528 unsigned int defer_count
;
532 * In case edge triggered interrupt must be used, we cannot iterate
533 * more than once without introducing race conditions with the hardirq.
535 if (wl
->irq_flags
& (IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
))
538 wl1271_debug(DEBUG_IRQ
, "IRQ work");
540 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
543 ret
= wl1271_ps_elp_wakeup(wl
);
547 while (!done
&& loopcount
--) {
549 * In order to avoid a race with the hardirq, clear the flag
550 * before acknowledging the chip. Since the mutex is held,
551 * wl1271_ps_elp_wakeup cannot be called concurrently.
553 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
554 smp_mb__after_atomic();
556 ret
= wlcore_fw_status(wl
, wl
->fw_status
);
560 wlcore_hw_tx_immediate_compl(wl
);
562 intr
= wl
->fw_status
->intr
;
563 intr
&= WLCORE_ALL_INTR_MASK
;
569 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
570 wl1271_error("HW watchdog interrupt received! starting recovery.");
571 wl
->watchdog_recovery
= true;
574 /* restarting the chip. ignore any other interrupt. */
578 if (unlikely(intr
& WL1271_ACX_SW_INTR_WATCHDOG
)) {
579 wl1271_error("SW watchdog interrupt received! "
580 "starting recovery.");
581 wl
->watchdog_recovery
= true;
584 /* restarting the chip. ignore any other interrupt. */
588 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
589 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
591 ret
= wlcore_rx(wl
, wl
->fw_status
);
595 /* Check if any tx blocks were freed */
596 spin_lock_irqsave(&wl
->wl_lock
, flags
);
597 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
598 wl1271_tx_total_queue_count(wl
) > 0) {
599 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
601 * In order to avoid starvation of the TX path,
602 * call the work function directly.
604 ret
= wlcore_tx_work_locked(wl
);
608 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
611 /* check for tx results */
612 ret
= wlcore_hw_tx_delayed_compl(wl
);
616 /* Make sure the deferred queues don't get too long */
617 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
618 skb_queue_len(&wl
->deferred_rx_queue
);
619 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
620 wl1271_flush_deferred_work(wl
);
623 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
624 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
625 ret
= wl1271_event_handle(wl
, 0);
630 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
631 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
632 ret
= wl1271_event_handle(wl
, 1);
637 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
638 wl1271_debug(DEBUG_IRQ
,
639 "WL1271_ACX_INTR_INIT_COMPLETE");
641 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
642 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
645 wl1271_ps_elp_sleep(wl
);
651 static irqreturn_t
wlcore_irq(int irq
, void *cookie
)
655 struct wl1271
*wl
= cookie
;
657 /* complete the ELP completion */
658 spin_lock_irqsave(&wl
->wl_lock
, flags
);
659 set_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
661 complete(wl
->elp_compl
);
662 wl
->elp_compl
= NULL
;
665 if (test_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
)) {
666 /* don't enqueue a work right now. mark it as pending */
667 set_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
);
668 wl1271_debug(DEBUG_IRQ
, "should not enqueue work");
669 disable_irq_nosync(wl
->irq
);
670 pm_wakeup_event(wl
->dev
, 0);
671 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
674 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
676 /* TX might be handled here, avoid redundant work */
677 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
678 cancel_work_sync(&wl
->tx_work
);
680 mutex_lock(&wl
->mutex
);
682 ret
= wlcore_irq_locked(wl
);
684 wl12xx_queue_recovery_work(wl
);
686 spin_lock_irqsave(&wl
->wl_lock
, flags
);
687 /* In case TX was not handled here, queue TX work */
688 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
689 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
690 wl1271_tx_total_queue_count(wl
) > 0)
691 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
692 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
694 mutex_unlock(&wl
->mutex
);
699 struct vif_counter_data
{
702 struct ieee80211_vif
*cur_vif
;
703 bool cur_vif_running
;
706 static void wl12xx_vif_count_iter(void *data
, u8
*mac
,
707 struct ieee80211_vif
*vif
)
709 struct vif_counter_data
*counter
= data
;
712 if (counter
->cur_vif
== vif
)
713 counter
->cur_vif_running
= true;
716 /* caller must not hold wl->mutex, as it might deadlock */
717 static void wl12xx_get_vif_count(struct ieee80211_hw
*hw
,
718 struct ieee80211_vif
*cur_vif
,
719 struct vif_counter_data
*data
)
721 memset(data
, 0, sizeof(*data
));
722 data
->cur_vif
= cur_vif
;
724 ieee80211_iterate_active_interfaces(hw
, IEEE80211_IFACE_ITER_RESUME_ALL
,
725 wl12xx_vif_count_iter
, data
);
728 static int wl12xx_fetch_firmware(struct wl1271
*wl
, bool plt
)
730 const struct firmware
*fw
;
732 enum wl12xx_fw_type fw_type
;
736 fw_type
= WL12XX_FW_TYPE_PLT
;
737 fw_name
= wl
->plt_fw_name
;
740 * we can't call wl12xx_get_vif_count() here because
741 * wl->mutex is taken, so use the cached last_vif_count value
743 if (wl
->last_vif_count
> 1 && wl
->mr_fw_name
) {
744 fw_type
= WL12XX_FW_TYPE_MULTI
;
745 fw_name
= wl
->mr_fw_name
;
747 fw_type
= WL12XX_FW_TYPE_NORMAL
;
748 fw_name
= wl
->sr_fw_name
;
752 if (wl
->fw_type
== fw_type
)
755 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
757 ret
= request_firmware(&fw
, fw_name
, wl
->dev
);
760 wl1271_error("could not get firmware %s: %d", fw_name
, ret
);
765 wl1271_error("firmware size is not multiple of 32 bits: %zu",
772 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
773 wl
->fw_len
= fw
->size
;
774 wl
->fw
= vmalloc(wl
->fw_len
);
777 wl1271_error("could not allocate memory for the firmware");
782 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
784 wl
->fw_type
= fw_type
;
786 release_firmware(fw
);
791 void wl12xx_queue_recovery_work(struct wl1271
*wl
)
793 /* Avoid a recursive recovery */
794 if (wl
->state
== WLCORE_STATE_ON
) {
795 WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
,
798 wl
->state
= WLCORE_STATE_RESTARTING
;
799 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
800 wl1271_ps_elp_wakeup(wl
);
801 wlcore_disable_interrupts_nosync(wl
);
802 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
806 size_t wl12xx_copy_fwlog(struct wl1271
*wl
, u8
*memblock
, size_t maxlen
)
810 /* Make sure we have enough room */
811 len
= min_t(size_t, maxlen
, PAGE_SIZE
- wl
->fwlog_size
);
813 /* Fill the FW log file, consumed by the sysfs fwlog entry */
814 memcpy(wl
->fwlog
+ wl
->fwlog_size
, memblock
, len
);
815 wl
->fwlog_size
+= len
;
820 static void wl12xx_read_fwlog_panic(struct wl1271
*wl
)
824 if (wl
->quirks
& WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED
)
827 wl1271_info("Reading FW panic log");
830 * Make sure the chip is awake and the logger isn't active.
831 * Do not send a stop fwlog command if the fw is hanged or if
832 * dbgpins are used (due to some fw bug).
834 if (wl1271_ps_elp_wakeup(wl
))
836 if (!wl
->watchdog_recovery
&&
837 wl
->conf
.fwlog
.output
!= WL12XX_FWLOG_OUTPUT_DBG_PINS
)
838 wl12xx_cmd_stop_fwlog(wl
);
840 /* Traverse the memory blocks linked list */
842 end_of_log
= wlcore_event_fw_logger(wl
);
843 if (end_of_log
== 0) {
845 end_of_log
= wlcore_event_fw_logger(wl
);
847 } while (end_of_log
!= 0);
850 static void wlcore_save_freed_pkts(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
851 u8 hlid
, struct ieee80211_sta
*sta
)
853 struct wl1271_station
*wl_sta
;
854 u32 sqn_recovery_padding
= WL1271_TX_SQN_POST_RECOVERY_PADDING
;
856 wl_sta
= (void *)sta
->drv_priv
;
857 wl_sta
->total_freed_pkts
= wl
->links
[hlid
].total_freed_pkts
;
860 * increment the initial seq number on recovery to account for
861 * transmitted packets that we haven't yet got in the FW status
863 if (wlvif
->encryption_type
== KEY_GEM
)
864 sqn_recovery_padding
= WL1271_TX_SQN_POST_RECOVERY_PADDING_GEM
;
866 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
867 wl_sta
->total_freed_pkts
+= sqn_recovery_padding
;
870 static void wlcore_save_freed_pkts_addr(struct wl1271
*wl
,
871 struct wl12xx_vif
*wlvif
,
872 u8 hlid
, const u8
*addr
)
874 struct ieee80211_sta
*sta
;
875 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
877 if (WARN_ON(hlid
== WL12XX_INVALID_LINK_ID
||
878 is_zero_ether_addr(addr
)))
882 sta
= ieee80211_find_sta(vif
, addr
);
884 wlcore_save_freed_pkts(wl
, wlvif
, hlid
, sta
);
888 static void wlcore_print_recovery(struct wl1271
*wl
)
894 wl1271_info("Hardware recovery in progress. FW ver: %s",
895 wl
->chip
.fw_ver_str
);
897 /* change partitions momentarily so we can read the FW pc */
898 ret
= wlcore_set_partition(wl
, &wl
->ptable
[PART_BOOT
]);
902 ret
= wlcore_read_reg(wl
, REG_PC_ON_RECOVERY
, &pc
);
906 ret
= wlcore_read_reg(wl
, REG_INTERRUPT_NO_CLEAR
, &hint_sts
);
910 wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
911 pc
, hint_sts
, ++wl
->recovery_count
);
913 wlcore_set_partition(wl
, &wl
->ptable
[PART_WORK
]);
917 static void wl1271_recovery_work(struct work_struct
*work
)
920 container_of(work
, struct wl1271
, recovery_work
);
921 struct wl12xx_vif
*wlvif
;
922 struct ieee80211_vif
*vif
;
924 mutex_lock(&wl
->mutex
);
926 if (wl
->state
== WLCORE_STATE_OFF
|| wl
->plt
)
929 if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
)) {
930 if (wl
->conf
.fwlog
.output
== WL12XX_FWLOG_OUTPUT_HOST
)
931 wl12xx_read_fwlog_panic(wl
);
932 wlcore_print_recovery(wl
);
935 BUG_ON(wl
->conf
.recovery
.bug_on_recovery
&&
936 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
));
938 if (wl
->conf
.recovery
.no_recovery
) {
939 wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
943 /* Prevent spurious TX during FW restart */
944 wlcore_stop_queues(wl
, WLCORE_QUEUE_STOP_REASON_FW_RESTART
);
946 /* reboot the chipset */
947 while (!list_empty(&wl
->wlvif_list
)) {
948 wlvif
= list_first_entry(&wl
->wlvif_list
,
949 struct wl12xx_vif
, list
);
950 vif
= wl12xx_wlvif_to_vif(wlvif
);
952 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
953 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) {
954 wlcore_save_freed_pkts_addr(wl
, wlvif
, wlvif
->sta
.hlid
,
955 vif
->bss_conf
.bssid
);
958 __wl1271_op_remove_interface(wl
, vif
, false);
961 wlcore_op_stop_locked(wl
);
963 ieee80211_restart_hw(wl
->hw
);
966 * Its safe to enable TX now - the queues are stopped after a request
969 wlcore_wake_queues(wl
, WLCORE_QUEUE_STOP_REASON_FW_RESTART
);
972 wl
->watchdog_recovery
= false;
973 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
974 mutex_unlock(&wl
->mutex
);
977 static int wlcore_fw_wakeup(struct wl1271
*wl
)
979 return wlcore_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG
, ELPCTRL_WAKE_UP
);
982 static int wl1271_setup(struct wl1271
*wl
)
984 wl
->raw_fw_status
= kzalloc(wl
->fw_status_len
, GFP_KERNEL
);
985 if (!wl
->raw_fw_status
)
988 wl
->fw_status
= kzalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
992 wl
->tx_res_if
= kzalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
998 kfree(wl
->fw_status
);
999 kfree(wl
->raw_fw_status
);
1003 static int wl12xx_set_power_on(struct wl1271
*wl
)
1007 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1008 ret
= wl1271_power_on(wl
);
1011 msleep(WL1271_POWER_ON_SLEEP
);
1012 wl1271_io_reset(wl
);
1015 ret
= wlcore_set_partition(wl
, &wl
->ptable
[PART_BOOT
]);
1019 /* ELP module wake up */
1020 ret
= wlcore_fw_wakeup(wl
);
1028 wl1271_power_off(wl
);
1032 static int wl12xx_chip_wakeup(struct wl1271
*wl
, bool plt
)
1036 ret
= wl12xx_set_power_on(wl
);
1041 * For wl127x based devices we could use the default block
1042 * size (512 bytes), but due to a bug in the sdio driver, we
1043 * need to set it explicitly after the chip is powered on. To
1044 * simplify the code and since the performance impact is
1045 * negligible, we use the same block size for all different
1048 * Check if the bus supports blocksize alignment and, if it
1049 * doesn't, make sure we don't have the quirk.
1051 if (!wl1271_set_block_size(wl
))
1052 wl
->quirks
&= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN
;
1054 /* TODO: make sure the lower driver has set things up correctly */
1056 ret
= wl1271_setup(wl
);
1060 ret
= wl12xx_fetch_firmware(wl
, plt
);
1068 int wl1271_plt_start(struct wl1271
*wl
, const enum plt_mode plt_mode
)
1070 int retries
= WL1271_BOOT_RETRIES
;
1071 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
1073 static const char* const PLT_MODE
[] = {
1082 mutex_lock(&wl
->mutex
);
1084 wl1271_notice("power up");
1086 if (wl
->state
!= WLCORE_STATE_OFF
) {
1087 wl1271_error("cannot go into PLT state because not "
1088 "in off state: %d", wl
->state
);
1093 /* Indicate to lower levels that we are now in PLT mode */
1095 wl
->plt_mode
= plt_mode
;
1099 ret
= wl12xx_chip_wakeup(wl
, true);
1103 if (plt_mode
!= PLT_CHIP_AWAKE
) {
1104 ret
= wl
->ops
->plt_init(wl
);
1109 wl
->state
= WLCORE_STATE_ON
;
1110 wl1271_notice("firmware booted in PLT mode %s (%s)",
1112 wl
->chip
.fw_ver_str
);
1114 /* update hw/fw version info in wiphy struct */
1115 wiphy
->hw_version
= wl
->chip
.id
;
1116 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1117 sizeof(wiphy
->fw_version
));
1122 wl1271_power_off(wl
);
1126 wl
->plt_mode
= PLT_OFF
;
1128 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1129 WL1271_BOOT_RETRIES
);
1131 mutex_unlock(&wl
->mutex
);
1136 int wl1271_plt_stop(struct wl1271
*wl
)
1140 wl1271_notice("power down");
1143 * Interrupts must be disabled before setting the state to OFF.
1144 * Otherwise, the interrupt handler might be called and exit without
1145 * reading the interrupt status.
1147 wlcore_disable_interrupts(wl
);
1148 mutex_lock(&wl
->mutex
);
1150 mutex_unlock(&wl
->mutex
);
1153 * This will not necessarily enable interrupts as interrupts
1154 * may have been disabled when op_stop was called. It will,
1155 * however, balance the above call to disable_interrupts().
1157 wlcore_enable_interrupts(wl
);
1159 wl1271_error("cannot power down because not in PLT "
1160 "state: %d", wl
->state
);
1165 mutex_unlock(&wl
->mutex
);
1167 wl1271_flush_deferred_work(wl
);
1168 cancel_work_sync(&wl
->netstack_work
);
1169 cancel_work_sync(&wl
->recovery_work
);
1170 cancel_delayed_work_sync(&wl
->elp_work
);
1171 cancel_delayed_work_sync(&wl
->tx_watchdog_work
);
1173 mutex_lock(&wl
->mutex
);
1174 wl1271_power_off(wl
);
1176 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
1177 wl
->state
= WLCORE_STATE_OFF
;
1179 wl
->plt_mode
= PLT_OFF
;
1181 mutex_unlock(&wl
->mutex
);
1187 static void wl1271_op_tx(struct ieee80211_hw
*hw
,
1188 struct ieee80211_tx_control
*control
,
1189 struct sk_buff
*skb
)
1191 struct wl1271
*wl
= hw
->priv
;
1192 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1193 struct ieee80211_vif
*vif
= info
->control
.vif
;
1194 struct wl12xx_vif
*wlvif
= NULL
;
1195 unsigned long flags
;
1200 wl1271_debug(DEBUG_TX
, "DROP skb with no vif");
1201 ieee80211_free_txskb(hw
, skb
);
1205 wlvif
= wl12xx_vif_to_data(vif
);
1206 mapping
= skb_get_queue_mapping(skb
);
1207 q
= wl1271_tx_get_queue(mapping
);
1209 hlid
= wl12xx_tx_get_hlid(wl
, wlvif
, skb
, control
->sta
);
1211 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1214 * drop the packet if the link is invalid or the queue is stopped
1215 * for any reason but watermark. Watermark is a "soft"-stop so we
1216 * allow these packets through.
1218 if (hlid
== WL12XX_INVALID_LINK_ID
||
1219 (!test_bit(hlid
, wlvif
->links_map
)) ||
1220 (wlcore_is_queue_stopped_locked(wl
, wlvif
, q
) &&
1221 !wlcore_is_queue_stopped_by_reason_locked(wl
, wlvif
, q
,
1222 WLCORE_QUEUE_STOP_REASON_WATERMARK
))) {
1223 wl1271_debug(DEBUG_TX
, "DROP skb hlid %d q %d", hlid
, q
);
1224 ieee80211_free_txskb(hw
, skb
);
1228 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d len %d",
1230 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1232 wl
->tx_queue_count
[q
]++;
1233 wlvif
->tx_queue_count
[q
]++;
1236 * The workqueue is slow to process the tx_queue and we need stop
1237 * the queue here, otherwise the queue will get too long.
1239 if (wlvif
->tx_queue_count
[q
] >= WL1271_TX_QUEUE_HIGH_WATERMARK
&&
1240 !wlcore_is_queue_stopped_by_reason_locked(wl
, wlvif
, q
,
1241 WLCORE_QUEUE_STOP_REASON_WATERMARK
)) {
1242 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues for q %d", q
);
1243 wlcore_stop_queue_locked(wl
, wlvif
, q
,
1244 WLCORE_QUEUE_STOP_REASON_WATERMARK
);
1248 * The chip specific setup must run before the first TX packet -
1249 * before that, the tx_work will not be initialized!
1252 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1253 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1254 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1257 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1260 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1262 unsigned long flags
;
1265 /* no need to queue a new dummy packet if one is already pending */
1266 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
))
1269 q
= wl1271_tx_get_queue(skb_get_queue_mapping(wl
->dummy_packet
));
1271 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1272 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1273 wl
->tx_queue_count
[q
]++;
1274 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1276 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1277 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1278 return wlcore_tx_work_locked(wl
);
1281 * If the FW TX is busy, TX work will be scheduled by the threaded
1282 * interrupt handler function
1288 * The size of the dummy packet should be at least 1400 bytes. However, in
1289 * order to minimize the number of bus transactions, aligning it to 512 bytes
1290 * boundaries could be beneficial, performance wise
1292 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1294 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1296 struct sk_buff
*skb
;
1297 struct ieee80211_hdr_3addr
*hdr
;
1298 unsigned int dummy_packet_size
;
1300 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1301 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1303 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1305 wl1271_warning("Failed to allocate a dummy packet skb");
1309 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1311 hdr
= skb_put_zero(skb
, sizeof(*hdr
));
1312 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1313 IEEE80211_STYPE_NULLFUNC
|
1314 IEEE80211_FCTL_TODS
);
1316 skb_put_zero(skb
, dummy_packet_size
);
1318 /* Dummy packets require the TID to be management */
1319 skb
->priority
= WL1271_TID_MGMT
;
1321 /* Initialize all fields that might be used */
1322 skb_set_queue_mapping(skb
, 0);
1323 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1331 wl1271_validate_wowlan_pattern(struct cfg80211_pkt_pattern
*p
)
1333 int num_fields
= 0, in_field
= 0, fields_size
= 0;
1334 int i
, pattern_len
= 0;
1337 wl1271_warning("No mask in WoWLAN pattern");
1342 * The pattern is broken up into segments of bytes at different offsets
1343 * that need to be checked by the FW filter. Each segment is called
1344 * a field in the FW API. We verify that the total number of fields
1345 * required for this pattern won't exceed FW limits (8)
1346 * as well as the total fields buffer won't exceed the FW limit.
1347 * Note that if there's a pattern which crosses Ethernet/IP header
1348 * boundary a new field is required.
1350 for (i
= 0; i
< p
->pattern_len
; i
++) {
1351 if (test_bit(i
, (unsigned long *)p
->mask
)) {
1356 if (i
== WL1271_RX_FILTER_ETH_HEADER_SIZE
) {
1358 fields_size
+= pattern_len
+
1359 RX_FILTER_FIELD_OVERHEAD
;
1367 fields_size
+= pattern_len
+
1368 RX_FILTER_FIELD_OVERHEAD
;
1375 fields_size
+= pattern_len
+ RX_FILTER_FIELD_OVERHEAD
;
1379 if (num_fields
> WL1271_RX_FILTER_MAX_FIELDS
) {
1380 wl1271_warning("RX Filter too complex. Too many segments");
1384 if (fields_size
> WL1271_RX_FILTER_MAX_FIELDS_SIZE
) {
1385 wl1271_warning("RX filter pattern is too big");
1392 struct wl12xx_rx_filter
*wl1271_rx_filter_alloc(void)
1394 return kzalloc(sizeof(struct wl12xx_rx_filter
), GFP_KERNEL
);
1397 void wl1271_rx_filter_free(struct wl12xx_rx_filter
*filter
)
1404 for (i
= 0; i
< filter
->num_fields
; i
++)
1405 kfree(filter
->fields
[i
].pattern
);
1410 int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter
*filter
,
1411 u16 offset
, u8 flags
,
1412 const u8
*pattern
, u8 len
)
1414 struct wl12xx_rx_filter_field
*field
;
1416 if (filter
->num_fields
== WL1271_RX_FILTER_MAX_FIELDS
) {
1417 wl1271_warning("Max fields per RX filter. can't alloc another");
1421 field
= &filter
->fields
[filter
->num_fields
];
1423 field
->pattern
= kzalloc(len
, GFP_KERNEL
);
1424 if (!field
->pattern
) {
1425 wl1271_warning("Failed to allocate RX filter pattern");
1429 filter
->num_fields
++;
1431 field
->offset
= cpu_to_le16(offset
);
1432 field
->flags
= flags
;
1434 memcpy(field
->pattern
, pattern
, len
);
1439 int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter
*filter
)
1441 int i
, fields_size
= 0;
1443 for (i
= 0; i
< filter
->num_fields
; i
++)
1444 fields_size
+= filter
->fields
[i
].len
+
1445 sizeof(struct wl12xx_rx_filter_field
) -
1451 void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter
*filter
,
1455 struct wl12xx_rx_filter_field
*field
;
1457 for (i
= 0; i
< filter
->num_fields
; i
++) {
1458 field
= (struct wl12xx_rx_filter_field
*)buf
;
1460 field
->offset
= filter
->fields
[i
].offset
;
1461 field
->flags
= filter
->fields
[i
].flags
;
1462 field
->len
= filter
->fields
[i
].len
;
1464 memcpy(&field
->pattern
, filter
->fields
[i
].pattern
, field
->len
);
1465 buf
+= sizeof(struct wl12xx_rx_filter_field
) -
1466 sizeof(u8
*) + field
->len
;
1471 * Allocates an RX filter returned through f
1472 * which needs to be freed using rx_filter_free()
1475 wl1271_convert_wowlan_pattern_to_rx_filter(struct cfg80211_pkt_pattern
*p
,
1476 struct wl12xx_rx_filter
**f
)
1479 struct wl12xx_rx_filter
*filter
;
1483 filter
= wl1271_rx_filter_alloc();
1485 wl1271_warning("Failed to alloc rx filter");
1491 while (i
< p
->pattern_len
) {
1492 if (!test_bit(i
, (unsigned long *)p
->mask
)) {
1497 for (j
= i
; j
< p
->pattern_len
; j
++) {
1498 if (!test_bit(j
, (unsigned long *)p
->mask
))
1501 if (i
< WL1271_RX_FILTER_ETH_HEADER_SIZE
&&
1502 j
>= WL1271_RX_FILTER_ETH_HEADER_SIZE
)
1506 if (i
< WL1271_RX_FILTER_ETH_HEADER_SIZE
) {
1508 flags
= WL1271_RX_FILTER_FLAG_ETHERNET_HEADER
;
1510 offset
= i
- WL1271_RX_FILTER_ETH_HEADER_SIZE
;
1511 flags
= WL1271_RX_FILTER_FLAG_IP_HEADER
;
1516 ret
= wl1271_rx_filter_alloc_field(filter
,
1519 &p
->pattern
[i
], len
);
1526 filter
->action
= FILTER_SIGNAL
;
1532 wl1271_rx_filter_free(filter
);
1538 static int wl1271_configure_wowlan(struct wl1271
*wl
,
1539 struct cfg80211_wowlan
*wow
)
1543 if (!wow
|| wow
->any
|| !wow
->n_patterns
) {
1544 ret
= wl1271_acx_default_rx_filter_enable(wl
, 0,
1549 ret
= wl1271_rx_filter_clear_all(wl
);
1556 if (WARN_ON(wow
->n_patterns
> WL1271_MAX_RX_FILTERS
))
1559 /* Validate all incoming patterns before clearing current FW state */
1560 for (i
= 0; i
< wow
->n_patterns
; i
++) {
1561 ret
= wl1271_validate_wowlan_pattern(&wow
->patterns
[i
]);
1563 wl1271_warning("Bad wowlan pattern %d", i
);
1568 ret
= wl1271_acx_default_rx_filter_enable(wl
, 0, FILTER_SIGNAL
);
1572 ret
= wl1271_rx_filter_clear_all(wl
);
1576 /* Translate WoWLAN patterns into filters */
1577 for (i
= 0; i
< wow
->n_patterns
; i
++) {
1578 struct cfg80211_pkt_pattern
*p
;
1579 struct wl12xx_rx_filter
*filter
= NULL
;
1581 p
= &wow
->patterns
[i
];
1583 ret
= wl1271_convert_wowlan_pattern_to_rx_filter(p
, &filter
);
1585 wl1271_warning("Failed to create an RX filter from "
1586 "wowlan pattern %d", i
);
1590 ret
= wl1271_rx_filter_enable(wl
, i
, 1, filter
);
1592 wl1271_rx_filter_free(filter
);
1597 ret
= wl1271_acx_default_rx_filter_enable(wl
, 1, FILTER_DROP
);
1603 static int wl1271_configure_suspend_sta(struct wl1271
*wl
,
1604 struct wl12xx_vif
*wlvif
,
1605 struct cfg80211_wowlan
*wow
)
1609 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
1612 ret
= wl1271_configure_wowlan(wl
, wow
);
1616 if ((wl
->conf
.conn
.suspend_wake_up_event
==
1617 wl
->conf
.conn
.wake_up_event
) &&
1618 (wl
->conf
.conn
.suspend_listen_interval
==
1619 wl
->conf
.conn
.listen_interval
))
1622 ret
= wl1271_acx_wake_up_conditions(wl
, wlvif
,
1623 wl
->conf
.conn
.suspend_wake_up_event
,
1624 wl
->conf
.conn
.suspend_listen_interval
);
1627 wl1271_error("suspend: set wake up conditions failed: %d", ret
);
1633 static int wl1271_configure_suspend_ap(struct wl1271
*wl
,
1634 struct wl12xx_vif
*wlvif
,
1635 struct cfg80211_wowlan
*wow
)
1639 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
))
1642 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, true);
1646 ret
= wl1271_configure_wowlan(wl
, wow
);
1655 static int wl1271_configure_suspend(struct wl1271
*wl
,
1656 struct wl12xx_vif
*wlvif
,
1657 struct cfg80211_wowlan
*wow
)
1659 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
)
1660 return wl1271_configure_suspend_sta(wl
, wlvif
, wow
);
1661 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
1662 return wl1271_configure_suspend_ap(wl
, wlvif
, wow
);
1666 static void wl1271_configure_resume(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
1669 bool is_ap
= wlvif
->bss_type
== BSS_TYPE_AP_BSS
;
1670 bool is_sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
1672 if ((!is_ap
) && (!is_sta
))
1675 if ((is_sta
&& !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) ||
1676 (is_ap
&& !test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)))
1679 wl1271_configure_wowlan(wl
, NULL
);
1682 if ((wl
->conf
.conn
.suspend_wake_up_event
==
1683 wl
->conf
.conn
.wake_up_event
) &&
1684 (wl
->conf
.conn
.suspend_listen_interval
==
1685 wl
->conf
.conn
.listen_interval
))
1688 ret
= wl1271_acx_wake_up_conditions(wl
, wlvif
,
1689 wl
->conf
.conn
.wake_up_event
,
1690 wl
->conf
.conn
.listen_interval
);
1693 wl1271_error("resume: wake up conditions failed: %d",
1697 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, false);
1701 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1702 struct cfg80211_wowlan
*wow
)
1704 struct wl1271
*wl
= hw
->priv
;
1705 struct wl12xx_vif
*wlvif
;
1708 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1711 /* we want to perform the recovery before suspending */
1712 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
)) {
1713 wl1271_warning("postponing suspend to perform recovery");
1717 wl1271_tx_flush(wl
);
1719 mutex_lock(&wl
->mutex
);
1721 ret
= wl1271_ps_elp_wakeup(wl
);
1723 mutex_unlock(&wl
->mutex
);
1727 wl
->wow_enabled
= true;
1728 wl12xx_for_each_wlvif(wl
, wlvif
) {
1729 if (wlcore_is_p2p_mgmt(wlvif
))
1732 ret
= wl1271_configure_suspend(wl
, wlvif
, wow
);
1734 mutex_unlock(&wl
->mutex
);
1735 wl1271_warning("couldn't prepare device to suspend");
1740 /* disable fast link flow control notifications from FW */
1741 ret
= wlcore_hw_interrupt_notify(wl
, false);
1745 /* if filtering is enabled, configure the FW to drop all RX BA frames */
1746 ret
= wlcore_hw_rx_ba_filter(wl
,
1747 !!wl
->conf
.conn
.suspend_rx_ba_activity
);
1752 wl1271_ps_elp_sleep(wl
);
1753 mutex_unlock(&wl
->mutex
);
1756 wl1271_warning("couldn't prepare device to suspend");
1760 /* flush any remaining work */
1761 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1764 * disable and re-enable interrupts in order to flush
1767 wlcore_disable_interrupts(wl
);
1770 * set suspended flag to avoid triggering a new threaded_irq
1771 * work. no need for spinlock as interrupts are disabled.
1773 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1775 wlcore_enable_interrupts(wl
);
1776 flush_work(&wl
->tx_work
);
1777 flush_delayed_work(&wl
->elp_work
);
1780 * Cancel the watchdog even if above tx_flush failed. We will detect
1781 * it on resume anyway.
1783 cancel_delayed_work(&wl
->tx_watchdog_work
);
1788 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1790 struct wl1271
*wl
= hw
->priv
;
1791 struct wl12xx_vif
*wlvif
;
1792 unsigned long flags
;
1793 bool run_irq_work
= false, pending_recovery
;
1796 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1798 WARN_ON(!wl
->wow_enabled
);
1801 * re-enable irq_work enqueuing, and call irq_work directly if
1802 * there is a pending work.
1804 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1805 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1806 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1807 run_irq_work
= true;
1808 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1810 mutex_lock(&wl
->mutex
);
1812 /* test the recovery flag before calling any SDIO functions */
1813 pending_recovery
= test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
,
1817 wl1271_debug(DEBUG_MAC80211
,
1818 "run postponed irq_work directly");
1820 /* don't talk to the HW if recovery is pending */
1821 if (!pending_recovery
) {
1822 ret
= wlcore_irq_locked(wl
);
1824 wl12xx_queue_recovery_work(wl
);
1827 wlcore_enable_interrupts(wl
);
1830 if (pending_recovery
) {
1831 wl1271_warning("queuing forgotten recovery on resume");
1832 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
1836 ret
= wl1271_ps_elp_wakeup(wl
);
1840 wl12xx_for_each_wlvif(wl
, wlvif
) {
1841 if (wlcore_is_p2p_mgmt(wlvif
))
1844 wl1271_configure_resume(wl
, wlvif
);
1847 ret
= wlcore_hw_interrupt_notify(wl
, true);
1851 /* if filtering is enabled, configure the FW to drop all RX BA frames */
1852 ret
= wlcore_hw_rx_ba_filter(wl
, false);
1857 wl1271_ps_elp_sleep(wl
);
1860 wl
->wow_enabled
= false;
1863 * Set a flag to re-init the watchdog on the first Tx after resume.
1864 * That way we avoid possible conditions where Tx-complete interrupts
1865 * fail to arrive and we perform a spurious recovery.
1867 set_bit(WL1271_FLAG_REINIT_TX_WDOG
, &wl
->flags
);
1868 mutex_unlock(&wl
->mutex
);
1874 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1876 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1879 * We have to delay the booting of the hardware because
1880 * we need to know the local MAC address before downloading and
1881 * initializing the firmware. The MAC address cannot be changed
1882 * after boot, and without the proper MAC address, the firmware
1883 * will not function properly.
1885 * The MAC address is first known when the corresponding interface
1886 * is added. That is where we will initialize the hardware.
1892 static void wlcore_op_stop_locked(struct wl1271
*wl
)
1896 if (wl
->state
== WLCORE_STATE_OFF
) {
1897 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
,
1899 wlcore_enable_interrupts(wl
);
1905 * this must be before the cancel_work calls below, so that the work
1906 * functions don't perform further work.
1908 wl
->state
= WLCORE_STATE_OFF
;
1911 * Use the nosync variant to disable interrupts, so the mutex could be
1912 * held while doing so without deadlocking.
1914 wlcore_disable_interrupts_nosync(wl
);
1916 mutex_unlock(&wl
->mutex
);
1918 wlcore_synchronize_interrupts(wl
);
1919 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1920 cancel_work_sync(&wl
->recovery_work
);
1921 wl1271_flush_deferred_work(wl
);
1922 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1923 cancel_work_sync(&wl
->netstack_work
);
1924 cancel_work_sync(&wl
->tx_work
);
1925 cancel_delayed_work_sync(&wl
->elp_work
);
1926 cancel_delayed_work_sync(&wl
->tx_watchdog_work
);
1928 /* let's notify MAC80211 about the remaining pending TX frames */
1929 mutex_lock(&wl
->mutex
);
1930 wl12xx_tx_reset(wl
);
1932 wl1271_power_off(wl
);
1934 * In case a recovery was scheduled, interrupts were disabled to avoid
1935 * an interrupt storm. Now that the power is down, it is safe to
1936 * re-enable interrupts to balance the disable depth
1938 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1939 wlcore_enable_interrupts(wl
);
1941 wl
->band
= NL80211_BAND_2GHZ
;
1944 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1945 wl
->channel_type
= NL80211_CHAN_NO_HT
;
1946 wl
->tx_blocks_available
= 0;
1947 wl
->tx_allocated_blocks
= 0;
1948 wl
->tx_results_count
= 0;
1949 wl
->tx_packets_count
= 0;
1950 wl
->time_offset
= 0;
1951 wl
->ap_fw_ps_map
= 0;
1953 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
1954 memset(wl
->roles_map
, 0, sizeof(wl
->roles_map
));
1955 memset(wl
->links_map
, 0, sizeof(wl
->links_map
));
1956 memset(wl
->roc_map
, 0, sizeof(wl
->roc_map
));
1957 memset(wl
->session_ids
, 0, sizeof(wl
->session_ids
));
1958 memset(wl
->rx_filter_enabled
, 0, sizeof(wl
->rx_filter_enabled
));
1959 wl
->active_sta_count
= 0;
1960 wl
->active_link_count
= 0;
1962 /* The system link is always allocated */
1963 wl
->links
[WL12XX_SYSTEM_HLID
].allocated_pkts
= 0;
1964 wl
->links
[WL12XX_SYSTEM_HLID
].prev_freed_pkts
= 0;
1965 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
1968 * this is performed after the cancel_work calls and the associated
1969 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1970 * get executed before all these vars have been reset.
1974 wl
->tx_blocks_freed
= 0;
1976 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
1977 wl
->tx_pkts_freed
[i
] = 0;
1978 wl
->tx_allocated_pkts
[i
] = 0;
1981 wl1271_debugfs_reset(wl
);
1983 kfree(wl
->raw_fw_status
);
1984 wl
->raw_fw_status
= NULL
;
1985 kfree(wl
->fw_status
);
1986 wl
->fw_status
= NULL
;
1987 kfree(wl
->tx_res_if
);
1988 wl
->tx_res_if
= NULL
;
1989 kfree(wl
->target_mem_map
);
1990 wl
->target_mem_map
= NULL
;
1993 * FW channels must be re-calibrated after recovery,
1994 * save current Reg-Domain channel configuration and clear it.
1996 memcpy(wl
->reg_ch_conf_pending
, wl
->reg_ch_conf_last
,
1997 sizeof(wl
->reg_ch_conf_pending
));
1998 memset(wl
->reg_ch_conf_last
, 0, sizeof(wl
->reg_ch_conf_last
));
2001 static void wlcore_op_stop(struct ieee80211_hw
*hw
)
2003 struct wl1271
*wl
= hw
->priv
;
2005 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
2007 mutex_lock(&wl
->mutex
);
2009 wlcore_op_stop_locked(wl
);
2011 mutex_unlock(&wl
->mutex
);
2014 static void wlcore_channel_switch_work(struct work_struct
*work
)
2016 struct delayed_work
*dwork
;
2018 struct ieee80211_vif
*vif
;
2019 struct wl12xx_vif
*wlvif
;
2022 dwork
= to_delayed_work(work
);
2023 wlvif
= container_of(dwork
, struct wl12xx_vif
, channel_switch_work
);
2026 wl1271_info("channel switch failed (role_id: %d).", wlvif
->role_id
);
2028 mutex_lock(&wl
->mutex
);
2030 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2033 /* check the channel switch is still ongoing */
2034 if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
))
2037 vif
= wl12xx_wlvif_to_vif(wlvif
);
2038 ieee80211_chswitch_done(vif
, false);
2040 ret
= wl1271_ps_elp_wakeup(wl
);
2044 wl12xx_cmd_stop_channel_switch(wl
, wlvif
);
2046 wl1271_ps_elp_sleep(wl
);
2048 mutex_unlock(&wl
->mutex
);
2051 static void wlcore_connection_loss_work(struct work_struct
*work
)
2053 struct delayed_work
*dwork
;
2055 struct ieee80211_vif
*vif
;
2056 struct wl12xx_vif
*wlvif
;
2058 dwork
= to_delayed_work(work
);
2059 wlvif
= container_of(dwork
, struct wl12xx_vif
, connection_loss_work
);
2062 wl1271_info("Connection loss work (role_id: %d).", wlvif
->role_id
);
2064 mutex_lock(&wl
->mutex
);
2066 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2069 /* Call mac80211 connection loss */
2070 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2073 vif
= wl12xx_wlvif_to_vif(wlvif
);
2074 ieee80211_connection_loss(vif
);
2076 mutex_unlock(&wl
->mutex
);
2079 static void wlcore_pending_auth_complete_work(struct work_struct
*work
)
2081 struct delayed_work
*dwork
;
2083 struct wl12xx_vif
*wlvif
;
2084 unsigned long time_spare
;
2087 dwork
= to_delayed_work(work
);
2088 wlvif
= container_of(dwork
, struct wl12xx_vif
,
2089 pending_auth_complete_work
);
2092 mutex_lock(&wl
->mutex
);
2094 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2098 * Make sure a second really passed since the last auth reply. Maybe
2099 * a second auth reply arrived while we were stuck on the mutex.
2100 * Check for a little less than the timeout to protect from scheduler
2103 time_spare
= jiffies
+
2104 msecs_to_jiffies(WLCORE_PEND_AUTH_ROC_TIMEOUT
- 50);
2105 if (!time_after(time_spare
, wlvif
->pending_auth_reply_time
))
2108 ret
= wl1271_ps_elp_wakeup(wl
);
2112 /* cancel the ROC if active */
2113 wlcore_update_inconn_sta(wl
, wlvif
, NULL
, false);
2115 wl1271_ps_elp_sleep(wl
);
2117 mutex_unlock(&wl
->mutex
);
2120 static int wl12xx_allocate_rate_policy(struct wl1271
*wl
, u8
*idx
)
2122 u8 policy
= find_first_zero_bit(wl
->rate_policies_map
,
2123 WL12XX_MAX_RATE_POLICIES
);
2124 if (policy
>= WL12XX_MAX_RATE_POLICIES
)
2127 __set_bit(policy
, wl
->rate_policies_map
);
2132 static void wl12xx_free_rate_policy(struct wl1271
*wl
, u8
*idx
)
2134 if (WARN_ON(*idx
>= WL12XX_MAX_RATE_POLICIES
))
2137 __clear_bit(*idx
, wl
->rate_policies_map
);
2138 *idx
= WL12XX_MAX_RATE_POLICIES
;
2141 static int wlcore_allocate_klv_template(struct wl1271
*wl
, u8
*idx
)
2143 u8 policy
= find_first_zero_bit(wl
->klv_templates_map
,
2144 WLCORE_MAX_KLV_TEMPLATES
);
2145 if (policy
>= WLCORE_MAX_KLV_TEMPLATES
)
2148 __set_bit(policy
, wl
->klv_templates_map
);
2153 static void wlcore_free_klv_template(struct wl1271
*wl
, u8
*idx
)
2155 if (WARN_ON(*idx
>= WLCORE_MAX_KLV_TEMPLATES
))
2158 __clear_bit(*idx
, wl
->klv_templates_map
);
2159 *idx
= WLCORE_MAX_KLV_TEMPLATES
;
2162 static u8
wl12xx_get_role_type(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2164 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2166 switch (wlvif
->bss_type
) {
2167 case BSS_TYPE_AP_BSS
:
2169 return WL1271_ROLE_P2P_GO
;
2170 else if (ieee80211_vif_is_mesh(vif
))
2171 return WL1271_ROLE_MESH_POINT
;
2173 return WL1271_ROLE_AP
;
2175 case BSS_TYPE_STA_BSS
:
2177 return WL1271_ROLE_P2P_CL
;
2179 return WL1271_ROLE_STA
;
2182 return WL1271_ROLE_IBSS
;
2185 wl1271_error("invalid bss_type: %d", wlvif
->bss_type
);
2187 return WL12XX_INVALID_ROLE_TYPE
;
2190 static int wl12xx_init_vif_data(struct wl1271
*wl
, struct ieee80211_vif
*vif
)
2192 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2195 /* clear everything but the persistent data */
2196 memset(wlvif
, 0, offsetof(struct wl12xx_vif
, persistent
));
2198 switch (ieee80211_vif_type_p2p(vif
)) {
2199 case NL80211_IFTYPE_P2P_CLIENT
:
2202 case NL80211_IFTYPE_STATION
:
2203 case NL80211_IFTYPE_P2P_DEVICE
:
2204 wlvif
->bss_type
= BSS_TYPE_STA_BSS
;
2206 case NL80211_IFTYPE_ADHOC
:
2207 wlvif
->bss_type
= BSS_TYPE_IBSS
;
2209 case NL80211_IFTYPE_P2P_GO
:
2212 case NL80211_IFTYPE_AP
:
2213 case NL80211_IFTYPE_MESH_POINT
:
2214 wlvif
->bss_type
= BSS_TYPE_AP_BSS
;
2217 wlvif
->bss_type
= MAX_BSS_TYPE
;
2221 wlvif
->role_id
= WL12XX_INVALID_ROLE_ID
;
2222 wlvif
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
2223 wlvif
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
2225 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2226 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2227 /* init sta/ibss data */
2228 wlvif
->sta
.hlid
= WL12XX_INVALID_LINK_ID
;
2229 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.basic_rate_idx
);
2230 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.ap_rate_idx
);
2231 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.p2p_rate_idx
);
2232 wlcore_allocate_klv_template(wl
, &wlvif
->sta
.klv_template_id
);
2233 wlvif
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
2234 wlvif
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
2235 wlvif
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
2238 wlvif
->ap
.bcast_hlid
= WL12XX_INVALID_LINK_ID
;
2239 wlvif
->ap
.global_hlid
= WL12XX_INVALID_LINK_ID
;
2240 wl12xx_allocate_rate_policy(wl
, &wlvif
->ap
.mgmt_rate_idx
);
2241 wl12xx_allocate_rate_policy(wl
, &wlvif
->ap
.bcast_rate_idx
);
2242 for (i
= 0; i
< CONF_TX_MAX_AC_COUNT
; i
++)
2243 wl12xx_allocate_rate_policy(wl
,
2244 &wlvif
->ap
.ucast_rate_idx
[i
]);
2245 wlvif
->basic_rate_set
= CONF_TX_ENABLED_RATES
;
2247 * TODO: check if basic_rate shouldn't be
2248 * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2249 * instead (the same thing for STA above).
2251 wlvif
->basic_rate
= CONF_TX_ENABLED_RATES
;
2252 /* TODO: this seems to be used only for STA, check it */
2253 wlvif
->rate_set
= CONF_TX_ENABLED_RATES
;
2256 wlvif
->bitrate_masks
[NL80211_BAND_2GHZ
] = wl
->conf
.tx
.basic_rate
;
2257 wlvif
->bitrate_masks
[NL80211_BAND_5GHZ
] = wl
->conf
.tx
.basic_rate_5
;
2258 wlvif
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
2261 * mac80211 configures some values globally, while we treat them
2262 * per-interface. thus, on init, we have to copy them from wl
2264 wlvif
->band
= wl
->band
;
2265 wlvif
->channel
= wl
->channel
;
2266 wlvif
->power_level
= wl
->power_level
;
2267 wlvif
->channel_type
= wl
->channel_type
;
2269 INIT_WORK(&wlvif
->rx_streaming_enable_work
,
2270 wl1271_rx_streaming_enable_work
);
2271 INIT_WORK(&wlvif
->rx_streaming_disable_work
,
2272 wl1271_rx_streaming_disable_work
);
2273 INIT_WORK(&wlvif
->rc_update_work
, wlcore_rc_update_work
);
2274 INIT_DELAYED_WORK(&wlvif
->channel_switch_work
,
2275 wlcore_channel_switch_work
);
2276 INIT_DELAYED_WORK(&wlvif
->connection_loss_work
,
2277 wlcore_connection_loss_work
);
2278 INIT_DELAYED_WORK(&wlvif
->pending_auth_complete_work
,
2279 wlcore_pending_auth_complete_work
);
2280 INIT_LIST_HEAD(&wlvif
->list
);
2282 setup_timer(&wlvif
->rx_streaming_timer
, wl1271_rx_streaming_timer
,
2283 (unsigned long) wlvif
);
2287 static int wl12xx_init_fw(struct wl1271
*wl
)
2289 int retries
= WL1271_BOOT_RETRIES
;
2290 bool booted
= false;
2291 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
2296 ret
= wl12xx_chip_wakeup(wl
, false);
2300 ret
= wl
->ops
->boot(wl
);
2304 ret
= wl1271_hw_init(wl
);
2312 mutex_unlock(&wl
->mutex
);
2313 /* Unlocking the mutex in the middle of handling is
2314 inherently unsafe. In this case we deem it safe to do,
2315 because we need to let any possibly pending IRQ out of
2316 the system (and while we are WLCORE_STATE_OFF the IRQ
2317 work function will not do anything.) Also, any other
2318 possible concurrent operations will fail due to the
2319 current state, hence the wl1271 struct should be safe. */
2320 wlcore_disable_interrupts(wl
);
2321 wl1271_flush_deferred_work(wl
);
2322 cancel_work_sync(&wl
->netstack_work
);
2323 mutex_lock(&wl
->mutex
);
2325 wl1271_power_off(wl
);
2329 wl1271_error("firmware boot failed despite %d retries",
2330 WL1271_BOOT_RETRIES
);
2334 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
2336 /* update hw/fw version info in wiphy struct */
2337 wiphy
->hw_version
= wl
->chip
.id
;
2338 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
2339 sizeof(wiphy
->fw_version
));
2342 * Now we know if 11a is supported (info from the NVS), so disable
2343 * 11a channels if not supported
2345 if (!wl
->enable_11a
)
2346 wiphy
->bands
[NL80211_BAND_5GHZ
]->n_channels
= 0;
2348 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
2349 wl
->enable_11a
? "" : "not ");
2351 wl
->state
= WLCORE_STATE_ON
;
2356 static bool wl12xx_dev_role_started(struct wl12xx_vif
*wlvif
)
2358 return wlvif
->dev_hlid
!= WL12XX_INVALID_LINK_ID
;
2362 * Check whether a fw switch (i.e. moving from one loaded
2363 * fw to another) is needed. This function is also responsible
2364 * for updating wl->last_vif_count, so it must be called before
2365 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2368 static bool wl12xx_need_fw_change(struct wl1271
*wl
,
2369 struct vif_counter_data vif_counter_data
,
2372 enum wl12xx_fw_type current_fw
= wl
->fw_type
;
2373 u8 vif_count
= vif_counter_data
.counter
;
2375 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
))
2378 /* increase the vif count if this is a new vif */
2379 if (add
&& !vif_counter_data
.cur_vif_running
)
2382 wl
->last_vif_count
= vif_count
;
2384 /* no need for fw change if the device is OFF */
2385 if (wl
->state
== WLCORE_STATE_OFF
)
2388 /* no need for fw change if a single fw is used */
2389 if (!wl
->mr_fw_name
)
2392 if (vif_count
> 1 && current_fw
== WL12XX_FW_TYPE_NORMAL
)
2394 if (vif_count
<= 1 && current_fw
== WL12XX_FW_TYPE_MULTI
)
2401 * Enter "forced psm". Make sure the sta is in psm against the ap,
2402 * to make the fw switch a bit more disconnection-persistent.
2404 static void wl12xx_force_active_psm(struct wl1271
*wl
)
2406 struct wl12xx_vif
*wlvif
;
2408 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
2409 wl1271_ps_set_mode(wl
, wlvif
, STATION_POWER_SAVE_MODE
);
2413 struct wlcore_hw_queue_iter_data
{
2414 unsigned long hw_queue_map
[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES
)];
2416 struct ieee80211_vif
*vif
;
2417 /* is the current vif among those iterated */
2421 static void wlcore_hw_queue_iter(void *data
, u8
*mac
,
2422 struct ieee80211_vif
*vif
)
2424 struct wlcore_hw_queue_iter_data
*iter_data
= data
;
2426 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
||
2427 WARN_ON_ONCE(vif
->hw_queue
[0] == IEEE80211_INVAL_HW_QUEUE
))
2430 if (iter_data
->cur_running
|| vif
== iter_data
->vif
) {
2431 iter_data
->cur_running
= true;
2435 __set_bit(vif
->hw_queue
[0] / NUM_TX_QUEUES
, iter_data
->hw_queue_map
);
2438 static int wlcore_allocate_hw_queue_base(struct wl1271
*wl
,
2439 struct wl12xx_vif
*wlvif
)
2441 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2442 struct wlcore_hw_queue_iter_data iter_data
= {};
2445 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
2446 vif
->cab_queue
= IEEE80211_INVAL_HW_QUEUE
;
2450 iter_data
.vif
= vif
;
2452 /* mark all bits taken by active interfaces */
2453 ieee80211_iterate_active_interfaces_atomic(wl
->hw
,
2454 IEEE80211_IFACE_ITER_RESUME_ALL
,
2455 wlcore_hw_queue_iter
, &iter_data
);
2457 /* the current vif is already running in mac80211 (resume/recovery) */
2458 if (iter_data
.cur_running
) {
2459 wlvif
->hw_queue_base
= vif
->hw_queue
[0];
2460 wl1271_debug(DEBUG_MAC80211
,
2461 "using pre-allocated hw queue base %d",
2462 wlvif
->hw_queue_base
);
2464 /* interface type might have changed type */
2465 goto adjust_cab_queue
;
2468 q_base
= find_first_zero_bit(iter_data
.hw_queue_map
,
2469 WLCORE_NUM_MAC_ADDRESSES
);
2470 if (q_base
>= WLCORE_NUM_MAC_ADDRESSES
)
2473 wlvif
->hw_queue_base
= q_base
* NUM_TX_QUEUES
;
2474 wl1271_debug(DEBUG_MAC80211
, "allocating hw queue base: %d",
2475 wlvif
->hw_queue_base
);
2477 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
2478 wl
->queue_stop_reasons
[wlvif
->hw_queue_base
+ i
] = 0;
2479 /* register hw queues in mac80211 */
2480 vif
->hw_queue
[i
] = wlvif
->hw_queue_base
+ i
;
2484 /* the last places are reserved for cab queues per interface */
2485 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
2486 vif
->cab_queue
= NUM_TX_QUEUES
* WLCORE_NUM_MAC_ADDRESSES
+
2487 wlvif
->hw_queue_base
/ NUM_TX_QUEUES
;
2489 vif
->cab_queue
= IEEE80211_INVAL_HW_QUEUE
;
2494 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
2495 struct ieee80211_vif
*vif
)
2497 struct wl1271
*wl
= hw
->priv
;
2498 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2499 struct vif_counter_data vif_count
;
2504 wl1271_error("Adding Interface not allowed while in PLT mode");
2508 vif
->driver_flags
|= IEEE80211_VIF_BEACON_FILTER
|
2509 IEEE80211_VIF_SUPPORTS_UAPSD
|
2510 IEEE80211_VIF_SUPPORTS_CQM_RSSI
;
2512 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
2513 ieee80211_vif_type_p2p(vif
), vif
->addr
);
2515 wl12xx_get_vif_count(hw
, vif
, &vif_count
);
2517 mutex_lock(&wl
->mutex
);
2518 ret
= wl1271_ps_elp_wakeup(wl
);
2523 * in some very corner case HW recovery scenarios its possible to
2524 * get here before __wl1271_op_remove_interface is complete, so
2525 * opt out if that is the case.
2527 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
) ||
2528 test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)) {
2534 ret
= wl12xx_init_vif_data(wl
, vif
);
2539 role_type
= wl12xx_get_role_type(wl
, wlvif
);
2540 if (role_type
== WL12XX_INVALID_ROLE_TYPE
) {
2545 ret
= wlcore_allocate_hw_queue_base(wl
, wlvif
);
2549 if (wl12xx_need_fw_change(wl
, vif_count
, true)) {
2550 wl12xx_force_active_psm(wl
);
2551 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
);
2552 mutex_unlock(&wl
->mutex
);
2553 wl1271_recovery_work(&wl
->recovery_work
);
2558 * TODO: after the nvs issue will be solved, move this block
2559 * to start(), and make sure here the driver is ON.
2561 if (wl
->state
== WLCORE_STATE_OFF
) {
2563 * we still need this in order to configure the fw
2564 * while uploading the nvs
2566 memcpy(wl
->addresses
[0].addr
, vif
->addr
, ETH_ALEN
);
2568 ret
= wl12xx_init_fw(wl
);
2573 if (!wlcore_is_p2p_mgmt(wlvif
)) {
2574 ret
= wl12xx_cmd_role_enable(wl
, vif
->addr
,
2575 role_type
, &wlvif
->role_id
);
2579 ret
= wl1271_init_vif_specific(wl
, vif
);
2584 ret
= wl12xx_cmd_role_enable(wl
, vif
->addr
, WL1271_ROLE_DEVICE
,
2585 &wlvif
->dev_role_id
);
2589 /* needed mainly for configuring rate policies */
2590 ret
= wl1271_sta_hw_init(wl
, wlvif
);
2595 list_add(&wlvif
->list
, &wl
->wlvif_list
);
2596 set_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
);
2598 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
2603 wl1271_ps_elp_sleep(wl
);
2605 mutex_unlock(&wl
->mutex
);
2610 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
2611 struct ieee80211_vif
*vif
,
2612 bool reset_tx_queues
)
2614 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2616 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
2618 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
2620 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
2623 /* because of hardware recovery, we may get here twice */
2624 if (wl
->state
== WLCORE_STATE_OFF
)
2627 wl1271_info("down");
2629 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
&&
2630 wl
->scan_wlvif
== wlvif
) {
2631 struct cfg80211_scan_info info
= {
2636 * Rearm the tx watchdog just before idling scan. This
2637 * prevents just-finished scans from triggering the watchdog
2639 wl12xx_rearm_tx_watchdog_locked(wl
);
2641 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2642 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2643 wl
->scan_wlvif
= NULL
;
2644 wl
->scan
.req
= NULL
;
2645 ieee80211_scan_completed(wl
->hw
, &info
);
2648 if (wl
->sched_vif
== wlvif
)
2649 wl
->sched_vif
= NULL
;
2651 if (wl
->roc_vif
== vif
) {
2653 ieee80211_remain_on_channel_expired(wl
->hw
);
2656 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
)) {
2657 /* disable active roles */
2658 ret
= wl1271_ps_elp_wakeup(wl
);
2662 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2663 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2664 if (wl12xx_dev_role_started(wlvif
))
2665 wl12xx_stop_dev(wl
, wlvif
);
2668 if (!wlcore_is_p2p_mgmt(wlvif
)) {
2669 ret
= wl12xx_cmd_role_disable(wl
, &wlvif
->role_id
);
2673 ret
= wl12xx_cmd_role_disable(wl
, &wlvif
->dev_role_id
);
2678 wl1271_ps_elp_sleep(wl
);
2681 wl12xx_tx_reset_wlvif(wl
, wlvif
);
2683 /* clear all hlids (except system_hlid) */
2684 wlvif
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
2686 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2687 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2688 wlvif
->sta
.hlid
= WL12XX_INVALID_LINK_ID
;
2689 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.basic_rate_idx
);
2690 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.ap_rate_idx
);
2691 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.p2p_rate_idx
);
2692 wlcore_free_klv_template(wl
, &wlvif
->sta
.klv_template_id
);
2694 wlvif
->ap
.bcast_hlid
= WL12XX_INVALID_LINK_ID
;
2695 wlvif
->ap
.global_hlid
= WL12XX_INVALID_LINK_ID
;
2696 wl12xx_free_rate_policy(wl
, &wlvif
->ap
.mgmt_rate_idx
);
2697 wl12xx_free_rate_policy(wl
, &wlvif
->ap
.bcast_rate_idx
);
2698 for (i
= 0; i
< CONF_TX_MAX_AC_COUNT
; i
++)
2699 wl12xx_free_rate_policy(wl
,
2700 &wlvif
->ap
.ucast_rate_idx
[i
]);
2701 wl1271_free_ap_keys(wl
, wlvif
);
2704 dev_kfree_skb(wlvif
->probereq
);
2705 wlvif
->probereq
= NULL
;
2706 if (wl
->last_wlvif
== wlvif
)
2707 wl
->last_wlvif
= NULL
;
2708 list_del(&wlvif
->list
);
2709 memset(wlvif
->ap
.sta_hlid_map
, 0, sizeof(wlvif
->ap
.sta_hlid_map
));
2710 wlvif
->role_id
= WL12XX_INVALID_ROLE_ID
;
2711 wlvif
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
2719 * Last AP, have more stations. Configure sleep auth according to STA.
2720 * Don't do thin on unintended recovery.
2722 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
) &&
2723 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
))
2726 if (wl
->ap_count
== 0 && is_ap
) {
2727 /* mask ap events */
2728 wl
->event_mask
&= ~wl
->ap_event_mask
;
2729 wl1271_event_unmask(wl
);
2732 if (wl
->ap_count
== 0 && is_ap
&& wl
->sta_count
) {
2733 u8 sta_auth
= wl
->conf
.conn
.sta_sleep_auth
;
2734 /* Configure for power according to debugfs */
2735 if (sta_auth
!= WL1271_PSM_ILLEGAL
)
2736 wl1271_acx_sleep_auth(wl
, sta_auth
);
2737 /* Configure for ELP power saving */
2739 wl1271_acx_sleep_auth(wl
, WL1271_PSM_ELP
);
2743 mutex_unlock(&wl
->mutex
);
2745 del_timer_sync(&wlvif
->rx_streaming_timer
);
2746 cancel_work_sync(&wlvif
->rx_streaming_enable_work
);
2747 cancel_work_sync(&wlvif
->rx_streaming_disable_work
);
2748 cancel_work_sync(&wlvif
->rc_update_work
);
2749 cancel_delayed_work_sync(&wlvif
->connection_loss_work
);
2750 cancel_delayed_work_sync(&wlvif
->channel_switch_work
);
2751 cancel_delayed_work_sync(&wlvif
->pending_auth_complete_work
);
2753 mutex_lock(&wl
->mutex
);
2756 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
2757 struct ieee80211_vif
*vif
)
2759 struct wl1271
*wl
= hw
->priv
;
2760 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2761 struct wl12xx_vif
*iter
;
2762 struct vif_counter_data vif_count
;
2764 wl12xx_get_vif_count(hw
, vif
, &vif_count
);
2765 mutex_lock(&wl
->mutex
);
2767 if (wl
->state
== WLCORE_STATE_OFF
||
2768 !test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
2772 * wl->vif can be null here if someone shuts down the interface
2773 * just when hardware recovery has been started.
2775 wl12xx_for_each_wlvif(wl
, iter
) {
2779 __wl1271_op_remove_interface(wl
, vif
, true);
2782 WARN_ON(iter
!= wlvif
);
2783 if (wl12xx_need_fw_change(wl
, vif_count
, false)) {
2784 wl12xx_force_active_psm(wl
);
2785 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
);
2786 wl12xx_queue_recovery_work(wl
);
2789 mutex_unlock(&wl
->mutex
);
2792 static int wl12xx_op_change_interface(struct ieee80211_hw
*hw
,
2793 struct ieee80211_vif
*vif
,
2794 enum nl80211_iftype new_type
, bool p2p
)
2796 struct wl1271
*wl
= hw
->priv
;
2799 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
);
2800 wl1271_op_remove_interface(hw
, vif
);
2802 vif
->type
= new_type
;
2804 ret
= wl1271_op_add_interface(hw
, vif
);
2806 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
);
2810 static int wlcore_join(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2813 bool is_ibss
= (wlvif
->bss_type
== BSS_TYPE_IBSS
);
2816 * One of the side effects of the JOIN command is that is clears
2817 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2818 * to a WPA/WPA2 access point will therefore kill the data-path.
2819 * Currently the only valid scenario for JOIN during association
2820 * is on roaming, in which case we will also be given new keys.
2821 * Keep the below message for now, unless it starts bothering
2822 * users who really like to roam a lot :)
2824 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2825 wl1271_info("JOIN while associated.");
2827 /* clear encryption type */
2828 wlvif
->encryption_type
= KEY_NONE
;
2831 ret
= wl12xx_cmd_role_start_ibss(wl
, wlvif
);
2833 if (wl
->quirks
& WLCORE_QUIRK_START_STA_FAILS
) {
2835 * TODO: this is an ugly workaround for wl12xx fw
2836 * bug - we are not able to tx/rx after the first
2837 * start_sta, so make dummy start+stop calls,
2838 * and then call start_sta again.
2839 * this should be fixed in the fw.
2841 wl12xx_cmd_role_start_sta(wl
, wlvif
);
2842 wl12xx_cmd_role_stop_sta(wl
, wlvif
);
2845 ret
= wl12xx_cmd_role_start_sta(wl
, wlvif
);
2851 static int wl1271_ssid_set(struct wl12xx_vif
*wlvif
, struct sk_buff
*skb
,
2855 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
2859 wl1271_error("No SSID in IEs!");
2864 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2865 wl1271_error("SSID is too long!");
2869 wlvif
->ssid_len
= ssid_len
;
2870 memcpy(wlvif
->ssid
, ptr
+2, ssid_len
);
2874 static int wlcore_set_ssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2876 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2877 struct sk_buff
*skb
;
2880 /* we currently only support setting the ssid from the ap probe req */
2881 if (wlvif
->bss_type
!= BSS_TYPE_STA_BSS
)
2884 skb
= ieee80211_ap_probereq_get(wl
->hw
, vif
);
2888 ieoffset
= offsetof(struct ieee80211_mgmt
,
2889 u
.probe_req
.variable
);
2890 wl1271_ssid_set(wlvif
, skb
, ieoffset
);
2896 static int wlcore_set_assoc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
2897 struct ieee80211_bss_conf
*bss_conf
,
2903 wlvif
->aid
= bss_conf
->aid
;
2904 wlvif
->channel_type
= cfg80211_get_chandef_type(&bss_conf
->chandef
);
2905 wlvif
->beacon_int
= bss_conf
->beacon_int
;
2906 wlvif
->wmm_enabled
= bss_conf
->qos
;
2908 set_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
);
2911 * with wl1271, we don't need to update the
2912 * beacon_int and dtim_period, because the firmware
2913 * updates it by itself when the first beacon is
2914 * received after a join.
2916 ret
= wl1271_cmd_build_ps_poll(wl
, wlvif
, wlvif
->aid
);
2921 * Get a template for hardware connection maintenance
2923 dev_kfree_skb(wlvif
->probereq
);
2924 wlvif
->probereq
= wl1271_cmd_build_ap_probe_req(wl
,
2927 ieoffset
= offsetof(struct ieee80211_mgmt
,
2928 u
.probe_req
.variable
);
2929 wl1271_ssid_set(wlvif
, wlvif
->probereq
, ieoffset
);
2931 /* enable the connection monitoring feature */
2932 ret
= wl1271_acx_conn_monit_params(wl
, wlvif
, true);
2937 * The join command disable the keep-alive mode, shut down its process,
2938 * and also clear the template config, so we need to reset it all after
2939 * the join. The acx_aid starts the keep-alive process, and the order
2940 * of the commands below is relevant.
2942 ret
= wl1271_acx_keep_alive_mode(wl
, wlvif
, true);
2946 ret
= wl1271_acx_aid(wl
, wlvif
, wlvif
->aid
);
2950 ret
= wl12xx_cmd_build_klv_null_data(wl
, wlvif
);
2954 ret
= wl1271_acx_keep_alive_config(wl
, wlvif
,
2955 wlvif
->sta
.klv_template_id
,
2956 ACX_KEEP_ALIVE_TPL_VALID
);
2961 * The default fw psm configuration is AUTO, while mac80211 default
2962 * setting is off (ACTIVE), so sync the fw with the correct value.
2964 ret
= wl1271_ps_set_mode(wl
, wlvif
, STATION_ACTIVE_MODE
);
2970 wl1271_tx_enabled_rates_get(wl
,
2973 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
2981 static int wlcore_unset_assoc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2984 bool sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
2986 /* make sure we are connected (sta) joined */
2988 !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2991 /* make sure we are joined (ibss) */
2993 test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED
, &wlvif
->flags
))
2997 /* use defaults when not associated */
3000 /* free probe-request template */
3001 dev_kfree_skb(wlvif
->probereq
);
3002 wlvif
->probereq
= NULL
;
3004 /* disable connection monitor features */
3005 ret
= wl1271_acx_conn_monit_params(wl
, wlvif
, false);
3009 /* Disable the keep-alive feature */
3010 ret
= wl1271_acx_keep_alive_mode(wl
, wlvif
, false);
3014 /* disable beacon filtering */
3015 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, false);
3020 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
)) {
3021 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
3023 wl12xx_cmd_stop_channel_switch(wl
, wlvif
);
3024 ieee80211_chswitch_done(vif
, false);
3025 cancel_delayed_work(&wlvif
->channel_switch_work
);
3028 /* invalidate keep-alive template */
3029 wl1271_acx_keep_alive_config(wl
, wlvif
,
3030 wlvif
->sta
.klv_template_id
,
3031 ACX_KEEP_ALIVE_TPL_INVALID
);
3036 static void wl1271_set_band_rate(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
3038 wlvif
->basic_rate_set
= wlvif
->bitrate_masks
[wlvif
->band
];
3039 wlvif
->rate_set
= wlvif
->basic_rate_set
;
3042 static void wl1271_sta_handle_idle(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3045 bool cur_idle
= !test_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
3047 if (idle
== cur_idle
)
3051 clear_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
3053 /* The current firmware only supports sched_scan in idle */
3054 if (wl
->sched_vif
== wlvif
)
3055 wl
->ops
->sched_scan_stop(wl
, wlvif
);
3057 set_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
3061 static int wl12xx_config_vif(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3062 struct ieee80211_conf
*conf
, u32 changed
)
3066 if (wlcore_is_p2p_mgmt(wlvif
))
3069 if (conf
->power_level
!= wlvif
->power_level
) {
3070 ret
= wl1271_acx_tx_power(wl
, wlvif
, conf
->power_level
);
3074 wlvif
->power_level
= conf
->power_level
;
3080 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
3082 struct wl1271
*wl
= hw
->priv
;
3083 struct wl12xx_vif
*wlvif
;
3084 struct ieee80211_conf
*conf
= &hw
->conf
;
3087 wl1271_debug(DEBUG_MAC80211
, "mac80211 config psm %s power %d %s"
3089 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
3091 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
3094 mutex_lock(&wl
->mutex
);
3096 if (changed
& IEEE80211_CONF_CHANGE_POWER
)
3097 wl
->power_level
= conf
->power_level
;
3099 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3102 ret
= wl1271_ps_elp_wakeup(wl
);
3106 /* configure each interface */
3107 wl12xx_for_each_wlvif(wl
, wlvif
) {
3108 ret
= wl12xx_config_vif(wl
, wlvif
, conf
, changed
);
3114 wl1271_ps_elp_sleep(wl
);
3117 mutex_unlock(&wl
->mutex
);
3122 struct wl1271_filter_params
{
3125 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
3128 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
3129 struct netdev_hw_addr_list
*mc_list
)
3131 struct wl1271_filter_params
*fp
;
3132 struct netdev_hw_addr
*ha
;
3134 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
3136 wl1271_error("Out of memory setting filters.");
3140 /* update multicast filtering parameters */
3141 fp
->mc_list_length
= 0;
3142 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
3143 fp
->enabled
= false;
3146 netdev_hw_addr_list_for_each(ha
, mc_list
) {
3147 memcpy(fp
->mc_list
[fp
->mc_list_length
],
3148 ha
->addr
, ETH_ALEN
);
3149 fp
->mc_list_length
++;
3153 return (u64
)(unsigned long)fp
;
3156 #define WL1271_SUPPORTED_FILTERS (FIF_ALLMULTI | \
3158 FIF_BCN_PRBRESP_PROMISC | \
3162 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
3163 unsigned int changed
,
3164 unsigned int *total
, u64 multicast
)
3166 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
3167 struct wl1271
*wl
= hw
->priv
;
3168 struct wl12xx_vif
*wlvif
;
3172 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
3173 " total %x", changed
, *total
);
3175 mutex_lock(&wl
->mutex
);
3177 *total
&= WL1271_SUPPORTED_FILTERS
;
3178 changed
&= WL1271_SUPPORTED_FILTERS
;
3180 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3183 ret
= wl1271_ps_elp_wakeup(wl
);
3187 wl12xx_for_each_wlvif(wl
, wlvif
) {
3188 if (wlcore_is_p2p_mgmt(wlvif
))
3191 if (wlvif
->bss_type
!= BSS_TYPE_AP_BSS
) {
3192 if (*total
& FIF_ALLMULTI
)
3193 ret
= wl1271_acx_group_address_tbl(wl
, wlvif
,
3197 ret
= wl1271_acx_group_address_tbl(wl
, wlvif
,
3200 fp
->mc_list_length
);
3206 * If interface in AP mode and created with allmulticast then disable
3207 * the firmware filters so that all multicast packets are passed
3208 * This is mandatory for MDNS based discovery protocols
3210 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
) {
3211 if (*total
& FIF_ALLMULTI
) {
3212 ret
= wl1271_acx_group_address_tbl(wl
, wlvif
,
3222 * the fw doesn't provide an api to configure the filters. instead,
3223 * the filters configuration is based on the active roles / ROC
3228 wl1271_ps_elp_sleep(wl
);
3231 mutex_unlock(&wl
->mutex
);
3235 static int wl1271_record_ap_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3236 u8 id
, u8 key_type
, u8 key_size
,
3237 const u8
*key
, u8 hlid
, u32 tx_seq_32
,
3240 struct wl1271_ap_key
*ap_key
;
3243 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
3245 if (key_size
> MAX_KEY_SIZE
)
3249 * Find next free entry in ap_keys. Also check we are not replacing
3252 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3253 if (wlvif
->ap
.recorded_keys
[i
] == NULL
)
3256 if (wlvif
->ap
.recorded_keys
[i
]->id
== id
) {
3257 wl1271_warning("trying to record key replacement");
3262 if (i
== MAX_NUM_KEYS
)
3265 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
3270 ap_key
->key_type
= key_type
;
3271 ap_key
->key_size
= key_size
;
3272 memcpy(ap_key
->key
, key
, key_size
);
3273 ap_key
->hlid
= hlid
;
3274 ap_key
->tx_seq_32
= tx_seq_32
;
3275 ap_key
->tx_seq_16
= tx_seq_16
;
3277 wlvif
->ap
.recorded_keys
[i
] = ap_key
;
3281 static void wl1271_free_ap_keys(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
3285 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3286 kfree(wlvif
->ap
.recorded_keys
[i
]);
3287 wlvif
->ap
.recorded_keys
[i
] = NULL
;
3291 static int wl1271_ap_init_hwenc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
3294 struct wl1271_ap_key
*key
;
3295 bool wep_key_added
= false;
3297 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3299 if (wlvif
->ap
.recorded_keys
[i
] == NULL
)
3302 key
= wlvif
->ap
.recorded_keys
[i
];
3304 if (hlid
== WL12XX_INVALID_LINK_ID
)
3305 hlid
= wlvif
->ap
.bcast_hlid
;
3307 ret
= wl1271_cmd_set_ap_key(wl
, wlvif
, KEY_ADD_OR_REPLACE
,
3308 key
->id
, key
->key_type
,
3309 key
->key_size
, key
->key
,
3310 hlid
, key
->tx_seq_32
,
3315 if (key
->key_type
== KEY_WEP
)
3316 wep_key_added
= true;
3319 if (wep_key_added
) {
3320 ret
= wl12xx_cmd_set_default_wep_key(wl
, wlvif
->default_key
,
3321 wlvif
->ap
.bcast_hlid
);
3327 wl1271_free_ap_keys(wl
, wlvif
);
3331 static int wl1271_set_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3332 u16 action
, u8 id
, u8 key_type
,
3333 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
3334 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
3337 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
3340 struct wl1271_station
*wl_sta
;
3344 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3345 hlid
= wl_sta
->hlid
;
3347 hlid
= wlvif
->ap
.bcast_hlid
;
3350 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
3352 * We do not support removing keys after AP shutdown.
3353 * Pretend we do to make mac80211 happy.
3355 if (action
!= KEY_ADD_OR_REPLACE
)
3358 ret
= wl1271_record_ap_key(wl
, wlvif
, id
,
3360 key
, hlid
, tx_seq_32
,
3363 ret
= wl1271_cmd_set_ap_key(wl
, wlvif
, action
,
3364 id
, key_type
, key_size
,
3365 key
, hlid
, tx_seq_32
,
3373 static const u8 bcast_addr
[ETH_ALEN
] = {
3374 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
3377 addr
= sta
? sta
->addr
: bcast_addr
;
3379 if (is_zero_ether_addr(addr
)) {
3380 /* We dont support TX only encryption */
3384 /* The wl1271 does not allow to remove unicast keys - they
3385 will be cleared automatically on next CMD_JOIN. Ignore the
3386 request silently, as we dont want the mac80211 to emit
3387 an error message. */
3388 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
3391 /* don't remove key if hlid was already deleted */
3392 if (action
== KEY_REMOVE
&&
3393 wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
)
3396 ret
= wl1271_cmd_set_sta_key(wl
, wlvif
, action
,
3397 id
, key_type
, key_size
,
3398 key
, addr
, tx_seq_32
,
3408 static int wlcore_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
3409 struct ieee80211_vif
*vif
,
3410 struct ieee80211_sta
*sta
,
3411 struct ieee80211_key_conf
*key_conf
)
3413 struct wl1271
*wl
= hw
->priv
;
3415 bool might_change_spare
=
3416 key_conf
->cipher
== WL1271_CIPHER_SUITE_GEM
||
3417 key_conf
->cipher
== WLAN_CIPHER_SUITE_TKIP
;
3419 if (might_change_spare
) {
3421 * stop the queues and flush to ensure the next packets are
3422 * in sync with FW spare block accounting
3424 wlcore_stop_queues(wl
, WLCORE_QUEUE_STOP_REASON_SPARE_BLK
);
3425 wl1271_tx_flush(wl
);
3428 mutex_lock(&wl
->mutex
);
3430 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3432 goto out_wake_queues
;
3435 ret
= wl1271_ps_elp_wakeup(wl
);
3437 goto out_wake_queues
;
3439 ret
= wlcore_hw_set_key(wl
, cmd
, vif
, sta
, key_conf
);
3441 wl1271_ps_elp_sleep(wl
);
3444 if (might_change_spare
)
3445 wlcore_wake_queues(wl
, WLCORE_QUEUE_STOP_REASON_SPARE_BLK
);
3447 mutex_unlock(&wl
->mutex
);
3452 int wlcore_set_key(struct wl1271
*wl
, enum set_key_cmd cmd
,
3453 struct ieee80211_vif
*vif
,
3454 struct ieee80211_sta
*sta
,
3455 struct ieee80211_key_conf
*key_conf
)
3457 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3464 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
3466 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
3467 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3468 key_conf
->cipher
, key_conf
->keyidx
,
3469 key_conf
->keylen
, key_conf
->flags
);
3470 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
3472 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
3474 struct wl1271_station
*wl_sta
= (void *)sta
->drv_priv
;
3475 hlid
= wl_sta
->hlid
;
3477 hlid
= wlvif
->ap
.bcast_hlid
;
3480 hlid
= wlvif
->sta
.hlid
;
3482 if (hlid
!= WL12XX_INVALID_LINK_ID
) {
3483 u64 tx_seq
= wl
->links
[hlid
].total_freed_pkts
;
3484 tx_seq_32
= WL1271_TX_SECURITY_HI32(tx_seq
);
3485 tx_seq_16
= WL1271_TX_SECURITY_LO16(tx_seq
);
3488 switch (key_conf
->cipher
) {
3489 case WLAN_CIPHER_SUITE_WEP40
:
3490 case WLAN_CIPHER_SUITE_WEP104
:
3493 key_conf
->hw_key_idx
= key_conf
->keyidx
;
3495 case WLAN_CIPHER_SUITE_TKIP
:
3496 key_type
= KEY_TKIP
;
3497 key_conf
->hw_key_idx
= key_conf
->keyidx
;
3499 case WLAN_CIPHER_SUITE_CCMP
:
3501 key_conf
->flags
|= IEEE80211_KEY_FLAG_PUT_IV_SPACE
;
3503 case WL1271_CIPHER_SUITE_GEM
:
3507 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
3514 ret
= wl1271_set_key(wl
, wlvif
, KEY_ADD_OR_REPLACE
,
3515 key_conf
->keyidx
, key_type
,
3516 key_conf
->keylen
, key_conf
->key
,
3517 tx_seq_32
, tx_seq_16
, sta
);
3519 wl1271_error("Could not add or replace key");
3524 * reconfiguring arp response if the unicast (or common)
3525 * encryption key type was changed
3527 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
3528 (sta
|| key_type
== KEY_WEP
) &&
3529 wlvif
->encryption_type
!= key_type
) {
3530 wlvif
->encryption_type
= key_type
;
3531 ret
= wl1271_cmd_build_arp_rsp(wl
, wlvif
);
3533 wl1271_warning("build arp rsp failed: %d", ret
);
3540 ret
= wl1271_set_key(wl
, wlvif
, KEY_REMOVE
,
3541 key_conf
->keyidx
, key_type
,
3542 key_conf
->keylen
, key_conf
->key
,
3545 wl1271_error("Could not remove key");
3551 wl1271_error("Unsupported key cmd 0x%x", cmd
);
3557 EXPORT_SYMBOL_GPL(wlcore_set_key
);
3559 static void wl1271_op_set_default_key_idx(struct ieee80211_hw
*hw
,
3560 struct ieee80211_vif
*vif
,
3563 struct wl1271
*wl
= hw
->priv
;
3564 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3567 wl1271_debug(DEBUG_MAC80211
, "mac80211 set default key idx %d",
3570 /* we don't handle unsetting of default key */
3574 mutex_lock(&wl
->mutex
);
3576 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3581 ret
= wl1271_ps_elp_wakeup(wl
);
3585 wlvif
->default_key
= key_idx
;
3587 /* the default WEP key needs to be configured at least once */
3588 if (wlvif
->encryption_type
== KEY_WEP
) {
3589 ret
= wl12xx_cmd_set_default_wep_key(wl
,
3597 wl1271_ps_elp_sleep(wl
);
3600 mutex_unlock(&wl
->mutex
);
3603 void wlcore_regdomain_config(struct wl1271
*wl
)
3607 if (!(wl
->quirks
& WLCORE_QUIRK_REGDOMAIN_CONF
))
3610 mutex_lock(&wl
->mutex
);
3612 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3615 ret
= wl1271_ps_elp_wakeup(wl
);
3619 ret
= wlcore_cmd_regdomain_config_locked(wl
);
3621 wl12xx_queue_recovery_work(wl
);
3625 wl1271_ps_elp_sleep(wl
);
3627 mutex_unlock(&wl
->mutex
);
3630 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
3631 struct ieee80211_vif
*vif
,
3632 struct ieee80211_scan_request
*hw_req
)
3634 struct cfg80211_scan_request
*req
= &hw_req
->req
;
3635 struct wl1271
*wl
= hw
->priv
;
3640 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
3643 ssid
= req
->ssids
[0].ssid
;
3644 len
= req
->ssids
[0].ssid_len
;
3647 mutex_lock(&wl
->mutex
);
3649 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3651 * We cannot return -EBUSY here because cfg80211 will expect
3652 * a call to ieee80211_scan_completed if we do - in this case
3653 * there won't be any call.
3659 ret
= wl1271_ps_elp_wakeup(wl
);
3663 /* fail if there is any role in ROC */
3664 if (find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
) {
3665 /* don't allow scanning right now */
3670 ret
= wlcore_scan(hw
->priv
, vif
, ssid
, len
, req
);
3672 wl1271_ps_elp_sleep(wl
);
3674 mutex_unlock(&wl
->mutex
);
3679 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw
*hw
,
3680 struct ieee80211_vif
*vif
)
3682 struct wl1271
*wl
= hw
->priv
;
3683 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3684 struct cfg80211_scan_info info
= {
3689 wl1271_debug(DEBUG_MAC80211
, "mac80211 cancel hw scan");
3691 mutex_lock(&wl
->mutex
);
3693 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3696 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
3699 ret
= wl1271_ps_elp_wakeup(wl
);
3703 if (wl
->scan
.state
!= WL1271_SCAN_STATE_DONE
) {
3704 ret
= wl
->ops
->scan_stop(wl
, wlvif
);
3710 * Rearm the tx watchdog just before idling scan. This
3711 * prevents just-finished scans from triggering the watchdog
3713 wl12xx_rearm_tx_watchdog_locked(wl
);
3715 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
3716 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
3717 wl
->scan_wlvif
= NULL
;
3718 wl
->scan
.req
= NULL
;
3719 ieee80211_scan_completed(wl
->hw
, &info
);
3722 wl1271_ps_elp_sleep(wl
);
3724 mutex_unlock(&wl
->mutex
);
3726 cancel_delayed_work_sync(&wl
->scan_complete_work
);
3729 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
3730 struct ieee80211_vif
*vif
,
3731 struct cfg80211_sched_scan_request
*req
,
3732 struct ieee80211_scan_ies
*ies
)
3734 struct wl1271
*wl
= hw
->priv
;
3735 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3738 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
3740 mutex_lock(&wl
->mutex
);
3742 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3747 ret
= wl1271_ps_elp_wakeup(wl
);
3751 ret
= wl
->ops
->sched_scan_start(wl
, wlvif
, req
, ies
);
3755 wl
->sched_vif
= wlvif
;
3758 wl1271_ps_elp_sleep(wl
);
3760 mutex_unlock(&wl
->mutex
);
3764 static int wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
3765 struct ieee80211_vif
*vif
)
3767 struct wl1271
*wl
= hw
->priv
;
3768 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3771 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
3773 mutex_lock(&wl
->mutex
);
3775 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3778 ret
= wl1271_ps_elp_wakeup(wl
);
3782 wl
->ops
->sched_scan_stop(wl
, wlvif
);
3784 wl1271_ps_elp_sleep(wl
);
3786 mutex_unlock(&wl
->mutex
);
3791 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
3793 struct wl1271
*wl
= hw
->priv
;
3796 mutex_lock(&wl
->mutex
);
3798 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3803 ret
= wl1271_ps_elp_wakeup(wl
);
3807 ret
= wl1271_acx_frag_threshold(wl
, value
);
3809 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
3811 wl1271_ps_elp_sleep(wl
);
3814 mutex_unlock(&wl
->mutex
);
3819 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
3821 struct wl1271
*wl
= hw
->priv
;
3822 struct wl12xx_vif
*wlvif
;
3825 mutex_lock(&wl
->mutex
);
3827 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3832 ret
= wl1271_ps_elp_wakeup(wl
);
3836 wl12xx_for_each_wlvif(wl
, wlvif
) {
3837 ret
= wl1271_acx_rts_threshold(wl
, wlvif
, value
);
3839 wl1271_warning("set rts threshold failed: %d", ret
);
3841 wl1271_ps_elp_sleep(wl
);
3844 mutex_unlock(&wl
->mutex
);
3849 static void wl12xx_remove_ie(struct sk_buff
*skb
, u8 eid
, int ieoffset
)
3852 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3853 u8
*ie
= (u8
*)cfg80211_find_ie(eid
, skb
->data
+ ieoffset
,
3854 skb
->len
- ieoffset
);
3859 memmove(ie
, next
, end
- next
);
3860 skb_trim(skb
, skb
->len
- len
);
3863 static void wl12xx_remove_vendor_ie(struct sk_buff
*skb
,
3864 unsigned int oui
, u8 oui_type
,
3868 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3869 u8
*ie
= (u8
*)cfg80211_find_vendor_ie(oui
, oui_type
,
3870 skb
->data
+ ieoffset
,
3871 skb
->len
- ieoffset
);
3876 memmove(ie
, next
, end
- next
);
3877 skb_trim(skb
, skb
->len
- len
);
3880 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271
*wl
, u32 rates
,
3881 struct ieee80211_vif
*vif
)
3883 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3884 struct sk_buff
*skb
;
3887 skb
= ieee80211_proberesp_get(wl
->hw
, vif
);
3891 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3892 CMD_TEMPL_AP_PROBE_RESPONSE
,
3901 wl1271_debug(DEBUG_AP
, "probe response updated");
3902 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
, &wlvif
->flags
);
3908 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271
*wl
,
3909 struct ieee80211_vif
*vif
,
3911 size_t probe_rsp_len
,
3914 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3915 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
3916 u8 probe_rsp_templ
[WL1271_CMD_TEMPL_MAX_SIZE
];
3917 int ssid_ie_offset
, ie_offset
, templ_len
;
3920 /* no need to change probe response if the SSID is set correctly */
3921 if (wlvif
->ssid_len
> 0)
3922 return wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3923 CMD_TEMPL_AP_PROBE_RESPONSE
,
3928 if (probe_rsp_len
+ bss_conf
->ssid_len
> WL1271_CMD_TEMPL_MAX_SIZE
) {
3929 wl1271_error("probe_rsp template too big");
3933 /* start searching from IE offset */
3934 ie_offset
= offsetof(struct ieee80211_mgmt
, u
.probe_resp
.variable
);
3936 ptr
= cfg80211_find_ie(WLAN_EID_SSID
, probe_rsp_data
+ ie_offset
,
3937 probe_rsp_len
- ie_offset
);
3939 wl1271_error("No SSID in beacon!");
3943 ssid_ie_offset
= ptr
- probe_rsp_data
;
3944 ptr
+= (ptr
[1] + 2);
3946 memcpy(probe_rsp_templ
, probe_rsp_data
, ssid_ie_offset
);
3948 /* insert SSID from bss_conf */
3949 probe_rsp_templ
[ssid_ie_offset
] = WLAN_EID_SSID
;
3950 probe_rsp_templ
[ssid_ie_offset
+ 1] = bss_conf
->ssid_len
;
3951 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2,
3952 bss_conf
->ssid
, bss_conf
->ssid_len
);
3953 templ_len
= ssid_ie_offset
+ 2 + bss_conf
->ssid_len
;
3955 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2 + bss_conf
->ssid_len
,
3956 ptr
, probe_rsp_len
- (ptr
- probe_rsp_data
));
3957 templ_len
+= probe_rsp_len
- (ptr
- probe_rsp_data
);
3959 return wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3960 CMD_TEMPL_AP_PROBE_RESPONSE
,
3966 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
3967 struct ieee80211_vif
*vif
,
3968 struct ieee80211_bss_conf
*bss_conf
,
3971 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3974 if (changed
& BSS_CHANGED_ERP_SLOT
) {
3975 if (bss_conf
->use_short_slot
)
3976 ret
= wl1271_acx_slot(wl
, wlvif
, SLOT_TIME_SHORT
);
3978 ret
= wl1271_acx_slot(wl
, wlvif
, SLOT_TIME_LONG
);
3980 wl1271_warning("Set slot time failed %d", ret
);
3985 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
3986 if (bss_conf
->use_short_preamble
)
3987 wl1271_acx_set_preamble(wl
, wlvif
, ACX_PREAMBLE_SHORT
);
3989 wl1271_acx_set_preamble(wl
, wlvif
, ACX_PREAMBLE_LONG
);
3992 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
3993 if (bss_conf
->use_cts_prot
)
3994 ret
= wl1271_acx_cts_protect(wl
, wlvif
,
3997 ret
= wl1271_acx_cts_protect(wl
, wlvif
,
3998 CTSPROTECT_DISABLE
);
4000 wl1271_warning("Set ctsprotect failed %d", ret
);
4009 static int wlcore_set_beacon_template(struct wl1271
*wl
,
4010 struct ieee80211_vif
*vif
,
4013 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4014 struct ieee80211_hdr
*hdr
;
4017 int ieoffset
= offsetof(struct ieee80211_mgmt
, u
.beacon
.variable
);
4018 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
4026 wl1271_debug(DEBUG_MASTER
, "beacon updated");
4028 ret
= wl1271_ssid_set(wlvif
, beacon
, ieoffset
);
4030 dev_kfree_skb(beacon
);
4033 min_rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
4034 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
4036 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
, tmpl_id
,
4041 dev_kfree_skb(beacon
);
4045 wlvif
->wmm_enabled
=
4046 cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT
,
4047 WLAN_OUI_TYPE_MICROSOFT_WMM
,
4048 beacon
->data
+ ieoffset
,
4049 beacon
->len
- ieoffset
);
4052 * In case we already have a probe-resp beacon set explicitly
4053 * by usermode, don't use the beacon data.
4055 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
, &wlvif
->flags
))
4058 /* remove TIM ie from probe response */
4059 wl12xx_remove_ie(beacon
, WLAN_EID_TIM
, ieoffset
);
4062 * remove p2p ie from probe response.
4063 * the fw reponds to probe requests that don't include
4064 * the p2p ie. probe requests with p2p ie will be passed,
4065 * and will be responded by the supplicant (the spec
4066 * forbids including the p2p ie when responding to probe
4067 * requests that didn't include it).
4069 wl12xx_remove_vendor_ie(beacon
, WLAN_OUI_WFA
,
4070 WLAN_OUI_TYPE_WFA_P2P
, ieoffset
);
4072 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
4073 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
4074 IEEE80211_STYPE_PROBE_RESP
);
4076 ret
= wl1271_ap_set_probe_resp_tmpl_legacy(wl
, vif
,
4081 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
4082 CMD_TEMPL_PROBE_RESPONSE
,
4087 dev_kfree_skb(beacon
);
4095 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
4096 struct ieee80211_vif
*vif
,
4097 struct ieee80211_bss_conf
*bss_conf
,
4100 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4101 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
4104 if (changed
& BSS_CHANGED_BEACON_INT
) {
4105 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
4106 bss_conf
->beacon_int
);
4108 wlvif
->beacon_int
= bss_conf
->beacon_int
;
4111 if ((changed
& BSS_CHANGED_AP_PROBE_RESP
) && is_ap
) {
4112 u32 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
4114 wl1271_ap_set_probe_resp_tmpl(wl
, rate
, vif
);
4117 if (changed
& BSS_CHANGED_BEACON
) {
4118 ret
= wlcore_set_beacon_template(wl
, vif
, is_ap
);
4122 if (test_and_clear_bit(WLVIF_FLAG_BEACON_DISABLED
,
4124 ret
= wlcore_hw_dfs_master_restart(wl
, wlvif
);
4131 wl1271_error("beacon info change failed: %d", ret
);
4135 /* AP mode changes */
4136 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
4137 struct ieee80211_vif
*vif
,
4138 struct ieee80211_bss_conf
*bss_conf
,
4141 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4144 if (changed
& BSS_CHANGED_BASIC_RATES
) {
4145 u32 rates
= bss_conf
->basic_rates
;
4147 wlvif
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
,
4149 wlvif
->basic_rate
= wl1271_tx_min_rate_get(wl
,
4150 wlvif
->basic_rate_set
);
4152 ret
= wl1271_init_ap_rates(wl
, wlvif
);
4154 wl1271_error("AP rate policy change failed %d", ret
);
4158 ret
= wl1271_ap_init_templates(wl
, vif
);
4162 /* No need to set probe resp template for mesh */
4163 if (!ieee80211_vif_is_mesh(vif
)) {
4164 ret
= wl1271_ap_set_probe_resp_tmpl(wl
,
4171 ret
= wlcore_set_beacon_template(wl
, vif
, true);
4176 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
4180 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
4181 if (bss_conf
->enable_beacon
) {
4182 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
4183 ret
= wl12xx_cmd_role_start_ap(wl
, wlvif
);
4187 ret
= wl1271_ap_init_hwenc(wl
, wlvif
);
4191 set_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
);
4192 wl1271_debug(DEBUG_AP
, "started AP");
4195 if (test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
4197 * AP might be in ROC in case we have just
4198 * sent auth reply. handle it.
4200 if (test_bit(wlvif
->role_id
, wl
->roc_map
))
4201 wl12xx_croc(wl
, wlvif
->role_id
);
4203 ret
= wl12xx_cmd_role_stop_ap(wl
, wlvif
);
4207 clear_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
);
4208 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
,
4210 wl1271_debug(DEBUG_AP
, "stopped AP");
4215 ret
= wl1271_bss_erp_info_changed(wl
, vif
, bss_conf
, changed
);
4219 /* Handle HT information change */
4220 if ((changed
& BSS_CHANGED_HT
) &&
4221 (bss_conf
->chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
)) {
4222 ret
= wl1271_acx_set_ht_information(wl
, wlvif
,
4223 bss_conf
->ht_operation_mode
);
4225 wl1271_warning("Set ht information failed %d", ret
);
4234 static int wlcore_set_bssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
4235 struct ieee80211_bss_conf
*bss_conf
,
4241 wl1271_debug(DEBUG_MAC80211
,
4242 "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
4243 bss_conf
->bssid
, bss_conf
->aid
,
4244 bss_conf
->beacon_int
,
4245 bss_conf
->basic_rates
, sta_rate_set
);
4247 wlvif
->beacon_int
= bss_conf
->beacon_int
;
4248 rates
= bss_conf
->basic_rates
;
4249 wlvif
->basic_rate_set
=
4250 wl1271_tx_enabled_rates_get(wl
, rates
,
4253 wl1271_tx_min_rate_get(wl
,
4254 wlvif
->basic_rate_set
);
4258 wl1271_tx_enabled_rates_get(wl
,
4262 /* we only support sched_scan while not connected */
4263 if (wl
->sched_vif
== wlvif
)
4264 wl
->ops
->sched_scan_stop(wl
, wlvif
);
4266 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4270 ret
= wl12xx_cmd_build_null_data(wl
, wlvif
);
4274 ret
= wl1271_build_qos_null_data(wl
, wl12xx_wlvif_to_vif(wlvif
));
4278 wlcore_set_ssid(wl
, wlvif
);
4280 set_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
);
4285 static int wlcore_clear_bssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
4289 /* revert back to minimum rates for the current band */
4290 wl1271_set_band_rate(wl
, wlvif
);
4291 wlvif
->basic_rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
4293 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4297 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
4298 test_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
)) {
4299 ret
= wl12xx_cmd_role_stop_sta(wl
, wlvif
);
4304 clear_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
);
4307 /* STA/IBSS mode changes */
4308 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
4309 struct ieee80211_vif
*vif
,
4310 struct ieee80211_bss_conf
*bss_conf
,
4313 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4314 bool do_join
= false;
4315 bool is_ibss
= (wlvif
->bss_type
== BSS_TYPE_IBSS
);
4316 bool ibss_joined
= false;
4317 u32 sta_rate_set
= 0;
4319 struct ieee80211_sta
*sta
;
4320 bool sta_exists
= false;
4321 struct ieee80211_sta_ht_cap sta_ht_cap
;
4324 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
4330 if (changed
& BSS_CHANGED_IBSS
) {
4331 if (bss_conf
->ibss_joined
) {
4332 set_bit(WLVIF_FLAG_IBSS_JOINED
, &wlvif
->flags
);
4335 wlcore_unset_assoc(wl
, wlvif
);
4336 wl12xx_cmd_role_stop_sta(wl
, wlvif
);
4340 if ((changed
& BSS_CHANGED_BEACON_INT
) && ibss_joined
)
4343 /* Need to update the SSID (for filtering etc) */
4344 if ((changed
& BSS_CHANGED_BEACON
) && ibss_joined
)
4347 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && ibss_joined
) {
4348 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
4349 bss_conf
->enable_beacon
? "enabled" : "disabled");
4354 if (changed
& BSS_CHANGED_IDLE
&& !is_ibss
)
4355 wl1271_sta_handle_idle(wl
, wlvif
, bss_conf
->idle
);
4357 if (changed
& BSS_CHANGED_CQM
) {
4358 bool enable
= false;
4359 if (bss_conf
->cqm_rssi_thold
)
4361 ret
= wl1271_acx_rssi_snr_trigger(wl
, wlvif
, enable
,
4362 bss_conf
->cqm_rssi_thold
,
4363 bss_conf
->cqm_rssi_hyst
);
4366 wlvif
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
4369 if (changed
& (BSS_CHANGED_BSSID
| BSS_CHANGED_HT
|
4370 BSS_CHANGED_ASSOC
)) {
4372 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
4374 u8
*rx_mask
= sta
->ht_cap
.mcs
.rx_mask
;
4376 /* save the supp_rates of the ap */
4377 sta_rate_set
= sta
->supp_rates
[wlvif
->band
];
4378 if (sta
->ht_cap
.ht_supported
)
4380 (rx_mask
[0] << HW_HT_RATES_OFFSET
) |
4381 (rx_mask
[1] << HW_MIMO_RATES_OFFSET
);
4382 sta_ht_cap
= sta
->ht_cap
;
4389 if (changed
& BSS_CHANGED_BSSID
) {
4390 if (!is_zero_ether_addr(bss_conf
->bssid
)) {
4391 ret
= wlcore_set_bssid(wl
, wlvif
, bss_conf
,
4396 /* Need to update the BSSID (for filtering etc) */
4399 ret
= wlcore_clear_bssid(wl
, wlvif
);
4405 if (changed
& BSS_CHANGED_IBSS
) {
4406 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
4407 bss_conf
->ibss_joined
);
4409 if (bss_conf
->ibss_joined
) {
4410 u32 rates
= bss_conf
->basic_rates
;
4411 wlvif
->basic_rate_set
=
4412 wl1271_tx_enabled_rates_get(wl
, rates
,
4415 wl1271_tx_min_rate_get(wl
,
4416 wlvif
->basic_rate_set
);
4418 /* by default, use 11b + OFDM rates */
4419 wlvif
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
4420 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4426 if ((changed
& BSS_CHANGED_BEACON_INFO
) && bss_conf
->dtim_period
) {
4427 /* enable beacon filtering */
4428 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, true);
4433 ret
= wl1271_bss_erp_info_changed(wl
, vif
, bss_conf
, changed
);
4438 ret
= wlcore_join(wl
, wlvif
);
4440 wl1271_warning("cmd join failed %d", ret
);
4445 if (changed
& BSS_CHANGED_ASSOC
) {
4446 if (bss_conf
->assoc
) {
4447 ret
= wlcore_set_assoc(wl
, wlvif
, bss_conf
,
4452 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
))
4453 wl12xx_set_authorized(wl
, wlvif
);
4455 wlcore_unset_assoc(wl
, wlvif
);
4459 if (changed
& BSS_CHANGED_PS
) {
4460 if ((bss_conf
->ps
) &&
4461 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) &&
4462 !test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
)) {
4466 if (wl
->conf
.conn
.forced_ps
) {
4467 ps_mode
= STATION_POWER_SAVE_MODE
;
4468 ps_mode_str
= "forced";
4470 ps_mode
= STATION_AUTO_PS_MODE
;
4471 ps_mode_str
= "auto";
4474 wl1271_debug(DEBUG_PSM
, "%s ps enabled", ps_mode_str
);
4476 ret
= wl1271_ps_set_mode(wl
, wlvif
, ps_mode
);
4478 wl1271_warning("enter %s ps failed %d",
4480 } else if (!bss_conf
->ps
&&
4481 test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
)) {
4482 wl1271_debug(DEBUG_PSM
, "auto ps disabled");
4484 ret
= wl1271_ps_set_mode(wl
, wlvif
,
4485 STATION_ACTIVE_MODE
);
4487 wl1271_warning("exit auto ps failed %d", ret
);
4491 /* Handle new association with HT. Do this after join. */
4494 bss_conf
->chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
;
4496 ret
= wlcore_hw_set_peer_cap(wl
,
4502 wl1271_warning("Set ht cap failed %d", ret
);
4508 ret
= wl1271_acx_set_ht_information(wl
, wlvif
,
4509 bss_conf
->ht_operation_mode
);
4511 wl1271_warning("Set ht information failed %d",
4518 /* Handle arp filtering. Done after join. */
4519 if ((changed
& BSS_CHANGED_ARP_FILTER
) ||
4520 (!is_ibss
&& (changed
& BSS_CHANGED_QOS
))) {
4521 __be32 addr
= bss_conf
->arp_addr_list
[0];
4522 wlvif
->sta
.qos
= bss_conf
->qos
;
4523 WARN_ON(wlvif
->bss_type
!= BSS_TYPE_STA_BSS
);
4525 if (bss_conf
->arp_addr_cnt
== 1 && bss_conf
->assoc
) {
4526 wlvif
->ip_addr
= addr
;
4528 * The template should have been configured only upon
4529 * association. however, it seems that the correct ip
4530 * isn't being set (when sending), so we have to
4531 * reconfigure the template upon every ip change.
4533 ret
= wl1271_cmd_build_arp_rsp(wl
, wlvif
);
4535 wl1271_warning("build arp rsp failed: %d", ret
);
4539 ret
= wl1271_acx_arp_ip_filter(wl
, wlvif
,
4540 (ACX_ARP_FILTER_ARP_FILTERING
|
4541 ACX_ARP_FILTER_AUTO_ARP
),
4545 ret
= wl1271_acx_arp_ip_filter(wl
, wlvif
, 0, addr
);
4556 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
4557 struct ieee80211_vif
*vif
,
4558 struct ieee80211_bss_conf
*bss_conf
,
4561 struct wl1271
*wl
= hw
->priv
;
4562 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4563 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
4566 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info role %d changed 0x%x",
4567 wlvif
->role_id
, (int)changed
);
4570 * make sure to cancel pending disconnections if our association
4573 if (!is_ap
&& (changed
& BSS_CHANGED_ASSOC
))
4574 cancel_delayed_work_sync(&wlvif
->connection_loss_work
);
4576 if (is_ap
&& (changed
& BSS_CHANGED_BEACON_ENABLED
) &&
4577 !bss_conf
->enable_beacon
)
4578 wl1271_tx_flush(wl
);
4580 mutex_lock(&wl
->mutex
);
4582 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4585 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)))
4588 ret
= wl1271_ps_elp_wakeup(wl
);
4592 if ((changed
& BSS_CHANGED_TXPOWER
) &&
4593 bss_conf
->txpower
!= wlvif
->power_level
) {
4595 ret
= wl1271_acx_tx_power(wl
, wlvif
, bss_conf
->txpower
);
4599 wlvif
->power_level
= bss_conf
->txpower
;
4603 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
4605 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
4607 wl1271_ps_elp_sleep(wl
);
4610 mutex_unlock(&wl
->mutex
);
4613 static int wlcore_op_add_chanctx(struct ieee80211_hw
*hw
,
4614 struct ieee80211_chanctx_conf
*ctx
)
4616 wl1271_debug(DEBUG_MAC80211
, "mac80211 add chanctx %d (type %d)",
4617 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4618 cfg80211_get_chandef_type(&ctx
->def
));
4622 static void wlcore_op_remove_chanctx(struct ieee80211_hw
*hw
,
4623 struct ieee80211_chanctx_conf
*ctx
)
4625 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove chanctx %d (type %d)",
4626 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4627 cfg80211_get_chandef_type(&ctx
->def
));
4630 static void wlcore_op_change_chanctx(struct ieee80211_hw
*hw
,
4631 struct ieee80211_chanctx_conf
*ctx
,
4634 struct wl1271
*wl
= hw
->priv
;
4635 struct wl12xx_vif
*wlvif
;
4637 int channel
= ieee80211_frequency_to_channel(
4638 ctx
->def
.chan
->center_freq
);
4640 wl1271_debug(DEBUG_MAC80211
,
4641 "mac80211 change chanctx %d (type %d) changed 0x%x",
4642 channel
, cfg80211_get_chandef_type(&ctx
->def
), changed
);
4644 mutex_lock(&wl
->mutex
);
4646 ret
= wl1271_ps_elp_wakeup(wl
);
4650 wl12xx_for_each_wlvif(wl
, wlvif
) {
4651 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
4654 if (rcu_access_pointer(vif
->chanctx_conf
) != ctx
) {
4660 /* start radar if needed */
4661 if (changed
& IEEE80211_CHANCTX_CHANGE_RADAR
&&
4662 wlvif
->bss_type
== BSS_TYPE_AP_BSS
&&
4663 ctx
->radar_enabled
&& !wlvif
->radar_enabled
&&
4664 ctx
->def
.chan
->dfs_state
== NL80211_DFS_USABLE
) {
4665 wl1271_debug(DEBUG_MAC80211
, "Start radar detection");
4666 wlcore_hw_set_cac(wl
, wlvif
, true);
4667 wlvif
->radar_enabled
= true;
4671 wl1271_ps_elp_sleep(wl
);
4673 mutex_unlock(&wl
->mutex
);
4676 static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw
*hw
,
4677 struct ieee80211_vif
*vif
,
4678 struct ieee80211_chanctx_conf
*ctx
)
4680 struct wl1271
*wl
= hw
->priv
;
4681 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4682 int channel
= ieee80211_frequency_to_channel(
4683 ctx
->def
.chan
->center_freq
);
4686 wl1271_debug(DEBUG_MAC80211
,
4687 "mac80211 assign chanctx (role %d) %d (type %d) (radar %d dfs_state %d)",
4688 wlvif
->role_id
, channel
,
4689 cfg80211_get_chandef_type(&ctx
->def
),
4690 ctx
->radar_enabled
, ctx
->def
.chan
->dfs_state
);
4692 mutex_lock(&wl
->mutex
);
4694 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4697 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)))
4700 ret
= wl1271_ps_elp_wakeup(wl
);
4704 wlvif
->band
= ctx
->def
.chan
->band
;
4705 wlvif
->channel
= channel
;
4706 wlvif
->channel_type
= cfg80211_get_chandef_type(&ctx
->def
);
4708 /* update default rates according to the band */
4709 wl1271_set_band_rate(wl
, wlvif
);
4711 if (ctx
->radar_enabled
&&
4712 ctx
->def
.chan
->dfs_state
== NL80211_DFS_USABLE
) {
4713 wl1271_debug(DEBUG_MAC80211
, "Start radar detection");
4714 wlcore_hw_set_cac(wl
, wlvif
, true);
4715 wlvif
->radar_enabled
= true;
4718 wl1271_ps_elp_sleep(wl
);
4720 mutex_unlock(&wl
->mutex
);
4725 static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw
*hw
,
4726 struct ieee80211_vif
*vif
,
4727 struct ieee80211_chanctx_conf
*ctx
)
4729 struct wl1271
*wl
= hw
->priv
;
4730 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4733 wl1271_debug(DEBUG_MAC80211
,
4734 "mac80211 unassign chanctx (role %d) %d (type %d)",
4736 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4737 cfg80211_get_chandef_type(&ctx
->def
));
4739 wl1271_tx_flush(wl
);
4741 mutex_lock(&wl
->mutex
);
4743 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4746 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)))
4749 ret
= wl1271_ps_elp_wakeup(wl
);
4753 if (wlvif
->radar_enabled
) {
4754 wl1271_debug(DEBUG_MAC80211
, "Stop radar detection");
4755 wlcore_hw_set_cac(wl
, wlvif
, false);
4756 wlvif
->radar_enabled
= false;
4759 wl1271_ps_elp_sleep(wl
);
4761 mutex_unlock(&wl
->mutex
);
4764 static int __wlcore_switch_vif_chan(struct wl1271
*wl
,
4765 struct wl12xx_vif
*wlvif
,
4766 struct ieee80211_chanctx_conf
*new_ctx
)
4768 int channel
= ieee80211_frequency_to_channel(
4769 new_ctx
->def
.chan
->center_freq
);
4771 wl1271_debug(DEBUG_MAC80211
,
4772 "switch vif (role %d) %d -> %d chan_type: %d",
4773 wlvif
->role_id
, wlvif
->channel
, channel
,
4774 cfg80211_get_chandef_type(&new_ctx
->def
));
4776 if (WARN_ON_ONCE(wlvif
->bss_type
!= BSS_TYPE_AP_BSS
))
4779 WARN_ON(!test_bit(WLVIF_FLAG_BEACON_DISABLED
, &wlvif
->flags
));
4781 if (wlvif
->radar_enabled
) {
4782 wl1271_debug(DEBUG_MAC80211
, "Stop radar detection");
4783 wlcore_hw_set_cac(wl
, wlvif
, false);
4784 wlvif
->radar_enabled
= false;
4787 wlvif
->band
= new_ctx
->def
.chan
->band
;
4788 wlvif
->channel
= channel
;
4789 wlvif
->channel_type
= cfg80211_get_chandef_type(&new_ctx
->def
);
4791 /* start radar if needed */
4792 if (new_ctx
->radar_enabled
) {
4793 wl1271_debug(DEBUG_MAC80211
, "Start radar detection");
4794 wlcore_hw_set_cac(wl
, wlvif
, true);
4795 wlvif
->radar_enabled
= true;
4802 wlcore_op_switch_vif_chanctx(struct ieee80211_hw
*hw
,
4803 struct ieee80211_vif_chanctx_switch
*vifs
,
4805 enum ieee80211_chanctx_switch_mode mode
)
4807 struct wl1271
*wl
= hw
->priv
;
4810 wl1271_debug(DEBUG_MAC80211
,
4811 "mac80211 switch chanctx n_vifs %d mode %d",
4814 mutex_lock(&wl
->mutex
);
4816 ret
= wl1271_ps_elp_wakeup(wl
);
4820 for (i
= 0; i
< n_vifs
; i
++) {
4821 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vifs
[i
].vif
);
4823 ret
= __wlcore_switch_vif_chan(wl
, wlvif
, vifs
[i
].new_ctx
);
4828 wl1271_ps_elp_sleep(wl
);
4830 mutex_unlock(&wl
->mutex
);
4835 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
,
4836 struct ieee80211_vif
*vif
, u16 queue
,
4837 const struct ieee80211_tx_queue_params
*params
)
4839 struct wl1271
*wl
= hw
->priv
;
4840 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4844 if (wlcore_is_p2p_mgmt(wlvif
))
4847 mutex_lock(&wl
->mutex
);
4849 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
4852 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
4854 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
4856 if (!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
4859 ret
= wl1271_ps_elp_wakeup(wl
);
4864 * the txop is confed in units of 32us by the mac80211,
4867 ret
= wl1271_acx_ac_cfg(wl
, wlvif
, wl1271_tx_get_queue(queue
),
4868 params
->cw_min
, params
->cw_max
,
4869 params
->aifs
, params
->txop
<< 5);
4873 ret
= wl1271_acx_tid_cfg(wl
, wlvif
, wl1271_tx_get_queue(queue
),
4874 CONF_CHANNEL_TYPE_EDCF
,
4875 wl1271_tx_get_queue(queue
),
4876 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
4880 wl1271_ps_elp_sleep(wl
);
4883 mutex_unlock(&wl
->mutex
);
4888 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
,
4889 struct ieee80211_vif
*vif
)
4892 struct wl1271
*wl
= hw
->priv
;
4893 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4894 u64 mactime
= ULLONG_MAX
;
4897 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
4899 mutex_lock(&wl
->mutex
);
4901 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4904 ret
= wl1271_ps_elp_wakeup(wl
);
4908 ret
= wl12xx_acx_tsf_info(wl
, wlvif
, &mactime
);
4913 wl1271_ps_elp_sleep(wl
);
4916 mutex_unlock(&wl
->mutex
);
4920 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
4921 struct survey_info
*survey
)
4923 struct ieee80211_conf
*conf
= &hw
->conf
;
4928 survey
->channel
= conf
->chandef
.chan
;
4933 static int wl1271_allocate_sta(struct wl1271
*wl
,
4934 struct wl12xx_vif
*wlvif
,
4935 struct ieee80211_sta
*sta
)
4937 struct wl1271_station
*wl_sta
;
4941 if (wl
->active_sta_count
>= wl
->max_ap_stations
) {
4942 wl1271_warning("could not allocate HLID - too much stations");
4946 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4947 ret
= wl12xx_allocate_link(wl
, wlvif
, &wl_sta
->hlid
);
4949 wl1271_warning("could not allocate HLID - too many links");
4953 /* use the previous security seq, if this is a recovery/resume */
4954 wl
->links
[wl_sta
->hlid
].total_freed_pkts
= wl_sta
->total_freed_pkts
;
4956 set_bit(wl_sta
->hlid
, wlvif
->ap
.sta_hlid_map
);
4957 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
4958 wl
->active_sta_count
++;
4962 void wl1271_free_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
, u8 hlid
)
4964 if (!test_bit(hlid
, wlvif
->ap
.sta_hlid_map
))
4967 clear_bit(hlid
, wlvif
->ap
.sta_hlid_map
);
4968 __clear_bit(hlid
, &wl
->ap_ps_map
);
4969 __clear_bit(hlid
, &wl
->ap_fw_ps_map
);
4972 * save the last used PN in the private part of iee80211_sta,
4973 * in case of recovery/suspend
4975 wlcore_save_freed_pkts_addr(wl
, wlvif
, hlid
, wl
->links
[hlid
].addr
);
4977 wl12xx_free_link(wl
, wlvif
, &hlid
);
4978 wl
->active_sta_count
--;
4981 * rearm the tx watchdog when the last STA is freed - give the FW a
4982 * chance to return STA-buffered packets before complaining.
4984 if (wl
->active_sta_count
== 0)
4985 wl12xx_rearm_tx_watchdog_locked(wl
);
4988 static int wl12xx_sta_add(struct wl1271
*wl
,
4989 struct wl12xx_vif
*wlvif
,
4990 struct ieee80211_sta
*sta
)
4992 struct wl1271_station
*wl_sta
;
4996 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
4998 ret
= wl1271_allocate_sta(wl
, wlvif
, sta
);
5002 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5003 hlid
= wl_sta
->hlid
;
5005 ret
= wl12xx_cmd_add_peer(wl
, wlvif
, sta
, hlid
);
5007 wl1271_free_sta(wl
, wlvif
, hlid
);
5012 static int wl12xx_sta_remove(struct wl1271
*wl
,
5013 struct wl12xx_vif
*wlvif
,
5014 struct ieee80211_sta
*sta
)
5016 struct wl1271_station
*wl_sta
;
5019 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
5021 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5023 if (WARN_ON(!test_bit(id
, wlvif
->ap
.sta_hlid_map
)))
5026 ret
= wl12xx_cmd_remove_peer(wl
, wlvif
, wl_sta
->hlid
);
5030 wl1271_free_sta(wl
, wlvif
, wl_sta
->hlid
);
5034 static void wlcore_roc_if_possible(struct wl1271
*wl
,
5035 struct wl12xx_vif
*wlvif
)
5037 if (find_first_bit(wl
->roc_map
,
5038 WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
)
5041 if (WARN_ON(wlvif
->role_id
== WL12XX_INVALID_ROLE_ID
))
5044 wl12xx_roc(wl
, wlvif
, wlvif
->role_id
, wlvif
->band
, wlvif
->channel
);
5048 * when wl_sta is NULL, we treat this call as if coming from a
5049 * pending auth reply.
5050 * wl->mutex must be taken and the FW must be awake when the call
5053 void wlcore_update_inconn_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
5054 struct wl1271_station
*wl_sta
, bool in_conn
)
5057 if (WARN_ON(wl_sta
&& wl_sta
->in_connection
))
5060 if (!wlvif
->ap_pending_auth_reply
&&
5061 !wlvif
->inconn_count
)
5062 wlcore_roc_if_possible(wl
, wlvif
);
5065 wl_sta
->in_connection
= true;
5066 wlvif
->inconn_count
++;
5068 wlvif
->ap_pending_auth_reply
= true;
5071 if (wl_sta
&& !wl_sta
->in_connection
)
5074 if (WARN_ON(!wl_sta
&& !wlvif
->ap_pending_auth_reply
))
5077 if (WARN_ON(wl_sta
&& !wlvif
->inconn_count
))
5081 wl_sta
->in_connection
= false;
5082 wlvif
->inconn_count
--;
5084 wlvif
->ap_pending_auth_reply
= false;
5087 if (!wlvif
->inconn_count
&& !wlvif
->ap_pending_auth_reply
&&
5088 test_bit(wlvif
->role_id
, wl
->roc_map
))
5089 wl12xx_croc(wl
, wlvif
->role_id
);
5093 static int wl12xx_update_sta_state(struct wl1271
*wl
,
5094 struct wl12xx_vif
*wlvif
,
5095 struct ieee80211_sta
*sta
,
5096 enum ieee80211_sta_state old_state
,
5097 enum ieee80211_sta_state new_state
)
5099 struct wl1271_station
*wl_sta
;
5100 bool is_ap
= wlvif
->bss_type
== BSS_TYPE_AP_BSS
;
5101 bool is_sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
5104 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5106 /* Add station (AP mode) */
5108 old_state
== IEEE80211_STA_NOTEXIST
&&
5109 new_state
== IEEE80211_STA_NONE
) {
5110 ret
= wl12xx_sta_add(wl
, wlvif
, sta
);
5114 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, true);
5117 /* Remove station (AP mode) */
5119 old_state
== IEEE80211_STA_NONE
&&
5120 new_state
== IEEE80211_STA_NOTEXIST
) {
5122 wl12xx_sta_remove(wl
, wlvif
, sta
);
5124 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, false);
5127 /* Authorize station (AP mode) */
5129 new_state
== IEEE80211_STA_AUTHORIZED
) {
5130 ret
= wl12xx_cmd_set_peer_state(wl
, wlvif
, wl_sta
->hlid
);
5134 /* reconfigure rates */
5135 ret
= wl12xx_cmd_add_peer(wl
, wlvif
, sta
, wl_sta
->hlid
);
5139 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta
->ht_cap
, true,
5144 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, false);
5147 /* Authorize station */
5149 new_state
== IEEE80211_STA_AUTHORIZED
) {
5150 set_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
);
5151 ret
= wl12xx_set_authorized(wl
, wlvif
);
5157 old_state
== IEEE80211_STA_AUTHORIZED
&&
5158 new_state
== IEEE80211_STA_ASSOC
) {
5159 clear_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
);
5160 clear_bit(WLVIF_FLAG_STA_STATE_SENT
, &wlvif
->flags
);
5163 /* save seq number on disassoc (suspend) */
5165 old_state
== IEEE80211_STA_ASSOC
&&
5166 new_state
== IEEE80211_STA_AUTH
) {
5167 wlcore_save_freed_pkts(wl
, wlvif
, wlvif
->sta
.hlid
, sta
);
5168 wlvif
->total_freed_pkts
= 0;
5171 /* restore seq number on assoc (resume) */
5173 old_state
== IEEE80211_STA_AUTH
&&
5174 new_state
== IEEE80211_STA_ASSOC
) {
5175 wlvif
->total_freed_pkts
= wl_sta
->total_freed_pkts
;
5178 /* clear ROCs on failure or authorization */
5180 (new_state
== IEEE80211_STA_AUTHORIZED
||
5181 new_state
== IEEE80211_STA_NOTEXIST
)) {
5182 if (test_bit(wlvif
->role_id
, wl
->roc_map
))
5183 wl12xx_croc(wl
, wlvif
->role_id
);
5187 old_state
== IEEE80211_STA_NOTEXIST
&&
5188 new_state
== IEEE80211_STA_NONE
) {
5189 if (find_first_bit(wl
->roc_map
,
5190 WL12XX_MAX_ROLES
) >= WL12XX_MAX_ROLES
) {
5191 WARN_ON(wlvif
->role_id
== WL12XX_INVALID_ROLE_ID
);
5192 wl12xx_roc(wl
, wlvif
, wlvif
->role_id
,
5193 wlvif
->band
, wlvif
->channel
);
5199 static int wl12xx_op_sta_state(struct ieee80211_hw
*hw
,
5200 struct ieee80211_vif
*vif
,
5201 struct ieee80211_sta
*sta
,
5202 enum ieee80211_sta_state old_state
,
5203 enum ieee80211_sta_state new_state
)
5205 struct wl1271
*wl
= hw
->priv
;
5206 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5209 wl1271_debug(DEBUG_MAC80211
, "mac80211 sta %d state=%d->%d",
5210 sta
->aid
, old_state
, new_state
);
5212 mutex_lock(&wl
->mutex
);
5214 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5219 ret
= wl1271_ps_elp_wakeup(wl
);
5223 ret
= wl12xx_update_sta_state(wl
, wlvif
, sta
, old_state
, new_state
);
5225 wl1271_ps_elp_sleep(wl
);
5227 mutex_unlock(&wl
->mutex
);
5228 if (new_state
< old_state
)
5233 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
5234 struct ieee80211_vif
*vif
,
5235 struct ieee80211_ampdu_params
*params
)
5237 struct wl1271
*wl
= hw
->priv
;
5238 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5240 u8 hlid
, *ba_bitmap
;
5241 struct ieee80211_sta
*sta
= params
->sta
;
5242 enum ieee80211_ampdu_mlme_action action
= params
->action
;
5243 u16 tid
= params
->tid
;
5244 u16
*ssn
= ¶ms
->ssn
;
5246 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu action %d tid %d", action
,
5249 /* sanity check - the fields in FW are only 8bits wide */
5250 if (WARN_ON(tid
> 0xFF))
5253 mutex_lock(&wl
->mutex
);
5255 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5260 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
) {
5261 hlid
= wlvif
->sta
.hlid
;
5262 } else if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
) {
5263 struct wl1271_station
*wl_sta
;
5265 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5266 hlid
= wl_sta
->hlid
;
5272 ba_bitmap
= &wl
->links
[hlid
].ba_bitmap
;
5274 ret
= wl1271_ps_elp_wakeup(wl
);
5278 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu: Rx tid %d action %d",
5282 case IEEE80211_AMPDU_RX_START
:
5283 if (!wlvif
->ba_support
|| !wlvif
->ba_allowed
) {
5288 if (wl
->ba_rx_session_count
>= wl
->ba_rx_session_count_max
) {
5290 wl1271_error("exceeded max RX BA sessions");
5294 if (*ba_bitmap
& BIT(tid
)) {
5296 wl1271_error("cannot enable RX BA session on active "
5301 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, *ssn
, true,
5306 *ba_bitmap
|= BIT(tid
);
5307 wl
->ba_rx_session_count
++;
5311 case IEEE80211_AMPDU_RX_STOP
:
5312 if (!(*ba_bitmap
& BIT(tid
))) {
5314 * this happens on reconfig - so only output a debug
5315 * message for now, and don't fail the function.
5317 wl1271_debug(DEBUG_MAC80211
,
5318 "no active RX BA session on tid: %d",
5324 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, 0, false,
5327 *ba_bitmap
&= ~BIT(tid
);
5328 wl
->ba_rx_session_count
--;
5333 * The BA initiator session management in FW independently.
5334 * Falling break here on purpose for all TX APDU commands.
5336 case IEEE80211_AMPDU_TX_START
:
5337 case IEEE80211_AMPDU_TX_STOP_CONT
:
5338 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
5339 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
5340 case IEEE80211_AMPDU_TX_OPERATIONAL
:
5345 wl1271_error("Incorrect ampdu action id=%x\n", action
);
5349 wl1271_ps_elp_sleep(wl
);
5352 mutex_unlock(&wl
->mutex
);
5357 static int wl12xx_set_bitrate_mask(struct ieee80211_hw
*hw
,
5358 struct ieee80211_vif
*vif
,
5359 const struct cfg80211_bitrate_mask
*mask
)
5361 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5362 struct wl1271
*wl
= hw
->priv
;
5365 wl1271_debug(DEBUG_MAC80211
, "mac80211 set_bitrate_mask 0x%x 0x%x",
5366 mask
->control
[NL80211_BAND_2GHZ
].legacy
,
5367 mask
->control
[NL80211_BAND_5GHZ
].legacy
);
5369 mutex_lock(&wl
->mutex
);
5371 for (i
= 0; i
< WLCORE_NUM_BANDS
; i
++)
5372 wlvif
->bitrate_masks
[i
] =
5373 wl1271_tx_enabled_rates_get(wl
,
5374 mask
->control
[i
].legacy
,
5377 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5380 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
5381 !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) {
5383 ret
= wl1271_ps_elp_wakeup(wl
);
5387 wl1271_set_band_rate(wl
, wlvif
);
5389 wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
5390 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
5392 wl1271_ps_elp_sleep(wl
);
5395 mutex_unlock(&wl
->mutex
);
5400 static void wl12xx_op_channel_switch(struct ieee80211_hw
*hw
,
5401 struct ieee80211_vif
*vif
,
5402 struct ieee80211_channel_switch
*ch_switch
)
5404 struct wl1271
*wl
= hw
->priv
;
5405 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5408 wl1271_debug(DEBUG_MAC80211
, "mac80211 channel switch");
5410 wl1271_tx_flush(wl
);
5412 mutex_lock(&wl
->mutex
);
5414 if (unlikely(wl
->state
== WLCORE_STATE_OFF
)) {
5415 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
5416 ieee80211_chswitch_done(vif
, false);
5418 } else if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5422 ret
= wl1271_ps_elp_wakeup(wl
);
5426 /* TODO: change mac80211 to pass vif as param */
5428 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) {
5429 unsigned long delay_usec
;
5431 ret
= wl
->ops
->channel_switch(wl
, wlvif
, ch_switch
);
5435 set_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
);
5437 /* indicate failure 5 seconds after channel switch time */
5438 delay_usec
= ieee80211_tu_to_usec(wlvif
->beacon_int
) *
5440 ieee80211_queue_delayed_work(hw
, &wlvif
->channel_switch_work
,
5441 usecs_to_jiffies(delay_usec
) +
5442 msecs_to_jiffies(5000));
5446 wl1271_ps_elp_sleep(wl
);
5449 mutex_unlock(&wl
->mutex
);
5452 static const void *wlcore_get_beacon_ie(struct wl1271
*wl
,
5453 struct wl12xx_vif
*wlvif
,
5456 int ieoffset
= offsetof(struct ieee80211_mgmt
, u
.beacon
.variable
);
5457 struct sk_buff
*beacon
=
5458 ieee80211_beacon_get(wl
->hw
, wl12xx_wlvif_to_vif(wlvif
));
5463 return cfg80211_find_ie(eid
,
5464 beacon
->data
+ ieoffset
,
5465 beacon
->len
- ieoffset
);
5468 static int wlcore_get_csa_count(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
5472 const struct ieee80211_channel_sw_ie
*ie_csa
;
5474 ie
= wlcore_get_beacon_ie(wl
, wlvif
, WLAN_EID_CHANNEL_SWITCH
);
5478 ie_csa
= (struct ieee80211_channel_sw_ie
*)&ie
[2];
5479 *csa_count
= ie_csa
->count
;
5484 static void wlcore_op_channel_switch_beacon(struct ieee80211_hw
*hw
,
5485 struct ieee80211_vif
*vif
,
5486 struct cfg80211_chan_def
*chandef
)
5488 struct wl1271
*wl
= hw
->priv
;
5489 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5490 struct ieee80211_channel_switch ch_switch
= {
5492 .chandef
= *chandef
,
5496 wl1271_debug(DEBUG_MAC80211
,
5497 "mac80211 channel switch beacon (role %d)",
5500 ret
= wlcore_get_csa_count(wl
, wlvif
, &ch_switch
.count
);
5502 wl1271_error("error getting beacon (for CSA counter)");
5506 mutex_lock(&wl
->mutex
);
5508 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5513 ret
= wl1271_ps_elp_wakeup(wl
);
5517 ret
= wl
->ops
->channel_switch(wl
, wlvif
, &ch_switch
);
5521 set_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
);
5524 wl1271_ps_elp_sleep(wl
);
5526 mutex_unlock(&wl
->mutex
);
5529 static void wlcore_op_flush(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
5530 u32 queues
, bool drop
)
5532 struct wl1271
*wl
= hw
->priv
;
5534 wl1271_tx_flush(wl
);
5537 static int wlcore_op_remain_on_channel(struct ieee80211_hw
*hw
,
5538 struct ieee80211_vif
*vif
,
5539 struct ieee80211_channel
*chan
,
5541 enum ieee80211_roc_type type
)
5543 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5544 struct wl1271
*wl
= hw
->priv
;
5545 int channel
, active_roc
, ret
= 0;
5547 channel
= ieee80211_frequency_to_channel(chan
->center_freq
);
5549 wl1271_debug(DEBUG_MAC80211
, "mac80211 roc %d (%d)",
5550 channel
, wlvif
->role_id
);
5552 mutex_lock(&wl
->mutex
);
5554 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5557 /* return EBUSY if we can't ROC right now */
5558 active_roc
= find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
);
5559 if (wl
->roc_vif
|| active_roc
< WL12XX_MAX_ROLES
) {
5560 wl1271_warning("active roc on role %d", active_roc
);
5565 ret
= wl1271_ps_elp_wakeup(wl
);
5569 ret
= wl12xx_start_dev(wl
, wlvif
, chan
->band
, channel
);
5574 ieee80211_queue_delayed_work(hw
, &wl
->roc_complete_work
,
5575 msecs_to_jiffies(duration
));
5577 wl1271_ps_elp_sleep(wl
);
5579 mutex_unlock(&wl
->mutex
);
5583 static int __wlcore_roc_completed(struct wl1271
*wl
)
5585 struct wl12xx_vif
*wlvif
;
5588 /* already completed */
5589 if (unlikely(!wl
->roc_vif
))
5592 wlvif
= wl12xx_vif_to_data(wl
->roc_vif
);
5594 if (!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
5597 ret
= wl12xx_stop_dev(wl
, wlvif
);
5606 static int wlcore_roc_completed(struct wl1271
*wl
)
5610 wl1271_debug(DEBUG_MAC80211
, "roc complete");
5612 mutex_lock(&wl
->mutex
);
5614 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5619 ret
= wl1271_ps_elp_wakeup(wl
);
5623 ret
= __wlcore_roc_completed(wl
);
5625 wl1271_ps_elp_sleep(wl
);
5627 mutex_unlock(&wl
->mutex
);
5632 static void wlcore_roc_complete_work(struct work_struct
*work
)
5634 struct delayed_work
*dwork
;
5638 dwork
= to_delayed_work(work
);
5639 wl
= container_of(dwork
, struct wl1271
, roc_complete_work
);
5641 ret
= wlcore_roc_completed(wl
);
5643 ieee80211_remain_on_channel_expired(wl
->hw
);
5646 static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw
*hw
)
5648 struct wl1271
*wl
= hw
->priv
;
5650 wl1271_debug(DEBUG_MAC80211
, "mac80211 croc");
5653 wl1271_tx_flush(wl
);
5656 * we can't just flush_work here, because it might deadlock
5657 * (as we might get called from the same workqueue)
5659 cancel_delayed_work_sync(&wl
->roc_complete_work
);
5660 wlcore_roc_completed(wl
);
5665 static void wlcore_op_sta_rc_update(struct ieee80211_hw
*hw
,
5666 struct ieee80211_vif
*vif
,
5667 struct ieee80211_sta
*sta
,
5670 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5672 wl1271_debug(DEBUG_MAC80211
, "mac80211 sta_rc_update");
5674 if (!(changed
& IEEE80211_RC_BW_CHANGED
))
5677 /* this callback is atomic, so schedule a new work */
5678 wlvif
->rc_update_bw
= sta
->bandwidth
;
5679 memcpy(&wlvif
->rc_ht_cap
, &sta
->ht_cap
, sizeof(sta
->ht_cap
));
5680 ieee80211_queue_work(hw
, &wlvif
->rc_update_work
);
5683 static void wlcore_op_sta_statistics(struct ieee80211_hw
*hw
,
5684 struct ieee80211_vif
*vif
,
5685 struct ieee80211_sta
*sta
,
5686 struct station_info
*sinfo
)
5688 struct wl1271
*wl
= hw
->priv
;
5689 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5693 wl1271_debug(DEBUG_MAC80211
, "mac80211 get_rssi");
5695 mutex_lock(&wl
->mutex
);
5697 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5700 ret
= wl1271_ps_elp_wakeup(wl
);
5704 ret
= wlcore_acx_average_rssi(wl
, wlvif
, &rssi_dbm
);
5708 sinfo
->filled
|= BIT(NL80211_STA_INFO_SIGNAL
);
5709 sinfo
->signal
= rssi_dbm
;
5712 wl1271_ps_elp_sleep(wl
);
5715 mutex_unlock(&wl
->mutex
);
5718 static u32
wlcore_op_get_expected_throughput(struct ieee80211_hw
*hw
,
5719 struct ieee80211_sta
*sta
)
5721 struct wl1271_station
*wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5722 struct wl1271
*wl
= hw
->priv
;
5723 u8 hlid
= wl_sta
->hlid
;
5725 /* return in units of Kbps */
5726 return (wl
->links
[hlid
].fw_rate_mbps
* 1000);
5729 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
5731 struct wl1271
*wl
= hw
->priv
;
5734 mutex_lock(&wl
->mutex
);
5736 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5739 /* packets are considered pending if in the TX queue or the FW */
5740 ret
= (wl1271_tx_total_queue_count(wl
) > 0) || (wl
->tx_frames_cnt
> 0);
5742 mutex_unlock(&wl
->mutex
);
5747 /* can't be const, mac80211 writes to this */
5748 static struct ieee80211_rate wl1271_rates
[] = {
5750 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
5751 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
5753 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
5754 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
5755 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5757 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
5758 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
5759 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5761 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
5762 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
5763 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5765 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
5766 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
5768 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
5769 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
5771 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
5772 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
5774 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
5775 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
5777 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
5778 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
5780 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
5781 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
5783 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
5784 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
5786 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
5787 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
5790 /* can't be const, mac80211 writes to this */
5791 static struct ieee80211_channel wl1271_channels
[] = {
5792 { .hw_value
= 1, .center_freq
= 2412, .max_power
= WLCORE_MAX_TXPWR
},
5793 { .hw_value
= 2, .center_freq
= 2417, .max_power
= WLCORE_MAX_TXPWR
},
5794 { .hw_value
= 3, .center_freq
= 2422, .max_power
= WLCORE_MAX_TXPWR
},
5795 { .hw_value
= 4, .center_freq
= 2427, .max_power
= WLCORE_MAX_TXPWR
},
5796 { .hw_value
= 5, .center_freq
= 2432, .max_power
= WLCORE_MAX_TXPWR
},
5797 { .hw_value
= 6, .center_freq
= 2437, .max_power
= WLCORE_MAX_TXPWR
},
5798 { .hw_value
= 7, .center_freq
= 2442, .max_power
= WLCORE_MAX_TXPWR
},
5799 { .hw_value
= 8, .center_freq
= 2447, .max_power
= WLCORE_MAX_TXPWR
},
5800 { .hw_value
= 9, .center_freq
= 2452, .max_power
= WLCORE_MAX_TXPWR
},
5801 { .hw_value
= 10, .center_freq
= 2457, .max_power
= WLCORE_MAX_TXPWR
},
5802 { .hw_value
= 11, .center_freq
= 2462, .max_power
= WLCORE_MAX_TXPWR
},
5803 { .hw_value
= 12, .center_freq
= 2467, .max_power
= WLCORE_MAX_TXPWR
},
5804 { .hw_value
= 13, .center_freq
= 2472, .max_power
= WLCORE_MAX_TXPWR
},
5805 { .hw_value
= 14, .center_freq
= 2484, .max_power
= WLCORE_MAX_TXPWR
},
5808 /* can't be const, mac80211 writes to this */
5809 static struct ieee80211_supported_band wl1271_band_2ghz
= {
5810 .channels
= wl1271_channels
,
5811 .n_channels
= ARRAY_SIZE(wl1271_channels
),
5812 .bitrates
= wl1271_rates
,
5813 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
5816 /* 5 GHz data rates for WL1273 */
5817 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
5819 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
5820 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
5822 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
5823 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
5825 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
5826 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
5828 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
5829 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
5831 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
5832 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
5834 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
5835 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
5837 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
5838 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
5840 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
5841 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
5844 /* 5 GHz band channels for WL1273 */
5845 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
5846 { .hw_value
= 8, .center_freq
= 5040, .max_power
= WLCORE_MAX_TXPWR
},
5847 { .hw_value
= 12, .center_freq
= 5060, .max_power
= WLCORE_MAX_TXPWR
},
5848 { .hw_value
= 16, .center_freq
= 5080, .max_power
= WLCORE_MAX_TXPWR
},
5849 { .hw_value
= 34, .center_freq
= 5170, .max_power
= WLCORE_MAX_TXPWR
},
5850 { .hw_value
= 36, .center_freq
= 5180, .max_power
= WLCORE_MAX_TXPWR
},
5851 { .hw_value
= 38, .center_freq
= 5190, .max_power
= WLCORE_MAX_TXPWR
},
5852 { .hw_value
= 40, .center_freq
= 5200, .max_power
= WLCORE_MAX_TXPWR
},
5853 { .hw_value
= 42, .center_freq
= 5210, .max_power
= WLCORE_MAX_TXPWR
},
5854 { .hw_value
= 44, .center_freq
= 5220, .max_power
= WLCORE_MAX_TXPWR
},
5855 { .hw_value
= 46, .center_freq
= 5230, .max_power
= WLCORE_MAX_TXPWR
},
5856 { .hw_value
= 48, .center_freq
= 5240, .max_power
= WLCORE_MAX_TXPWR
},
5857 { .hw_value
= 52, .center_freq
= 5260, .max_power
= WLCORE_MAX_TXPWR
},
5858 { .hw_value
= 56, .center_freq
= 5280, .max_power
= WLCORE_MAX_TXPWR
},
5859 { .hw_value
= 60, .center_freq
= 5300, .max_power
= WLCORE_MAX_TXPWR
},
5860 { .hw_value
= 64, .center_freq
= 5320, .max_power
= WLCORE_MAX_TXPWR
},
5861 { .hw_value
= 100, .center_freq
= 5500, .max_power
= WLCORE_MAX_TXPWR
},
5862 { .hw_value
= 104, .center_freq
= 5520, .max_power
= WLCORE_MAX_TXPWR
},
5863 { .hw_value
= 108, .center_freq
= 5540, .max_power
= WLCORE_MAX_TXPWR
},
5864 { .hw_value
= 112, .center_freq
= 5560, .max_power
= WLCORE_MAX_TXPWR
},
5865 { .hw_value
= 116, .center_freq
= 5580, .max_power
= WLCORE_MAX_TXPWR
},
5866 { .hw_value
= 120, .center_freq
= 5600, .max_power
= WLCORE_MAX_TXPWR
},
5867 { .hw_value
= 124, .center_freq
= 5620, .max_power
= WLCORE_MAX_TXPWR
},
5868 { .hw_value
= 128, .center_freq
= 5640, .max_power
= WLCORE_MAX_TXPWR
},
5869 { .hw_value
= 132, .center_freq
= 5660, .max_power
= WLCORE_MAX_TXPWR
},
5870 { .hw_value
= 136, .center_freq
= 5680, .max_power
= WLCORE_MAX_TXPWR
},
5871 { .hw_value
= 140, .center_freq
= 5700, .max_power
= WLCORE_MAX_TXPWR
},
5872 { .hw_value
= 149, .center_freq
= 5745, .max_power
= WLCORE_MAX_TXPWR
},
5873 { .hw_value
= 153, .center_freq
= 5765, .max_power
= WLCORE_MAX_TXPWR
},
5874 { .hw_value
= 157, .center_freq
= 5785, .max_power
= WLCORE_MAX_TXPWR
},
5875 { .hw_value
= 161, .center_freq
= 5805, .max_power
= WLCORE_MAX_TXPWR
},
5876 { .hw_value
= 165, .center_freq
= 5825, .max_power
= WLCORE_MAX_TXPWR
},
5879 static struct ieee80211_supported_band wl1271_band_5ghz
= {
5880 .channels
= wl1271_channels_5ghz
,
5881 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
5882 .bitrates
= wl1271_rates_5ghz
,
5883 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
5886 static const struct ieee80211_ops wl1271_ops
= {
5887 .start
= wl1271_op_start
,
5888 .stop
= wlcore_op_stop
,
5889 .add_interface
= wl1271_op_add_interface
,
5890 .remove_interface
= wl1271_op_remove_interface
,
5891 .change_interface
= wl12xx_op_change_interface
,
5893 .suspend
= wl1271_op_suspend
,
5894 .resume
= wl1271_op_resume
,
5896 .config
= wl1271_op_config
,
5897 .prepare_multicast
= wl1271_op_prepare_multicast
,
5898 .configure_filter
= wl1271_op_configure_filter
,
5900 .set_key
= wlcore_op_set_key
,
5901 .hw_scan
= wl1271_op_hw_scan
,
5902 .cancel_hw_scan
= wl1271_op_cancel_hw_scan
,
5903 .sched_scan_start
= wl1271_op_sched_scan_start
,
5904 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
5905 .bss_info_changed
= wl1271_op_bss_info_changed
,
5906 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
5907 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
5908 .conf_tx
= wl1271_op_conf_tx
,
5909 .get_tsf
= wl1271_op_get_tsf
,
5910 .get_survey
= wl1271_op_get_survey
,
5911 .sta_state
= wl12xx_op_sta_state
,
5912 .ampdu_action
= wl1271_op_ampdu_action
,
5913 .tx_frames_pending
= wl1271_tx_frames_pending
,
5914 .set_bitrate_mask
= wl12xx_set_bitrate_mask
,
5915 .set_default_unicast_key
= wl1271_op_set_default_key_idx
,
5916 .channel_switch
= wl12xx_op_channel_switch
,
5917 .channel_switch_beacon
= wlcore_op_channel_switch_beacon
,
5918 .flush
= wlcore_op_flush
,
5919 .remain_on_channel
= wlcore_op_remain_on_channel
,
5920 .cancel_remain_on_channel
= wlcore_op_cancel_remain_on_channel
,
5921 .add_chanctx
= wlcore_op_add_chanctx
,
5922 .remove_chanctx
= wlcore_op_remove_chanctx
,
5923 .change_chanctx
= wlcore_op_change_chanctx
,
5924 .assign_vif_chanctx
= wlcore_op_assign_vif_chanctx
,
5925 .unassign_vif_chanctx
= wlcore_op_unassign_vif_chanctx
,
5926 .switch_vif_chanctx
= wlcore_op_switch_vif_chanctx
,
5927 .sta_rc_update
= wlcore_op_sta_rc_update
,
5928 .sta_statistics
= wlcore_op_sta_statistics
,
5929 .get_expected_throughput
= wlcore_op_get_expected_throughput
,
5930 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
5934 u8
wlcore_rate_to_idx(struct wl1271
*wl
, u8 rate
, enum nl80211_band band
)
5940 if (unlikely(rate
>= wl
->hw_tx_rate_tbl_size
)) {
5941 wl1271_error("Illegal RX rate from HW: %d", rate
);
5945 idx
= wl
->band_rate_to_idx
[band
][rate
];
5946 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
5947 wl1271_error("Unsupported RX rate from HW: %d", rate
);
5954 static void wl12xx_derive_mac_addresses(struct wl1271
*wl
, u32 oui
, u32 nic
)
5958 wl1271_debug(DEBUG_PROBE
, "base address: oui %06x nic %06x",
5961 if (nic
+ WLCORE_NUM_MAC_ADDRESSES
- wl
->num_mac_addr
> 0xffffff)
5962 wl1271_warning("NIC part of the MAC address wraps around!");
5964 for (i
= 0; i
< wl
->num_mac_addr
; i
++) {
5965 wl
->addresses
[i
].addr
[0] = (u8
)(oui
>> 16);
5966 wl
->addresses
[i
].addr
[1] = (u8
)(oui
>> 8);
5967 wl
->addresses
[i
].addr
[2] = (u8
) oui
;
5968 wl
->addresses
[i
].addr
[3] = (u8
)(nic
>> 16);
5969 wl
->addresses
[i
].addr
[4] = (u8
)(nic
>> 8);
5970 wl
->addresses
[i
].addr
[5] = (u8
) nic
;
5974 /* we may be one address short at the most */
5975 WARN_ON(wl
->num_mac_addr
+ 1 < WLCORE_NUM_MAC_ADDRESSES
);
5978 * turn on the LAA bit in the first address and use it as
5981 if (wl
->num_mac_addr
< WLCORE_NUM_MAC_ADDRESSES
) {
5982 int idx
= WLCORE_NUM_MAC_ADDRESSES
- 1;
5983 memcpy(&wl
->addresses
[idx
], &wl
->addresses
[0],
5984 sizeof(wl
->addresses
[0]));
5986 wl
->addresses
[idx
].addr
[0] |= BIT(1);
5989 wl
->hw
->wiphy
->n_addresses
= WLCORE_NUM_MAC_ADDRESSES
;
5990 wl
->hw
->wiphy
->addresses
= wl
->addresses
;
5993 static int wl12xx_get_hw_info(struct wl1271
*wl
)
5997 ret
= wlcore_read_reg(wl
, REG_CHIP_ID_B
, &wl
->chip
.id
);
6001 wl
->fuse_oui_addr
= 0;
6002 wl
->fuse_nic_addr
= 0;
6004 ret
= wl
->ops
->get_pg_ver(wl
, &wl
->hw_pg_ver
);
6008 if (wl
->ops
->get_mac
)
6009 ret
= wl
->ops
->get_mac(wl
);
6015 static int wl1271_register_hw(struct wl1271
*wl
)
6018 u32 oui_addr
= 0, nic_addr
= 0;
6019 struct platform_device
*pdev
= wl
->pdev
;
6020 struct wlcore_platdev_data
*pdev_data
= dev_get_platdata(&pdev
->dev
);
6022 if (wl
->mac80211_registered
)
6025 if (wl
->nvs_len
>= 12) {
6026 /* NOTE: The wl->nvs->nvs element must be first, in
6027 * order to simplify the casting, we assume it is at
6028 * the beginning of the wl->nvs structure.
6030 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
6033 (nvs_ptr
[11] << 16) + (nvs_ptr
[10] << 8) + nvs_ptr
[6];
6035 (nvs_ptr
[5] << 16) + (nvs_ptr
[4] << 8) + nvs_ptr
[3];
6038 /* if the MAC address is zeroed in the NVS derive from fuse */
6039 if (oui_addr
== 0 && nic_addr
== 0) {
6040 oui_addr
= wl
->fuse_oui_addr
;
6041 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
6042 nic_addr
= wl
->fuse_nic_addr
+ 1;
6045 if (oui_addr
== 0xdeadbe && nic_addr
== 0xef0000) {
6046 wl1271_warning("Detected unconfigured mac address in nvs, derive from fuse instead.\n");
6047 if (!strcmp(pdev_data
->family
->name
, "wl18xx")) {
6048 wl1271_warning("This default nvs file can be removed from the file system\n");
6050 wl1271_warning("Your device performance is not optimized.\n");
6051 wl1271_warning("Please use the calibrator tool to configure your device.\n");
6054 if (wl
->fuse_oui_addr
== 0 && wl
->fuse_nic_addr
== 0) {
6055 wl1271_warning("Fuse mac address is zero. using random mac\n");
6056 /* Use TI oui and a random nic */
6057 oui_addr
= WLCORE_TI_OUI_ADDRESS
;
6058 nic_addr
= get_random_int();
6060 oui_addr
= wl
->fuse_oui_addr
;
6061 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
6062 nic_addr
= wl
->fuse_nic_addr
+ 1;
6066 wl12xx_derive_mac_addresses(wl
, oui_addr
, nic_addr
);
6068 ret
= ieee80211_register_hw(wl
->hw
);
6070 wl1271_error("unable to register mac80211 hw: %d", ret
);
6074 wl
->mac80211_registered
= true;
6076 wl1271_debugfs_init(wl
);
6078 wl1271_notice("loaded");
6084 static void wl1271_unregister_hw(struct wl1271
*wl
)
6087 wl1271_plt_stop(wl
);
6089 ieee80211_unregister_hw(wl
->hw
);
6090 wl
->mac80211_registered
= false;
6094 static int wl1271_init_ieee80211(struct wl1271
*wl
)
6097 static const u32 cipher_suites
[] = {
6098 WLAN_CIPHER_SUITE_WEP40
,
6099 WLAN_CIPHER_SUITE_WEP104
,
6100 WLAN_CIPHER_SUITE_TKIP
,
6101 WLAN_CIPHER_SUITE_CCMP
,
6102 WL1271_CIPHER_SUITE_GEM
,
6105 /* The tx descriptor buffer */
6106 wl
->hw
->extra_tx_headroom
= sizeof(struct wl1271_tx_hw_descr
);
6108 if (wl
->quirks
& WLCORE_QUIRK_TKIP_HEADER_SPACE
)
6109 wl
->hw
->extra_tx_headroom
+= WL1271_EXTRA_SPACE_TKIP
;
6112 /* FIXME: find a proper value */
6113 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
6115 ieee80211_hw_set(wl
->hw
, SUPPORT_FAST_XMIT
);
6116 ieee80211_hw_set(wl
->hw
, CHANCTX_STA_CSA
);
6117 ieee80211_hw_set(wl
->hw
, QUEUE_CONTROL
);
6118 ieee80211_hw_set(wl
->hw
, TX_AMPDU_SETUP_IN_HW
);
6119 ieee80211_hw_set(wl
->hw
, AMPDU_AGGREGATION
);
6120 ieee80211_hw_set(wl
->hw
, AP_LINK_PS
);
6121 ieee80211_hw_set(wl
->hw
, SPECTRUM_MGMT
);
6122 ieee80211_hw_set(wl
->hw
, REPORTS_TX_ACK_STATUS
);
6123 ieee80211_hw_set(wl
->hw
, CONNECTION_MONITOR
);
6124 ieee80211_hw_set(wl
->hw
, HAS_RATE_CONTROL
);
6125 ieee80211_hw_set(wl
->hw
, SUPPORTS_DYNAMIC_PS
);
6126 ieee80211_hw_set(wl
->hw
, SIGNAL_DBM
);
6127 ieee80211_hw_set(wl
->hw
, SUPPORTS_PS
);
6128 ieee80211_hw_set(wl
->hw
, SUPPORTS_TX_FRAG
);
6130 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
6131 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
6133 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
6134 BIT(NL80211_IFTYPE_AP
) |
6135 BIT(NL80211_IFTYPE_P2P_DEVICE
) |
6136 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
6137 #ifdef CONFIG_MAC80211_MESH
6138 BIT(NL80211_IFTYPE_MESH_POINT
) |
6140 BIT(NL80211_IFTYPE_P2P_GO
);
6142 wl
->hw
->wiphy
->max_scan_ssids
= 1;
6143 wl
->hw
->wiphy
->max_sched_scan_ssids
= 16;
6144 wl
->hw
->wiphy
->max_match_sets
= 16;
6146 * Maximum length of elements in scanning probe request templates
6147 * should be the maximum length possible for a template, without
6148 * the IEEE80211 header of the template
6150 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
6151 sizeof(struct ieee80211_header
);
6153 wl
->hw
->wiphy
->max_sched_scan_reqs
= 1;
6154 wl
->hw
->wiphy
->max_sched_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
6155 sizeof(struct ieee80211_header
);
6157 wl
->hw
->wiphy
->max_remain_on_channel_duration
= 30000;
6159 wl
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
|
6160 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
|
6161 WIPHY_FLAG_HAS_CHANNEL_SWITCH
;
6163 wl
->hw
->wiphy
->features
|= NL80211_FEATURE_AP_SCAN
;
6165 /* make sure all our channels fit in the scanned_ch bitmask */
6166 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
6167 ARRAY_SIZE(wl1271_channels_5ghz
) >
6168 WL1271_MAX_CHANNELS
);
6170 * clear channel flags from the previous usage
6171 * and restore max_power & max_antenna_gain values.
6173 for (i
= 0; i
< ARRAY_SIZE(wl1271_channels
); i
++) {
6174 wl1271_band_2ghz
.channels
[i
].flags
= 0;
6175 wl1271_band_2ghz
.channels
[i
].max_power
= WLCORE_MAX_TXPWR
;
6176 wl1271_band_2ghz
.channels
[i
].max_antenna_gain
= 0;
6179 for (i
= 0; i
< ARRAY_SIZE(wl1271_channels_5ghz
); i
++) {
6180 wl1271_band_5ghz
.channels
[i
].flags
= 0;
6181 wl1271_band_5ghz
.channels
[i
].max_power
= WLCORE_MAX_TXPWR
;
6182 wl1271_band_5ghz
.channels
[i
].max_antenna_gain
= 0;
6186 * We keep local copies of the band structs because we need to
6187 * modify them on a per-device basis.
6189 memcpy(&wl
->bands
[NL80211_BAND_2GHZ
], &wl1271_band_2ghz
,
6190 sizeof(wl1271_band_2ghz
));
6191 memcpy(&wl
->bands
[NL80211_BAND_2GHZ
].ht_cap
,
6192 &wl
->ht_cap
[NL80211_BAND_2GHZ
],
6193 sizeof(*wl
->ht_cap
));
6194 memcpy(&wl
->bands
[NL80211_BAND_5GHZ
], &wl1271_band_5ghz
,
6195 sizeof(wl1271_band_5ghz
));
6196 memcpy(&wl
->bands
[NL80211_BAND_5GHZ
].ht_cap
,
6197 &wl
->ht_cap
[NL80211_BAND_5GHZ
],
6198 sizeof(*wl
->ht_cap
));
6200 wl
->hw
->wiphy
->bands
[NL80211_BAND_2GHZ
] =
6201 &wl
->bands
[NL80211_BAND_2GHZ
];
6202 wl
->hw
->wiphy
->bands
[NL80211_BAND_5GHZ
] =
6203 &wl
->bands
[NL80211_BAND_5GHZ
];
6206 * allow 4 queues per mac address we support +
6207 * 1 cab queue per mac + one global offchannel Tx queue
6209 wl
->hw
->queues
= (NUM_TX_QUEUES
+ 1) * WLCORE_NUM_MAC_ADDRESSES
+ 1;
6211 /* the last queue is the offchannel queue */
6212 wl
->hw
->offchannel_tx_hw_queue
= wl
->hw
->queues
- 1;
6213 wl
->hw
->max_rates
= 1;
6215 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
6217 /* the FW answers probe-requests in AP-mode */
6218 wl
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
;
6219 wl
->hw
->wiphy
->probe_resp_offload
=
6220 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS
|
6221 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2
|
6222 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P
;
6224 /* allowed interface combinations */
6225 wl
->hw
->wiphy
->iface_combinations
= wl
->iface_combinations
;
6226 wl
->hw
->wiphy
->n_iface_combinations
= wl
->n_iface_combinations
;
6228 /* register vendor commands */
6229 wlcore_set_vendor_commands(wl
->hw
->wiphy
);
6231 SET_IEEE80211_DEV(wl
->hw
, wl
->dev
);
6233 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
6234 wl
->hw
->vif_data_size
= sizeof(struct wl12xx_vif
);
6236 wl
->hw
->max_rx_aggregation_subframes
= wl
->conf
.ht
.rx_ba_win_size
;
6241 struct ieee80211_hw
*wlcore_alloc_hw(size_t priv_size
, u32 aggr_buf_size
,
6244 struct ieee80211_hw
*hw
;
6249 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
6251 wl1271_error("could not alloc ieee80211_hw");
6257 memset(wl
, 0, sizeof(*wl
));
6259 wl
->priv
= kzalloc(priv_size
, GFP_KERNEL
);
6261 wl1271_error("could not alloc wl priv");
6263 goto err_priv_alloc
;
6266 INIT_LIST_HEAD(&wl
->wlvif_list
);
6271 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS.
6272 * we don't allocate any additional resource here, so that's fine.
6274 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
6275 for (j
= 0; j
< WLCORE_MAX_LINKS
; j
++)
6276 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
6278 skb_queue_head_init(&wl
->deferred_rx_queue
);
6279 skb_queue_head_init(&wl
->deferred_tx_queue
);
6281 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
6282 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
6283 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
6284 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
6285 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
6286 INIT_DELAYED_WORK(&wl
->roc_complete_work
, wlcore_roc_complete_work
);
6287 INIT_DELAYED_WORK(&wl
->tx_watchdog_work
, wl12xx_tx_watchdog_work
);
6289 wl
->freezable_wq
= create_freezable_workqueue("wl12xx_wq");
6290 if (!wl
->freezable_wq
) {
6297 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
6298 wl
->band
= NL80211_BAND_2GHZ
;
6299 wl
->channel_type
= NL80211_CHAN_NO_HT
;
6301 wl
->sg_enabled
= true;
6302 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
6303 wl
->recovery_count
= 0;
6306 wl
->ap_fw_ps_map
= 0;
6308 wl
->system_hlid
= WL12XX_SYSTEM_HLID
;
6309 wl
->active_sta_count
= 0;
6310 wl
->active_link_count
= 0;
6313 /* The system link is always allocated */
6314 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
6316 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
6317 for (i
= 0; i
< wl
->num_tx_desc
; i
++)
6318 wl
->tx_frames
[i
] = NULL
;
6320 spin_lock_init(&wl
->wl_lock
);
6322 wl
->state
= WLCORE_STATE_OFF
;
6323 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
6324 mutex_init(&wl
->mutex
);
6325 mutex_init(&wl
->flush_mutex
);
6326 init_completion(&wl
->nvs_loading_complete
);
6328 order
= get_order(aggr_buf_size
);
6329 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
6330 if (!wl
->aggr_buf
) {
6334 wl
->aggr_buf_size
= aggr_buf_size
;
6336 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
6337 if (!wl
->dummy_packet
) {
6342 /* Allocate one page for the FW log */
6343 wl
->fwlog
= (u8
*)get_zeroed_page(GFP_KERNEL
);
6346 goto err_dummy_packet
;
6349 wl
->mbox_size
= mbox_size
;
6350 wl
->mbox
= kmalloc(wl
->mbox_size
, GFP_KERNEL
| GFP_DMA
);
6356 wl
->buffer_32
= kmalloc(sizeof(*wl
->buffer_32
), GFP_KERNEL
);
6357 if (!wl
->buffer_32
) {
6368 free_page((unsigned long)wl
->fwlog
);
6371 dev_kfree_skb(wl
->dummy_packet
);
6374 free_pages((unsigned long)wl
->aggr_buf
, order
);
6377 destroy_workqueue(wl
->freezable_wq
);
6380 wl1271_debugfs_exit(wl
);
6384 ieee80211_free_hw(hw
);
6388 return ERR_PTR(ret
);
6390 EXPORT_SYMBOL_GPL(wlcore_alloc_hw
);
6392 int wlcore_free_hw(struct wl1271
*wl
)
6394 /* Unblock any fwlog readers */
6395 mutex_lock(&wl
->mutex
);
6396 wl
->fwlog_size
= -1;
6397 mutex_unlock(&wl
->mutex
);
6399 wlcore_sysfs_free(wl
);
6401 kfree(wl
->buffer_32
);
6403 free_page((unsigned long)wl
->fwlog
);
6404 dev_kfree_skb(wl
->dummy_packet
);
6405 free_pages((unsigned long)wl
->aggr_buf
, get_order(wl
->aggr_buf_size
));
6407 wl1271_debugfs_exit(wl
);
6411 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
6415 kfree(wl
->raw_fw_status
);
6416 kfree(wl
->fw_status
);
6417 kfree(wl
->tx_res_if
);
6418 destroy_workqueue(wl
->freezable_wq
);
6421 ieee80211_free_hw(wl
->hw
);
6425 EXPORT_SYMBOL_GPL(wlcore_free_hw
);
6428 static const struct wiphy_wowlan_support wlcore_wowlan_support
= {
6429 .flags
= WIPHY_WOWLAN_ANY
,
6430 .n_patterns
= WL1271_MAX_RX_FILTERS
,
6431 .pattern_min_len
= 1,
6432 .pattern_max_len
= WL1271_RX_FILTER_MAX_PATTERN_SIZE
,
6436 static irqreturn_t
wlcore_hardirq(int irq
, void *cookie
)
6438 return IRQ_WAKE_THREAD
;
6441 static void wlcore_nvs_cb(const struct firmware
*fw
, void *context
)
6443 struct wl1271
*wl
= context
;
6444 struct platform_device
*pdev
= wl
->pdev
;
6445 struct wlcore_platdev_data
*pdev_data
= dev_get_platdata(&pdev
->dev
);
6446 struct resource
*res
;
6449 irq_handler_t hardirq_fn
= NULL
;
6452 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
6454 wl1271_error("Could not allocate nvs data");
6457 wl
->nvs_len
= fw
->size
;
6458 } else if (pdev_data
->family
->nvs_name
) {
6459 wl1271_debug(DEBUG_BOOT
, "Could not get nvs file %s",
6460 pdev_data
->family
->nvs_name
);
6468 ret
= wl
->ops
->setup(wl
);
6472 BUG_ON(wl
->num_tx_desc
> WLCORE_MAX_TX_DESCRIPTORS
);
6474 /* adjust some runtime configuration parameters */
6475 wlcore_adjust_conf(wl
);
6477 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
6479 wl1271_error("Could not get IRQ resource");
6483 wl
->irq
= res
->start
;
6484 wl
->irq_flags
= res
->flags
& IRQF_TRIGGER_MASK
;
6485 wl
->if_ops
= pdev_data
->if_ops
;
6487 if (wl
->irq_flags
& (IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
))
6488 hardirq_fn
= wlcore_hardirq
;
6490 wl
->irq_flags
|= IRQF_ONESHOT
;
6492 ret
= wl12xx_set_power_on(wl
);
6496 ret
= wl12xx_get_hw_info(wl
);
6498 wl1271_error("couldn't get hw info");
6499 wl1271_power_off(wl
);
6503 ret
= request_threaded_irq(wl
->irq
, hardirq_fn
, wlcore_irq
,
6504 wl
->irq_flags
, pdev
->name
, wl
);
6506 wl1271_error("interrupt configuration failed");
6507 wl1271_power_off(wl
);
6512 ret
= enable_irq_wake(wl
->irq
);
6514 wl
->irq_wake_enabled
= true;
6515 device_init_wakeup(wl
->dev
, 1);
6516 if (pdev_data
->pwr_in_suspend
)
6517 wl
->hw
->wiphy
->wowlan
= &wlcore_wowlan_support
;
6520 disable_irq(wl
->irq
);
6521 wl1271_power_off(wl
);
6523 ret
= wl
->ops
->identify_chip(wl
);
6527 ret
= wl1271_init_ieee80211(wl
);
6531 ret
= wl1271_register_hw(wl
);
6535 ret
= wlcore_sysfs_init(wl
);
6539 wl
->initialized
= true;
6543 wl1271_unregister_hw(wl
);
6546 free_irq(wl
->irq
, wl
);
6552 release_firmware(fw
);
6553 complete_all(&wl
->nvs_loading_complete
);
6556 int wlcore_probe(struct wl1271
*wl
, struct platform_device
*pdev
)
6558 struct wlcore_platdev_data
*pdev_data
= dev_get_platdata(&pdev
->dev
);
6559 const char *nvs_name
;
6562 if (!wl
->ops
|| !wl
->ptable
|| !pdev_data
)
6565 wl
->dev
= &pdev
->dev
;
6567 platform_set_drvdata(pdev
, wl
);
6569 if (pdev_data
->family
&& pdev_data
->family
->nvs_name
) {
6570 nvs_name
= pdev_data
->family
->nvs_name
;
6571 ret
= request_firmware_nowait(THIS_MODULE
, FW_ACTION_HOTPLUG
,
6572 nvs_name
, &pdev
->dev
, GFP_KERNEL
,
6575 wl1271_error("request_firmware_nowait failed for %s: %d",
6577 complete_all(&wl
->nvs_loading_complete
);
6580 wlcore_nvs_cb(NULL
, wl
);
6585 EXPORT_SYMBOL_GPL(wlcore_probe
);
6587 int wlcore_remove(struct platform_device
*pdev
)
6589 struct wlcore_platdev_data
*pdev_data
= dev_get_platdata(&pdev
->dev
);
6590 struct wl1271
*wl
= platform_get_drvdata(pdev
);
6592 if (pdev_data
->family
&& pdev_data
->family
->nvs_name
)
6593 wait_for_completion(&wl
->nvs_loading_complete
);
6594 if (!wl
->initialized
)
6597 if (wl
->irq_wake_enabled
) {
6598 device_init_wakeup(wl
->dev
, 0);
6599 disable_irq_wake(wl
->irq
);
6601 wl1271_unregister_hw(wl
);
6602 free_irq(wl
->irq
, wl
);
6607 EXPORT_SYMBOL_GPL(wlcore_remove
);
6609 u32 wl12xx_debug_level
= DEBUG_NONE
;
6610 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
6611 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
6612 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
6614 module_param_named(fwlog
, fwlog_param
, charp
, 0);
6615 MODULE_PARM_DESC(fwlog
,
6616 "FW logger options: continuous, dbgpins or disable");
6618 module_param(fwlog_mem_blocks
, int, S_IRUSR
| S_IWUSR
);
6619 MODULE_PARM_DESC(fwlog_mem_blocks
, "fwlog mem_blocks");
6621 module_param(bug_on_recovery
, int, S_IRUSR
| S_IWUSR
);
6622 MODULE_PARM_DESC(bug_on_recovery
, "BUG() on fw recovery");
6624 module_param(no_recovery
, int, S_IRUSR
| S_IWUSR
);
6625 MODULE_PARM_DESC(no_recovery
, "Prevent HW recovery. FW will remain stuck.");
6627 MODULE_LICENSE("GPL");
6628 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
6629 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");