3 * This file is part of wlcore
5 * Copyright (C) 2008-2010 Nokia Corporation
6 * Copyright (C) 2011-2013 Texas Instruments Inc.
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * version 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
24 #include <linux/module.h>
25 #include <linux/firmware.h>
26 #include <linux/etherdevice.h>
27 #include <linux/vmalloc.h>
28 #include <linux/wl12xx.h>
29 #include <linux/interrupt.h>
33 #include "wl12xx_80211.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_supported_band
*band
;
82 struct ieee80211_channel
*ch
;
84 struct ieee80211_hw
*hw
= wiphy_to_ieee80211_hw(wiphy
);
85 struct wl1271
*wl
= hw
->priv
;
87 band
= wiphy
->bands
[IEEE80211_BAND_5GHZ
];
88 for (i
= 0; i
< band
->n_channels
; i
++) {
89 ch
= &band
->channels
[i
];
90 if (ch
->flags
& IEEE80211_CHAN_DISABLED
)
93 if (ch
->flags
& IEEE80211_CHAN_RADAR
)
94 ch
->flags
|= IEEE80211_CHAN_NO_IR
;
98 wlcore_regdomain_config(wl
);
101 static int wl1271_set_rx_streaming(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
106 /* we should hold wl->mutex */
107 ret
= wl1271_acx_ps_rx_streaming(wl
, wlvif
, enable
);
112 set_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
);
114 clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
);
120 * this function is being called when the rx_streaming interval
121 * has beed changed or rx_streaming should be disabled
123 int wl1271_recalc_rx_streaming(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
126 int period
= wl
->conf
.rx_streaming
.interval
;
128 /* don't reconfigure if rx_streaming is disabled */
129 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
))
132 /* reconfigure/disable according to new streaming_period */
134 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) &&
135 (wl
->conf
.rx_streaming
.always
||
136 test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
137 ret
= wl1271_set_rx_streaming(wl
, wlvif
, true);
139 ret
= wl1271_set_rx_streaming(wl
, wlvif
, false);
140 /* don't cancel_work_sync since we might deadlock */
141 del_timer_sync(&wlvif
->rx_streaming_timer
);
147 static void wl1271_rx_streaming_enable_work(struct work_struct
*work
)
150 struct wl12xx_vif
*wlvif
= container_of(work
, struct wl12xx_vif
,
151 rx_streaming_enable_work
);
152 struct wl1271
*wl
= wlvif
->wl
;
154 mutex_lock(&wl
->mutex
);
156 if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
) ||
157 !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) ||
158 (!wl
->conf
.rx_streaming
.always
&&
159 !test_bit(WL1271_FLAG_SOFT_GEMINI
, &wl
->flags
)))
162 if (!wl
->conf
.rx_streaming
.interval
)
165 ret
= wl1271_ps_elp_wakeup(wl
);
169 ret
= wl1271_set_rx_streaming(wl
, wlvif
, true);
173 /* stop it after some time of inactivity */
174 mod_timer(&wlvif
->rx_streaming_timer
,
175 jiffies
+ msecs_to_jiffies(wl
->conf
.rx_streaming
.duration
));
178 wl1271_ps_elp_sleep(wl
);
180 mutex_unlock(&wl
->mutex
);
183 static void wl1271_rx_streaming_disable_work(struct work_struct
*work
)
186 struct wl12xx_vif
*wlvif
= container_of(work
, struct wl12xx_vif
,
187 rx_streaming_disable_work
);
188 struct wl1271
*wl
= wlvif
->wl
;
190 mutex_lock(&wl
->mutex
);
192 if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED
, &wlvif
->flags
))
195 ret
= wl1271_ps_elp_wakeup(wl
);
199 ret
= wl1271_set_rx_streaming(wl
, wlvif
, false);
204 wl1271_ps_elp_sleep(wl
);
206 mutex_unlock(&wl
->mutex
);
209 static void wl1271_rx_streaming_timer(unsigned long data
)
211 struct wl12xx_vif
*wlvif
= (struct wl12xx_vif
*)data
;
212 struct wl1271
*wl
= wlvif
->wl
;
213 ieee80211_queue_work(wl
->hw
, &wlvif
->rx_streaming_disable_work
);
216 /* wl->mutex must be taken */
217 void wl12xx_rearm_tx_watchdog_locked(struct wl1271
*wl
)
219 /* if the watchdog is not armed, don't do anything */
220 if (wl
->tx_allocated_blocks
== 0)
223 cancel_delayed_work(&wl
->tx_watchdog_work
);
224 ieee80211_queue_delayed_work(wl
->hw
, &wl
->tx_watchdog_work
,
225 msecs_to_jiffies(wl
->conf
.tx
.tx_watchdog_timeout
));
228 static void wl12xx_tx_watchdog_work(struct work_struct
*work
)
230 struct delayed_work
*dwork
;
233 dwork
= container_of(work
, struct delayed_work
, work
);
234 wl
= container_of(dwork
, struct wl1271
, tx_watchdog_work
);
236 mutex_lock(&wl
->mutex
);
238 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
241 /* Tx went out in the meantime - everything is ok */
242 if (unlikely(wl
->tx_allocated_blocks
== 0))
246 * if a ROC is in progress, we might not have any Tx for a long
247 * time (e.g. pending Tx on the non-ROC channels)
249 if (find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
) {
250 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms due to ROC",
251 wl
->conf
.tx
.tx_watchdog_timeout
);
252 wl12xx_rearm_tx_watchdog_locked(wl
);
257 * if a scan is in progress, we might not have any Tx for a long
260 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
) {
261 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms due to scan",
262 wl
->conf
.tx
.tx_watchdog_timeout
);
263 wl12xx_rearm_tx_watchdog_locked(wl
);
268 * AP might cache a frame for a long time for a sleeping station,
269 * so rearm the timer if there's an AP interface with stations. If
270 * Tx is genuinely stuck we will most hopefully discover it when all
271 * stations are removed due to inactivity.
273 if (wl
->active_sta_count
) {
274 wl1271_debug(DEBUG_TX
, "No Tx (in FW) for %d ms. AP has "
276 wl
->conf
.tx
.tx_watchdog_timeout
,
277 wl
->active_sta_count
);
278 wl12xx_rearm_tx_watchdog_locked(wl
);
282 wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
283 wl
->conf
.tx
.tx_watchdog_timeout
);
284 wl12xx_queue_recovery_work(wl
);
287 mutex_unlock(&wl
->mutex
);
290 static void wlcore_adjust_conf(struct wl1271
*wl
)
292 /* Adjust settings according to optional module parameters */
294 /* Firmware Logger params */
295 if (fwlog_mem_blocks
!= -1) {
296 if (fwlog_mem_blocks
>= CONF_FWLOG_MIN_MEM_BLOCKS
&&
297 fwlog_mem_blocks
<= CONF_FWLOG_MAX_MEM_BLOCKS
) {
298 wl
->conf
.fwlog
.mem_blocks
= fwlog_mem_blocks
;
301 "Illegal fwlog_mem_blocks=%d using default %d",
302 fwlog_mem_blocks
, wl
->conf
.fwlog
.mem_blocks
);
307 if (!strcmp(fwlog_param
, "continuous")) {
308 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
309 } else if (!strcmp(fwlog_param
, "ondemand")) {
310 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_ON_DEMAND
;
311 } else if (!strcmp(fwlog_param
, "dbgpins")) {
312 wl
->conf
.fwlog
.mode
= WL12XX_FWLOG_CONTINUOUS
;
313 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_DBG_PINS
;
314 } else if (!strcmp(fwlog_param
, "disable")) {
315 wl
->conf
.fwlog
.mem_blocks
= 0;
316 wl
->conf
.fwlog
.output
= WL12XX_FWLOG_OUTPUT_NONE
;
318 wl1271_error("Unknown fwlog parameter %s", fwlog_param
);
322 if (bug_on_recovery
!= -1)
323 wl
->conf
.recovery
.bug_on_recovery
= (u8
) bug_on_recovery
;
325 if (no_recovery
!= -1)
326 wl
->conf
.recovery
.no_recovery
= (u8
) no_recovery
;
329 static void wl12xx_irq_ps_regulate_link(struct wl1271
*wl
,
330 struct wl12xx_vif
*wlvif
,
335 fw_ps
= test_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
338 * Wake up from high level PS if the STA is asleep with too little
339 * packets in FW or if the STA is awake.
341 if (!fw_ps
|| tx_pkts
< WL1271_PS_STA_MAX_PACKETS
)
342 wl12xx_ps_link_end(wl
, wlvif
, hlid
);
345 * Start high-level PS if the STA is asleep with enough blocks in FW.
346 * Make an exception if this is the only connected link. In this
347 * case FW-memory congestion is less of a problem.
348 * Note that a single connected STA means 2*ap_count + 1 active links,
349 * since we must account for the global and broadcast AP links
350 * for each AP. The "fw_ps" check assures us the other link is a STA
351 * connected to the AP. Otherwise the FW would not set the PSM bit.
353 else if (wl
->active_link_count
> (wl
->ap_count
*2 + 1) && fw_ps
&&
354 tx_pkts
>= WL1271_PS_STA_MAX_PACKETS
)
355 wl12xx_ps_link_start(wl
, wlvif
, hlid
, true);
358 static void wl12xx_irq_update_links_status(struct wl1271
*wl
,
359 struct wl12xx_vif
*wlvif
,
360 struct wl_fw_status
*status
)
365 cur_fw_ps_map
= status
->link_ps_bitmap
;
366 if (wl
->ap_fw_ps_map
!= cur_fw_ps_map
) {
367 wl1271_debug(DEBUG_PSM
,
368 "link ps prev 0x%x cur 0x%x changed 0x%x",
369 wl
->ap_fw_ps_map
, cur_fw_ps_map
,
370 wl
->ap_fw_ps_map
^ cur_fw_ps_map
);
372 wl
->ap_fw_ps_map
= cur_fw_ps_map
;
375 for_each_set_bit(hlid
, wlvif
->ap
.sta_hlid_map
, wl
->num_links
)
376 wl12xx_irq_ps_regulate_link(wl
, wlvif
, hlid
,
377 wl
->links
[hlid
].allocated_pkts
);
380 static int wlcore_fw_status(struct wl1271
*wl
, struct wl_fw_status
*status
)
382 struct wl12xx_vif
*wlvif
;
384 u32 old_tx_blk_count
= wl
->tx_blocks_available
;
385 int avail
, freed_blocks
;
388 struct wl1271_link
*lnk
;
390 ret
= wlcore_raw_read_data(wl
, REG_RAW_FW_STATUS_ADDR
,
392 wl
->fw_status_len
, false);
396 wlcore_hw_convert_fw_status(wl
, wl
->raw_fw_status
, wl
->fw_status
);
398 wl1271_debug(DEBUG_IRQ
, "intr: 0x%x (fw_rx_counter = %d, "
399 "drv_rx_counter = %d, tx_results_counter = %d)",
401 status
->fw_rx_counter
,
402 status
->drv_rx_counter
,
403 status
->tx_results_counter
);
405 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
406 /* prevent wrap-around in freed-packets counter */
407 wl
->tx_allocated_pkts
[i
] -=
408 (status
->counters
.tx_released_pkts
[i
] -
409 wl
->tx_pkts_freed
[i
]) & 0xff;
411 wl
->tx_pkts_freed
[i
] = status
->counters
.tx_released_pkts
[i
];
415 for_each_set_bit(i
, wl
->links_map
, wl
->num_links
) {
419 /* prevent wrap-around in freed-packets counter */
420 diff
= (status
->counters
.tx_lnk_free_pkts
[i
] -
421 lnk
->prev_freed_pkts
) & 0xff;
426 lnk
->allocated_pkts
-= diff
;
427 lnk
->prev_freed_pkts
= status
->counters
.tx_lnk_free_pkts
[i
];
429 /* accumulate the prev_freed_pkts counter */
430 lnk
->total_freed_pkts
+= diff
;
433 /* prevent wrap-around in total blocks counter */
434 if (likely(wl
->tx_blocks_freed
<= status
->total_released_blks
))
435 freed_blocks
= status
->total_released_blks
-
438 freed_blocks
= 0x100000000LL
- wl
->tx_blocks_freed
+
439 status
->total_released_blks
;
441 wl
->tx_blocks_freed
= status
->total_released_blks
;
443 wl
->tx_allocated_blocks
-= freed_blocks
;
446 * If the FW freed some blocks:
447 * If we still have allocated blocks - re-arm the timer, Tx is
448 * not stuck. Otherwise, cancel the timer (no Tx currently).
451 if (wl
->tx_allocated_blocks
)
452 wl12xx_rearm_tx_watchdog_locked(wl
);
454 cancel_delayed_work(&wl
->tx_watchdog_work
);
457 avail
= status
->tx_total
- wl
->tx_allocated_blocks
;
460 * The FW might change the total number of TX memblocks before
461 * we get a notification about blocks being released. Thus, the
462 * available blocks calculation might yield a temporary result
463 * which is lower than the actual available blocks. Keeping in
464 * mind that only blocks that were allocated can be moved from
465 * TX to RX, tx_blocks_available should never decrease here.
467 wl
->tx_blocks_available
= max((int)wl
->tx_blocks_available
,
470 /* if more blocks are available now, tx work can be scheduled */
471 if (wl
->tx_blocks_available
> old_tx_blk_count
)
472 clear_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
);
474 /* for AP update num of allocated TX blocks per link and ps status */
475 wl12xx_for_each_wlvif_ap(wl
, wlvif
) {
476 wl12xx_irq_update_links_status(wl
, wlvif
, status
);
479 /* update the host-chipset time offset */
481 wl
->time_offset
= (timespec_to_ns(&ts
) >> 10) -
482 (s64
)(status
->fw_localtime
);
484 wl
->fw_fast_lnk_map
= status
->link_fast_bitmap
;
489 static void wl1271_flush_deferred_work(struct wl1271
*wl
)
493 /* Pass all received frames to the network stack */
494 while ((skb
= skb_dequeue(&wl
->deferred_rx_queue
)))
495 ieee80211_rx_ni(wl
->hw
, skb
);
497 /* Return sent skbs to the network stack */
498 while ((skb
= skb_dequeue(&wl
->deferred_tx_queue
)))
499 ieee80211_tx_status_ni(wl
->hw
, skb
);
502 static void wl1271_netstack_work(struct work_struct
*work
)
505 container_of(work
, struct wl1271
, netstack_work
);
508 wl1271_flush_deferred_work(wl
);
509 } while (skb_queue_len(&wl
->deferred_rx_queue
));
512 #define WL1271_IRQ_MAX_LOOPS 256
514 static int wlcore_irq_locked(struct wl1271
*wl
)
518 int loopcount
= WL1271_IRQ_MAX_LOOPS
;
520 unsigned int defer_count
;
524 * In case edge triggered interrupt must be used, we cannot iterate
525 * more than once without introducing race conditions with the hardirq.
527 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
)
530 wl1271_debug(DEBUG_IRQ
, "IRQ work");
532 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
535 ret
= wl1271_ps_elp_wakeup(wl
);
539 while (!done
&& loopcount
--) {
541 * In order to avoid a race with the hardirq, clear the flag
542 * before acknowledging the chip. Since the mutex is held,
543 * wl1271_ps_elp_wakeup cannot be called concurrently.
545 clear_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
546 smp_mb__after_atomic();
548 ret
= wlcore_fw_status(wl
, wl
->fw_status
);
552 wlcore_hw_tx_immediate_compl(wl
);
554 intr
= wl
->fw_status
->intr
;
555 intr
&= WLCORE_ALL_INTR_MASK
;
561 if (unlikely(intr
& WL1271_ACX_INTR_WATCHDOG
)) {
562 wl1271_error("HW watchdog interrupt received! starting recovery.");
563 wl
->watchdog_recovery
= true;
566 /* restarting the chip. ignore any other interrupt. */
570 if (unlikely(intr
& WL1271_ACX_SW_INTR_WATCHDOG
)) {
571 wl1271_error("SW watchdog interrupt received! "
572 "starting recovery.");
573 wl
->watchdog_recovery
= true;
576 /* restarting the chip. ignore any other interrupt. */
580 if (likely(intr
& WL1271_ACX_INTR_DATA
)) {
581 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_DATA");
583 ret
= wlcore_rx(wl
, wl
->fw_status
);
587 /* Check if any tx blocks were freed */
588 spin_lock_irqsave(&wl
->wl_lock
, flags
);
589 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
590 wl1271_tx_total_queue_count(wl
) > 0) {
591 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
593 * In order to avoid starvation of the TX path,
594 * call the work function directly.
596 ret
= wlcore_tx_work_locked(wl
);
600 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
603 /* check for tx results */
604 ret
= wlcore_hw_tx_delayed_compl(wl
);
608 /* Make sure the deferred queues don't get too long */
609 defer_count
= skb_queue_len(&wl
->deferred_tx_queue
) +
610 skb_queue_len(&wl
->deferred_rx_queue
);
611 if (defer_count
> WL1271_DEFERRED_QUEUE_LIMIT
)
612 wl1271_flush_deferred_work(wl
);
615 if (intr
& WL1271_ACX_INTR_EVENT_A
) {
616 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_A");
617 ret
= wl1271_event_handle(wl
, 0);
622 if (intr
& WL1271_ACX_INTR_EVENT_B
) {
623 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_EVENT_B");
624 ret
= wl1271_event_handle(wl
, 1);
629 if (intr
& WL1271_ACX_INTR_INIT_COMPLETE
)
630 wl1271_debug(DEBUG_IRQ
,
631 "WL1271_ACX_INTR_INIT_COMPLETE");
633 if (intr
& WL1271_ACX_INTR_HW_AVAILABLE
)
634 wl1271_debug(DEBUG_IRQ
, "WL1271_ACX_INTR_HW_AVAILABLE");
637 wl1271_ps_elp_sleep(wl
);
643 static irqreturn_t
wlcore_irq(int irq
, void *cookie
)
647 struct wl1271
*wl
= cookie
;
649 /* complete the ELP completion */
650 spin_lock_irqsave(&wl
->wl_lock
, flags
);
651 set_bit(WL1271_FLAG_IRQ_RUNNING
, &wl
->flags
);
653 complete(wl
->elp_compl
);
654 wl
->elp_compl
= NULL
;
657 if (test_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
)) {
658 /* don't enqueue a work right now. mark it as pending */
659 set_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
);
660 wl1271_debug(DEBUG_IRQ
, "should not enqueue work");
661 disable_irq_nosync(wl
->irq
);
662 pm_wakeup_event(wl
->dev
, 0);
663 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
666 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
668 /* TX might be handled here, avoid redundant work */
669 set_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
670 cancel_work_sync(&wl
->tx_work
);
672 mutex_lock(&wl
->mutex
);
674 ret
= wlcore_irq_locked(wl
);
676 wl12xx_queue_recovery_work(wl
);
678 spin_lock_irqsave(&wl
->wl_lock
, flags
);
679 /* In case TX was not handled here, queue TX work */
680 clear_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
);
681 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
682 wl1271_tx_total_queue_count(wl
) > 0)
683 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
684 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
686 mutex_unlock(&wl
->mutex
);
691 struct vif_counter_data
{
694 struct ieee80211_vif
*cur_vif
;
695 bool cur_vif_running
;
698 static void wl12xx_vif_count_iter(void *data
, u8
*mac
,
699 struct ieee80211_vif
*vif
)
701 struct vif_counter_data
*counter
= data
;
704 if (counter
->cur_vif
== vif
)
705 counter
->cur_vif_running
= true;
708 /* caller must not hold wl->mutex, as it might deadlock */
709 static void wl12xx_get_vif_count(struct ieee80211_hw
*hw
,
710 struct ieee80211_vif
*cur_vif
,
711 struct vif_counter_data
*data
)
713 memset(data
, 0, sizeof(*data
));
714 data
->cur_vif
= cur_vif
;
716 ieee80211_iterate_active_interfaces(hw
, IEEE80211_IFACE_ITER_RESUME_ALL
,
717 wl12xx_vif_count_iter
, data
);
720 static int wl12xx_fetch_firmware(struct wl1271
*wl
, bool plt
)
722 const struct firmware
*fw
;
724 enum wl12xx_fw_type fw_type
;
728 fw_type
= WL12XX_FW_TYPE_PLT
;
729 fw_name
= wl
->plt_fw_name
;
732 * we can't call wl12xx_get_vif_count() here because
733 * wl->mutex is taken, so use the cached last_vif_count value
735 if (wl
->last_vif_count
> 1 && wl
->mr_fw_name
) {
736 fw_type
= WL12XX_FW_TYPE_MULTI
;
737 fw_name
= wl
->mr_fw_name
;
739 fw_type
= WL12XX_FW_TYPE_NORMAL
;
740 fw_name
= wl
->sr_fw_name
;
744 if (wl
->fw_type
== fw_type
)
747 wl1271_debug(DEBUG_BOOT
, "booting firmware %s", fw_name
);
749 ret
= request_firmware(&fw
, fw_name
, wl
->dev
);
752 wl1271_error("could not get firmware %s: %d", fw_name
, ret
);
757 wl1271_error("firmware size is not multiple of 32 bits: %zu",
764 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
765 wl
->fw_len
= fw
->size
;
766 wl
->fw
= vmalloc(wl
->fw_len
);
769 wl1271_error("could not allocate memory for the firmware");
774 memcpy(wl
->fw
, fw
->data
, wl
->fw_len
);
776 wl
->fw_type
= fw_type
;
778 release_firmware(fw
);
783 void wl12xx_queue_recovery_work(struct wl1271
*wl
)
785 /* Avoid a recursive recovery */
786 if (wl
->state
== WLCORE_STATE_ON
) {
787 WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
,
790 wl
->state
= WLCORE_STATE_RESTARTING
;
791 set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
792 wl1271_ps_elp_wakeup(wl
);
793 wlcore_disable_interrupts_nosync(wl
);
794 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
798 size_t wl12xx_copy_fwlog(struct wl1271
*wl
, u8
*memblock
, size_t maxlen
)
802 /* Make sure we have enough room */
803 len
= min_t(size_t, maxlen
, PAGE_SIZE
- wl
->fwlog_size
);
805 /* Fill the FW log file, consumed by the sysfs fwlog entry */
806 memcpy(wl
->fwlog
+ wl
->fwlog_size
, memblock
, len
);
807 wl
->fwlog_size
+= len
;
812 static void wl12xx_read_fwlog_panic(struct wl1271
*wl
)
814 struct wlcore_partition_set part
, old_part
;
821 if ((wl
->quirks
& WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED
) ||
822 (wl
->conf
.fwlog
.mem_blocks
== 0))
825 wl1271_info("Reading FW panic log");
827 block
= kmalloc(wl
->fw_mem_block_size
, GFP_KERNEL
);
832 * Make sure the chip is awake and the logger isn't active.
833 * Do not send a stop fwlog command if the fw is hanged or if
834 * dbgpins are used (due to some fw bug).
836 if (wl1271_ps_elp_wakeup(wl
))
838 if (!wl
->watchdog_recovery
&&
839 wl
->conf
.fwlog
.output
!= WL12XX_FWLOG_OUTPUT_DBG_PINS
)
840 wl12xx_cmd_stop_fwlog(wl
);
842 /* Read the first memory block address */
843 ret
= wlcore_fw_status(wl
, wl
->fw_status
);
847 addr
= wl
->fw_status
->log_start_addr
;
851 if (wl
->conf
.fwlog
.mode
== WL12XX_FWLOG_CONTINUOUS
) {
852 offset
= sizeof(addr
) + sizeof(struct wl1271_rx_descriptor
);
853 end_of_log
= wl
->fwlog_end
;
855 offset
= sizeof(addr
);
859 old_part
= wl
->curr_part
;
860 memset(&part
, 0, sizeof(part
));
862 /* Traverse the memory blocks linked list */
864 part
.mem
.start
= wlcore_hw_convert_hwaddr(wl
, addr
);
865 part
.mem
.size
= PAGE_SIZE
;
867 ret
= wlcore_set_partition(wl
, &part
);
869 wl1271_error("%s: set_partition start=0x%X size=%d",
870 __func__
, part
.mem
.start
, part
.mem
.size
);
874 memset(block
, 0, wl
->fw_mem_block_size
);
875 ret
= wlcore_read_hwaddr(wl
, addr
, block
,
876 wl
->fw_mem_block_size
, false);
882 * Memory blocks are linked to one another. The first 4 bytes
883 * of each memory block hold the hardware address of the next
884 * one. The last memory block points to the first one in
885 * on demand mode and is equal to 0x2000000 in continuous mode.
887 addr
= le32_to_cpup((__le32
*)block
);
889 if (!wl12xx_copy_fwlog(wl
, block
+ offset
,
890 wl
->fw_mem_block_size
- offset
))
892 } while (addr
&& (addr
!= end_of_log
));
894 wake_up_interruptible(&wl
->fwlog_waitq
);
898 wlcore_set_partition(wl
, &old_part
);
901 static void wlcore_print_recovery(struct wl1271
*wl
)
907 wl1271_info("Hardware recovery in progress. FW ver: %s",
908 wl
->chip
.fw_ver_str
);
910 /* change partitions momentarily so we can read the FW pc */
911 ret
= wlcore_set_partition(wl
, &wl
->ptable
[PART_BOOT
]);
915 ret
= wlcore_read_reg(wl
, REG_PC_ON_RECOVERY
, &pc
);
919 ret
= wlcore_read_reg(wl
, REG_INTERRUPT_NO_CLEAR
, &hint_sts
);
923 wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
924 pc
, hint_sts
, ++wl
->recovery_count
);
926 wlcore_set_partition(wl
, &wl
->ptable
[PART_WORK
]);
930 static void wl1271_recovery_work(struct work_struct
*work
)
933 container_of(work
, struct wl1271
, recovery_work
);
934 struct wl12xx_vif
*wlvif
;
935 struct ieee80211_vif
*vif
;
937 mutex_lock(&wl
->mutex
);
939 if (wl
->state
== WLCORE_STATE_OFF
|| wl
->plt
)
942 if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
)) {
943 if (wl
->conf
.fwlog
.output
== WL12XX_FWLOG_OUTPUT_HOST
)
944 wl12xx_read_fwlog_panic(wl
);
945 wlcore_print_recovery(wl
);
948 BUG_ON(wl
->conf
.recovery
.bug_on_recovery
&&
949 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
));
951 if (wl
->conf
.recovery
.no_recovery
) {
952 wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
956 /* Prevent spurious TX during FW restart */
957 wlcore_stop_queues(wl
, WLCORE_QUEUE_STOP_REASON_FW_RESTART
);
959 /* reboot the chipset */
960 while (!list_empty(&wl
->wlvif_list
)) {
961 wlvif
= list_first_entry(&wl
->wlvif_list
,
962 struct wl12xx_vif
, list
);
963 vif
= wl12xx_wlvif_to_vif(wlvif
);
964 __wl1271_op_remove_interface(wl
, vif
, false);
967 wlcore_op_stop_locked(wl
);
969 ieee80211_restart_hw(wl
->hw
);
972 * Its safe to enable TX now - the queues are stopped after a request
975 wlcore_wake_queues(wl
, WLCORE_QUEUE_STOP_REASON_FW_RESTART
);
978 wl
->watchdog_recovery
= false;
979 clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
);
980 mutex_unlock(&wl
->mutex
);
983 static int wlcore_fw_wakeup(struct wl1271
*wl
)
985 return wlcore_raw_write32(wl
, HW_ACCESS_ELP_CTRL_REG
, ELPCTRL_WAKE_UP
);
988 static int wl1271_setup(struct wl1271
*wl
)
990 wl
->raw_fw_status
= kzalloc(wl
->fw_status_len
, GFP_KERNEL
);
991 if (!wl
->raw_fw_status
)
994 wl
->fw_status
= kzalloc(sizeof(*wl
->fw_status
), GFP_KERNEL
);
998 wl
->tx_res_if
= kzalloc(sizeof(*wl
->tx_res_if
), GFP_KERNEL
);
1004 kfree(wl
->fw_status
);
1005 kfree(wl
->raw_fw_status
);
1009 static int wl12xx_set_power_on(struct wl1271
*wl
)
1013 msleep(WL1271_PRE_POWER_ON_SLEEP
);
1014 ret
= wl1271_power_on(wl
);
1017 msleep(WL1271_POWER_ON_SLEEP
);
1018 wl1271_io_reset(wl
);
1021 ret
= wlcore_set_partition(wl
, &wl
->ptable
[PART_BOOT
]);
1025 /* ELP module wake up */
1026 ret
= wlcore_fw_wakeup(wl
);
1034 wl1271_power_off(wl
);
1038 static int wl12xx_chip_wakeup(struct wl1271
*wl
, bool plt
)
1042 ret
= wl12xx_set_power_on(wl
);
1047 * For wl127x based devices we could use the default block
1048 * size (512 bytes), but due to a bug in the sdio driver, we
1049 * need to set it explicitly after the chip is powered on. To
1050 * simplify the code and since the performance impact is
1051 * negligible, we use the same block size for all different
1054 * Check if the bus supports blocksize alignment and, if it
1055 * doesn't, make sure we don't have the quirk.
1057 if (!wl1271_set_block_size(wl
))
1058 wl
->quirks
&= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN
;
1060 /* TODO: make sure the lower driver has set things up correctly */
1062 ret
= wl1271_setup(wl
);
1066 ret
= wl12xx_fetch_firmware(wl
, plt
);
1074 int wl1271_plt_start(struct wl1271
*wl
, const enum plt_mode plt_mode
)
1076 int retries
= WL1271_BOOT_RETRIES
;
1077 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
1079 static const char* const PLT_MODE
[] = {
1088 mutex_lock(&wl
->mutex
);
1090 wl1271_notice("power up");
1092 if (wl
->state
!= WLCORE_STATE_OFF
) {
1093 wl1271_error("cannot go into PLT state because not "
1094 "in off state: %d", wl
->state
);
1099 /* Indicate to lower levels that we are now in PLT mode */
1101 wl
->plt_mode
= plt_mode
;
1105 ret
= wl12xx_chip_wakeup(wl
, true);
1109 if (plt_mode
!= PLT_CHIP_AWAKE
) {
1110 ret
= wl
->ops
->plt_init(wl
);
1115 wl
->state
= WLCORE_STATE_ON
;
1116 wl1271_notice("firmware booted in PLT mode %s (%s)",
1118 wl
->chip
.fw_ver_str
);
1120 /* update hw/fw version info in wiphy struct */
1121 wiphy
->hw_version
= wl
->chip
.id
;
1122 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
1123 sizeof(wiphy
->fw_version
));
1128 wl1271_power_off(wl
);
1132 wl
->plt_mode
= PLT_OFF
;
1134 wl1271_error("firmware boot in PLT mode failed despite %d retries",
1135 WL1271_BOOT_RETRIES
);
1137 mutex_unlock(&wl
->mutex
);
1142 int wl1271_plt_stop(struct wl1271
*wl
)
1146 wl1271_notice("power down");
1149 * Interrupts must be disabled before setting the state to OFF.
1150 * Otherwise, the interrupt handler might be called and exit without
1151 * reading the interrupt status.
1153 wlcore_disable_interrupts(wl
);
1154 mutex_lock(&wl
->mutex
);
1156 mutex_unlock(&wl
->mutex
);
1159 * This will not necessarily enable interrupts as interrupts
1160 * may have been disabled when op_stop was called. It will,
1161 * however, balance the above call to disable_interrupts().
1163 wlcore_enable_interrupts(wl
);
1165 wl1271_error("cannot power down because not in PLT "
1166 "state: %d", wl
->state
);
1171 mutex_unlock(&wl
->mutex
);
1173 wl1271_flush_deferred_work(wl
);
1174 cancel_work_sync(&wl
->netstack_work
);
1175 cancel_work_sync(&wl
->recovery_work
);
1176 cancel_delayed_work_sync(&wl
->elp_work
);
1177 cancel_delayed_work_sync(&wl
->tx_watchdog_work
);
1179 mutex_lock(&wl
->mutex
);
1180 wl1271_power_off(wl
);
1182 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
1183 wl
->state
= WLCORE_STATE_OFF
;
1185 wl
->plt_mode
= PLT_OFF
;
1187 mutex_unlock(&wl
->mutex
);
1193 static void wl1271_op_tx(struct ieee80211_hw
*hw
,
1194 struct ieee80211_tx_control
*control
,
1195 struct sk_buff
*skb
)
1197 struct wl1271
*wl
= hw
->priv
;
1198 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
1199 struct ieee80211_vif
*vif
= info
->control
.vif
;
1200 struct wl12xx_vif
*wlvif
= NULL
;
1201 unsigned long flags
;
1206 wl1271_debug(DEBUG_TX
, "DROP skb with no vif");
1207 ieee80211_free_txskb(hw
, skb
);
1211 wlvif
= wl12xx_vif_to_data(vif
);
1212 mapping
= skb_get_queue_mapping(skb
);
1213 q
= wl1271_tx_get_queue(mapping
);
1215 hlid
= wl12xx_tx_get_hlid(wl
, wlvif
, skb
, control
->sta
);
1217 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1220 * drop the packet if the link is invalid or the queue is stopped
1221 * for any reason but watermark. Watermark is a "soft"-stop so we
1222 * allow these packets through.
1224 if (hlid
== WL12XX_INVALID_LINK_ID
||
1225 (!test_bit(hlid
, wlvif
->links_map
)) ||
1226 (wlcore_is_queue_stopped_locked(wl
, wlvif
, q
) &&
1227 !wlcore_is_queue_stopped_by_reason_locked(wl
, wlvif
, q
,
1228 WLCORE_QUEUE_STOP_REASON_WATERMARK
))) {
1229 wl1271_debug(DEBUG_TX
, "DROP skb hlid %d q %d", hlid
, q
);
1230 ieee80211_free_txskb(hw
, skb
);
1234 wl1271_debug(DEBUG_TX
, "queue skb hlid %d q %d len %d",
1236 skb_queue_tail(&wl
->links
[hlid
].tx_queue
[q
], skb
);
1238 wl
->tx_queue_count
[q
]++;
1239 wlvif
->tx_queue_count
[q
]++;
1242 * The workqueue is slow to process the tx_queue and we need stop
1243 * the queue here, otherwise the queue will get too long.
1245 if (wlvif
->tx_queue_count
[q
] >= WL1271_TX_QUEUE_HIGH_WATERMARK
&&
1246 !wlcore_is_queue_stopped_by_reason_locked(wl
, wlvif
, q
,
1247 WLCORE_QUEUE_STOP_REASON_WATERMARK
)) {
1248 wl1271_debug(DEBUG_TX
, "op_tx: stopping queues for q %d", q
);
1249 wlcore_stop_queue_locked(wl
, wlvif
, q
,
1250 WLCORE_QUEUE_STOP_REASON_WATERMARK
);
1254 * The chip specific setup must run before the first TX packet -
1255 * before that, the tx_work will not be initialized!
1258 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
) &&
1259 !test_bit(WL1271_FLAG_TX_PENDING
, &wl
->flags
))
1260 ieee80211_queue_work(wl
->hw
, &wl
->tx_work
);
1263 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1266 int wl1271_tx_dummy_packet(struct wl1271
*wl
)
1268 unsigned long flags
;
1271 /* no need to queue a new dummy packet if one is already pending */
1272 if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
))
1275 q
= wl1271_tx_get_queue(skb_get_queue_mapping(wl
->dummy_packet
));
1277 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1278 set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING
, &wl
->flags
);
1279 wl
->tx_queue_count
[q
]++;
1280 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1282 /* The FW is low on RX memory blocks, so send the dummy packet asap */
1283 if (!test_bit(WL1271_FLAG_FW_TX_BUSY
, &wl
->flags
))
1284 return wlcore_tx_work_locked(wl
);
1287 * If the FW TX is busy, TX work will be scheduled by the threaded
1288 * interrupt handler function
1294 * The size of the dummy packet should be at least 1400 bytes. However, in
1295 * order to minimize the number of bus transactions, aligning it to 512 bytes
1296 * boundaries could be beneficial, performance wise
1298 #define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1300 static struct sk_buff
*wl12xx_alloc_dummy_packet(struct wl1271
*wl
)
1302 struct sk_buff
*skb
;
1303 struct ieee80211_hdr_3addr
*hdr
;
1304 unsigned int dummy_packet_size
;
1306 dummy_packet_size
= TOTAL_TX_DUMMY_PACKET_SIZE
-
1307 sizeof(struct wl1271_tx_hw_descr
) - sizeof(*hdr
);
1309 skb
= dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE
);
1311 wl1271_warning("Failed to allocate a dummy packet skb");
1315 skb_reserve(skb
, sizeof(struct wl1271_tx_hw_descr
));
1317 hdr
= (struct ieee80211_hdr_3addr
*) skb_put(skb
, sizeof(*hdr
));
1318 memset(hdr
, 0, sizeof(*hdr
));
1319 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_DATA
|
1320 IEEE80211_STYPE_NULLFUNC
|
1321 IEEE80211_FCTL_TODS
);
1323 memset(skb_put(skb
, dummy_packet_size
), 0, dummy_packet_size
);
1325 /* Dummy packets require the TID to be management */
1326 skb
->priority
= WL1271_TID_MGMT
;
1328 /* Initialize all fields that might be used */
1329 skb_set_queue_mapping(skb
, 0);
1330 memset(IEEE80211_SKB_CB(skb
), 0, sizeof(struct ieee80211_tx_info
));
1338 wl1271_validate_wowlan_pattern(struct cfg80211_pkt_pattern
*p
)
1340 int num_fields
= 0, in_field
= 0, fields_size
= 0;
1341 int i
, pattern_len
= 0;
1344 wl1271_warning("No mask in WoWLAN pattern");
1349 * The pattern is broken up into segments of bytes at different offsets
1350 * that need to be checked by the FW filter. Each segment is called
1351 * a field in the FW API. We verify that the total number of fields
1352 * required for this pattern won't exceed FW limits (8)
1353 * as well as the total fields buffer won't exceed the FW limit.
1354 * Note that if there's a pattern which crosses Ethernet/IP header
1355 * boundary a new field is required.
1357 for (i
= 0; i
< p
->pattern_len
; i
++) {
1358 if (test_bit(i
, (unsigned long *)p
->mask
)) {
1363 if (i
== WL1271_RX_FILTER_ETH_HEADER_SIZE
) {
1365 fields_size
+= pattern_len
+
1366 RX_FILTER_FIELD_OVERHEAD
;
1374 fields_size
+= pattern_len
+
1375 RX_FILTER_FIELD_OVERHEAD
;
1382 fields_size
+= pattern_len
+ RX_FILTER_FIELD_OVERHEAD
;
1386 if (num_fields
> WL1271_RX_FILTER_MAX_FIELDS
) {
1387 wl1271_warning("RX Filter too complex. Too many segments");
1391 if (fields_size
> WL1271_RX_FILTER_MAX_FIELDS_SIZE
) {
1392 wl1271_warning("RX filter pattern is too big");
1399 struct wl12xx_rx_filter
*wl1271_rx_filter_alloc(void)
1401 return kzalloc(sizeof(struct wl12xx_rx_filter
), GFP_KERNEL
);
1404 void wl1271_rx_filter_free(struct wl12xx_rx_filter
*filter
)
1411 for (i
= 0; i
< filter
->num_fields
; i
++)
1412 kfree(filter
->fields
[i
].pattern
);
1417 int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter
*filter
,
1418 u16 offset
, u8 flags
,
1419 const u8
*pattern
, u8 len
)
1421 struct wl12xx_rx_filter_field
*field
;
1423 if (filter
->num_fields
== WL1271_RX_FILTER_MAX_FIELDS
) {
1424 wl1271_warning("Max fields per RX filter. can't alloc another");
1428 field
= &filter
->fields
[filter
->num_fields
];
1430 field
->pattern
= kzalloc(len
, GFP_KERNEL
);
1431 if (!field
->pattern
) {
1432 wl1271_warning("Failed to allocate RX filter pattern");
1436 filter
->num_fields
++;
1438 field
->offset
= cpu_to_le16(offset
);
1439 field
->flags
= flags
;
1441 memcpy(field
->pattern
, pattern
, len
);
1446 int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter
*filter
)
1448 int i
, fields_size
= 0;
1450 for (i
= 0; i
< filter
->num_fields
; i
++)
1451 fields_size
+= filter
->fields
[i
].len
+
1452 sizeof(struct wl12xx_rx_filter_field
) -
1458 void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter
*filter
,
1462 struct wl12xx_rx_filter_field
*field
;
1464 for (i
= 0; i
< filter
->num_fields
; i
++) {
1465 field
= (struct wl12xx_rx_filter_field
*)buf
;
1467 field
->offset
= filter
->fields
[i
].offset
;
1468 field
->flags
= filter
->fields
[i
].flags
;
1469 field
->len
= filter
->fields
[i
].len
;
1471 memcpy(&field
->pattern
, filter
->fields
[i
].pattern
, field
->len
);
1472 buf
+= sizeof(struct wl12xx_rx_filter_field
) -
1473 sizeof(u8
*) + field
->len
;
1478 * Allocates an RX filter returned through f
1479 * which needs to be freed using rx_filter_free()
1482 wl1271_convert_wowlan_pattern_to_rx_filter(struct cfg80211_pkt_pattern
*p
,
1483 struct wl12xx_rx_filter
**f
)
1486 struct wl12xx_rx_filter
*filter
;
1490 filter
= wl1271_rx_filter_alloc();
1492 wl1271_warning("Failed to alloc rx filter");
1498 while (i
< p
->pattern_len
) {
1499 if (!test_bit(i
, (unsigned long *)p
->mask
)) {
1504 for (j
= i
; j
< p
->pattern_len
; j
++) {
1505 if (!test_bit(j
, (unsigned long *)p
->mask
))
1508 if (i
< WL1271_RX_FILTER_ETH_HEADER_SIZE
&&
1509 j
>= WL1271_RX_FILTER_ETH_HEADER_SIZE
)
1513 if (i
< WL1271_RX_FILTER_ETH_HEADER_SIZE
) {
1515 flags
= WL1271_RX_FILTER_FLAG_ETHERNET_HEADER
;
1517 offset
= i
- WL1271_RX_FILTER_ETH_HEADER_SIZE
;
1518 flags
= WL1271_RX_FILTER_FLAG_IP_HEADER
;
1523 ret
= wl1271_rx_filter_alloc_field(filter
,
1526 &p
->pattern
[i
], len
);
1533 filter
->action
= FILTER_SIGNAL
;
1539 wl1271_rx_filter_free(filter
);
1545 static int wl1271_configure_wowlan(struct wl1271
*wl
,
1546 struct cfg80211_wowlan
*wow
)
1550 if (!wow
|| wow
->any
|| !wow
->n_patterns
) {
1551 ret
= wl1271_acx_default_rx_filter_enable(wl
, 0,
1556 ret
= wl1271_rx_filter_clear_all(wl
);
1563 if (WARN_ON(wow
->n_patterns
> WL1271_MAX_RX_FILTERS
))
1566 /* Validate all incoming patterns before clearing current FW state */
1567 for (i
= 0; i
< wow
->n_patterns
; i
++) {
1568 ret
= wl1271_validate_wowlan_pattern(&wow
->patterns
[i
]);
1570 wl1271_warning("Bad wowlan pattern %d", i
);
1575 ret
= wl1271_acx_default_rx_filter_enable(wl
, 0, FILTER_SIGNAL
);
1579 ret
= wl1271_rx_filter_clear_all(wl
);
1583 /* Translate WoWLAN patterns into filters */
1584 for (i
= 0; i
< wow
->n_patterns
; i
++) {
1585 struct cfg80211_pkt_pattern
*p
;
1586 struct wl12xx_rx_filter
*filter
= NULL
;
1588 p
= &wow
->patterns
[i
];
1590 ret
= wl1271_convert_wowlan_pattern_to_rx_filter(p
, &filter
);
1592 wl1271_warning("Failed to create an RX filter from "
1593 "wowlan pattern %d", i
);
1597 ret
= wl1271_rx_filter_enable(wl
, i
, 1, filter
);
1599 wl1271_rx_filter_free(filter
);
1604 ret
= wl1271_acx_default_rx_filter_enable(wl
, 1, FILTER_DROP
);
1610 static int wl1271_configure_suspend_sta(struct wl1271
*wl
,
1611 struct wl12xx_vif
*wlvif
,
1612 struct cfg80211_wowlan
*wow
)
1616 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
1619 ret
= wl1271_ps_elp_wakeup(wl
);
1623 ret
= wl1271_configure_wowlan(wl
, wow
);
1627 if ((wl
->conf
.conn
.suspend_wake_up_event
==
1628 wl
->conf
.conn
.wake_up_event
) &&
1629 (wl
->conf
.conn
.suspend_listen_interval
==
1630 wl
->conf
.conn
.listen_interval
))
1633 ret
= wl1271_acx_wake_up_conditions(wl
, wlvif
,
1634 wl
->conf
.conn
.suspend_wake_up_event
,
1635 wl
->conf
.conn
.suspend_listen_interval
);
1638 wl1271_error("suspend: set wake up conditions failed: %d", ret
);
1641 wl1271_ps_elp_sleep(wl
);
1647 static int wl1271_configure_suspend_ap(struct wl1271
*wl
,
1648 struct wl12xx_vif
*wlvif
)
1652 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
))
1655 ret
= wl1271_ps_elp_wakeup(wl
);
1659 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, true);
1661 wl1271_ps_elp_sleep(wl
);
1667 static int wl1271_configure_suspend(struct wl1271
*wl
,
1668 struct wl12xx_vif
*wlvif
,
1669 struct cfg80211_wowlan
*wow
)
1671 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
)
1672 return wl1271_configure_suspend_sta(wl
, wlvif
, wow
);
1673 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
1674 return wl1271_configure_suspend_ap(wl
, wlvif
);
1678 static void wl1271_configure_resume(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
1681 bool is_ap
= wlvif
->bss_type
== BSS_TYPE_AP_BSS
;
1682 bool is_sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
1684 if ((!is_ap
) && (!is_sta
))
1687 if (is_sta
&& !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
1690 ret
= wl1271_ps_elp_wakeup(wl
);
1695 wl1271_configure_wowlan(wl
, NULL
);
1697 if ((wl
->conf
.conn
.suspend_wake_up_event
==
1698 wl
->conf
.conn
.wake_up_event
) &&
1699 (wl
->conf
.conn
.suspend_listen_interval
==
1700 wl
->conf
.conn
.listen_interval
))
1703 ret
= wl1271_acx_wake_up_conditions(wl
, wlvif
,
1704 wl
->conf
.conn
.wake_up_event
,
1705 wl
->conf
.conn
.listen_interval
);
1708 wl1271_error("resume: wake up conditions failed: %d",
1712 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, false);
1716 wl1271_ps_elp_sleep(wl
);
1719 static int wl1271_op_suspend(struct ieee80211_hw
*hw
,
1720 struct cfg80211_wowlan
*wow
)
1722 struct wl1271
*wl
= hw
->priv
;
1723 struct wl12xx_vif
*wlvif
;
1726 wl1271_debug(DEBUG_MAC80211
, "mac80211 suspend wow=%d", !!wow
);
1729 /* we want to perform the recovery before suspending */
1730 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
)) {
1731 wl1271_warning("postponing suspend to perform recovery");
1735 wl1271_tx_flush(wl
);
1737 mutex_lock(&wl
->mutex
);
1738 wl
->wow_enabled
= true;
1739 wl12xx_for_each_wlvif(wl
, wlvif
) {
1740 ret
= wl1271_configure_suspend(wl
, wlvif
, wow
);
1742 mutex_unlock(&wl
->mutex
);
1743 wl1271_warning("couldn't prepare device to suspend");
1747 mutex_unlock(&wl
->mutex
);
1748 /* flush any remaining work */
1749 wl1271_debug(DEBUG_MAC80211
, "flushing remaining works");
1752 * disable and re-enable interrupts in order to flush
1755 wlcore_disable_interrupts(wl
);
1758 * set suspended flag to avoid triggering a new threaded_irq
1759 * work. no need for spinlock as interrupts are disabled.
1761 set_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1763 wlcore_enable_interrupts(wl
);
1764 flush_work(&wl
->tx_work
);
1765 flush_delayed_work(&wl
->elp_work
);
1768 * Cancel the watchdog even if above tx_flush failed. We will detect
1769 * it on resume anyway.
1771 cancel_delayed_work(&wl
->tx_watchdog_work
);
1776 static int wl1271_op_resume(struct ieee80211_hw
*hw
)
1778 struct wl1271
*wl
= hw
->priv
;
1779 struct wl12xx_vif
*wlvif
;
1780 unsigned long flags
;
1781 bool run_irq_work
= false, pending_recovery
;
1784 wl1271_debug(DEBUG_MAC80211
, "mac80211 resume wow=%d",
1786 WARN_ON(!wl
->wow_enabled
);
1789 * re-enable irq_work enqueuing, and call irq_work directly if
1790 * there is a pending work.
1792 spin_lock_irqsave(&wl
->wl_lock
, flags
);
1793 clear_bit(WL1271_FLAG_SUSPENDED
, &wl
->flags
);
1794 if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK
, &wl
->flags
))
1795 run_irq_work
= true;
1796 spin_unlock_irqrestore(&wl
->wl_lock
, flags
);
1798 mutex_lock(&wl
->mutex
);
1800 /* test the recovery flag before calling any SDIO functions */
1801 pending_recovery
= test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
,
1805 wl1271_debug(DEBUG_MAC80211
,
1806 "run postponed irq_work directly");
1808 /* don't talk to the HW if recovery is pending */
1809 if (!pending_recovery
) {
1810 ret
= wlcore_irq_locked(wl
);
1812 wl12xx_queue_recovery_work(wl
);
1815 wlcore_enable_interrupts(wl
);
1818 if (pending_recovery
) {
1819 wl1271_warning("queuing forgotten recovery on resume");
1820 ieee80211_queue_work(wl
->hw
, &wl
->recovery_work
);
1824 wl12xx_for_each_wlvif(wl
, wlvif
) {
1825 wl1271_configure_resume(wl
, wlvif
);
1829 wl
->wow_enabled
= false;
1832 * Set a flag to re-init the watchdog on the first Tx after resume.
1833 * That way we avoid possible conditions where Tx-complete interrupts
1834 * fail to arrive and we perform a spurious recovery.
1836 set_bit(WL1271_FLAG_REINIT_TX_WDOG
, &wl
->flags
);
1837 mutex_unlock(&wl
->mutex
);
1843 static int wl1271_op_start(struct ieee80211_hw
*hw
)
1845 wl1271_debug(DEBUG_MAC80211
, "mac80211 start");
1848 * We have to delay the booting of the hardware because
1849 * we need to know the local MAC address before downloading and
1850 * initializing the firmware. The MAC address cannot be changed
1851 * after boot, and without the proper MAC address, the firmware
1852 * will not function properly.
1854 * The MAC address is first known when the corresponding interface
1855 * is added. That is where we will initialize the hardware.
1861 static void wlcore_op_stop_locked(struct wl1271
*wl
)
1865 if (wl
->state
== WLCORE_STATE_OFF
) {
1866 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
,
1868 wlcore_enable_interrupts(wl
);
1874 * this must be before the cancel_work calls below, so that the work
1875 * functions don't perform further work.
1877 wl
->state
= WLCORE_STATE_OFF
;
1880 * Use the nosync variant to disable interrupts, so the mutex could be
1881 * held while doing so without deadlocking.
1883 wlcore_disable_interrupts_nosync(wl
);
1885 mutex_unlock(&wl
->mutex
);
1887 wlcore_synchronize_interrupts(wl
);
1888 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1889 cancel_work_sync(&wl
->recovery_work
);
1890 wl1271_flush_deferred_work(wl
);
1891 cancel_delayed_work_sync(&wl
->scan_complete_work
);
1892 cancel_work_sync(&wl
->netstack_work
);
1893 cancel_work_sync(&wl
->tx_work
);
1894 cancel_delayed_work_sync(&wl
->elp_work
);
1895 cancel_delayed_work_sync(&wl
->tx_watchdog_work
);
1897 /* let's notify MAC80211 about the remaining pending TX frames */
1898 mutex_lock(&wl
->mutex
);
1899 wl12xx_tx_reset(wl
);
1901 wl1271_power_off(wl
);
1903 * In case a recovery was scheduled, interrupts were disabled to avoid
1904 * an interrupt storm. Now that the power is down, it is safe to
1905 * re-enable interrupts to balance the disable depth
1907 if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
1908 wlcore_enable_interrupts(wl
);
1910 wl
->band
= IEEE80211_BAND_2GHZ
;
1913 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
1914 wl
->channel_type
= NL80211_CHAN_NO_HT
;
1915 wl
->tx_blocks_available
= 0;
1916 wl
->tx_allocated_blocks
= 0;
1917 wl
->tx_results_count
= 0;
1918 wl
->tx_packets_count
= 0;
1919 wl
->time_offset
= 0;
1920 wl
->ap_fw_ps_map
= 0;
1922 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
1923 memset(wl
->roles_map
, 0, sizeof(wl
->roles_map
));
1924 memset(wl
->links_map
, 0, sizeof(wl
->links_map
));
1925 memset(wl
->roc_map
, 0, sizeof(wl
->roc_map
));
1926 memset(wl
->session_ids
, 0, sizeof(wl
->session_ids
));
1927 memset(wl
->rx_filter_enabled
, 0, sizeof(wl
->rx_filter_enabled
));
1928 wl
->active_sta_count
= 0;
1929 wl
->active_link_count
= 0;
1931 /* The system link is always allocated */
1932 wl
->links
[WL12XX_SYSTEM_HLID
].allocated_pkts
= 0;
1933 wl
->links
[WL12XX_SYSTEM_HLID
].prev_freed_pkts
= 0;
1934 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
1937 * this is performed after the cancel_work calls and the associated
1938 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1939 * get executed before all these vars have been reset.
1943 wl
->tx_blocks_freed
= 0;
1945 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
1946 wl
->tx_pkts_freed
[i
] = 0;
1947 wl
->tx_allocated_pkts
[i
] = 0;
1950 wl1271_debugfs_reset(wl
);
1952 kfree(wl
->raw_fw_status
);
1953 wl
->raw_fw_status
= NULL
;
1954 kfree(wl
->fw_status
);
1955 wl
->fw_status
= NULL
;
1956 kfree(wl
->tx_res_if
);
1957 wl
->tx_res_if
= NULL
;
1958 kfree(wl
->target_mem_map
);
1959 wl
->target_mem_map
= NULL
;
1962 * FW channels must be re-calibrated after recovery,
1963 * save current Reg-Domain channel configuration and clear it.
1965 memcpy(wl
->reg_ch_conf_pending
, wl
->reg_ch_conf_last
,
1966 sizeof(wl
->reg_ch_conf_pending
));
1967 memset(wl
->reg_ch_conf_last
, 0, sizeof(wl
->reg_ch_conf_last
));
1970 static void wlcore_op_stop(struct ieee80211_hw
*hw
)
1972 struct wl1271
*wl
= hw
->priv
;
1974 wl1271_debug(DEBUG_MAC80211
, "mac80211 stop");
1976 mutex_lock(&wl
->mutex
);
1978 wlcore_op_stop_locked(wl
);
1980 mutex_unlock(&wl
->mutex
);
1983 static void wlcore_channel_switch_work(struct work_struct
*work
)
1985 struct delayed_work
*dwork
;
1987 struct ieee80211_vif
*vif
;
1988 struct wl12xx_vif
*wlvif
;
1991 dwork
= container_of(work
, struct delayed_work
, work
);
1992 wlvif
= container_of(dwork
, struct wl12xx_vif
, channel_switch_work
);
1995 wl1271_info("channel switch failed (role_id: %d).", wlvif
->role_id
);
1997 mutex_lock(&wl
->mutex
);
1999 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2002 /* check the channel switch is still ongoing */
2003 if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
))
2006 vif
= wl12xx_wlvif_to_vif(wlvif
);
2007 ieee80211_chswitch_done(vif
, false);
2009 ret
= wl1271_ps_elp_wakeup(wl
);
2013 wl12xx_cmd_stop_channel_switch(wl
, wlvif
);
2015 wl1271_ps_elp_sleep(wl
);
2017 mutex_unlock(&wl
->mutex
);
2020 static void wlcore_connection_loss_work(struct work_struct
*work
)
2022 struct delayed_work
*dwork
;
2024 struct ieee80211_vif
*vif
;
2025 struct wl12xx_vif
*wlvif
;
2027 dwork
= container_of(work
, struct delayed_work
, work
);
2028 wlvif
= container_of(dwork
, struct wl12xx_vif
, connection_loss_work
);
2031 wl1271_info("Connection loss work (role_id: %d).", wlvif
->role_id
);
2033 mutex_lock(&wl
->mutex
);
2035 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2038 /* Call mac80211 connection loss */
2039 if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2042 vif
= wl12xx_wlvif_to_vif(wlvif
);
2043 ieee80211_connection_loss(vif
);
2045 mutex_unlock(&wl
->mutex
);
2048 static void wlcore_pending_auth_complete_work(struct work_struct
*work
)
2050 struct delayed_work
*dwork
;
2052 struct wl12xx_vif
*wlvif
;
2053 unsigned long time_spare
;
2056 dwork
= container_of(work
, struct delayed_work
, work
);
2057 wlvif
= container_of(dwork
, struct wl12xx_vif
,
2058 pending_auth_complete_work
);
2061 mutex_lock(&wl
->mutex
);
2063 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
2067 * Make sure a second really passed since the last auth reply. Maybe
2068 * a second auth reply arrived while we were stuck on the mutex.
2069 * Check for a little less than the timeout to protect from scheduler
2072 time_spare
= jiffies
+
2073 msecs_to_jiffies(WLCORE_PEND_AUTH_ROC_TIMEOUT
- 50);
2074 if (!time_after(time_spare
, wlvif
->pending_auth_reply_time
))
2077 ret
= wl1271_ps_elp_wakeup(wl
);
2081 /* cancel the ROC if active */
2082 wlcore_update_inconn_sta(wl
, wlvif
, NULL
, false);
2084 wl1271_ps_elp_sleep(wl
);
2086 mutex_unlock(&wl
->mutex
);
2089 static int wl12xx_allocate_rate_policy(struct wl1271
*wl
, u8
*idx
)
2091 u8 policy
= find_first_zero_bit(wl
->rate_policies_map
,
2092 WL12XX_MAX_RATE_POLICIES
);
2093 if (policy
>= WL12XX_MAX_RATE_POLICIES
)
2096 __set_bit(policy
, wl
->rate_policies_map
);
2101 static void wl12xx_free_rate_policy(struct wl1271
*wl
, u8
*idx
)
2103 if (WARN_ON(*idx
>= WL12XX_MAX_RATE_POLICIES
))
2106 __clear_bit(*idx
, wl
->rate_policies_map
);
2107 *idx
= WL12XX_MAX_RATE_POLICIES
;
2110 static int wlcore_allocate_klv_template(struct wl1271
*wl
, u8
*idx
)
2112 u8 policy
= find_first_zero_bit(wl
->klv_templates_map
,
2113 WLCORE_MAX_KLV_TEMPLATES
);
2114 if (policy
>= WLCORE_MAX_KLV_TEMPLATES
)
2117 __set_bit(policy
, wl
->klv_templates_map
);
2122 static void wlcore_free_klv_template(struct wl1271
*wl
, u8
*idx
)
2124 if (WARN_ON(*idx
>= WLCORE_MAX_KLV_TEMPLATES
))
2127 __clear_bit(*idx
, wl
->klv_templates_map
);
2128 *idx
= WLCORE_MAX_KLV_TEMPLATES
;
2131 static u8
wl12xx_get_role_type(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2133 switch (wlvif
->bss_type
) {
2134 case BSS_TYPE_AP_BSS
:
2136 return WL1271_ROLE_P2P_GO
;
2138 return WL1271_ROLE_AP
;
2140 case BSS_TYPE_STA_BSS
:
2142 return WL1271_ROLE_P2P_CL
;
2144 return WL1271_ROLE_STA
;
2147 return WL1271_ROLE_IBSS
;
2150 wl1271_error("invalid bss_type: %d", wlvif
->bss_type
);
2152 return WL12XX_INVALID_ROLE_TYPE
;
2155 static int wl12xx_init_vif_data(struct wl1271
*wl
, struct ieee80211_vif
*vif
)
2157 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2160 /* clear everything but the persistent data */
2161 memset(wlvif
, 0, offsetof(struct wl12xx_vif
, persistent
));
2163 switch (ieee80211_vif_type_p2p(vif
)) {
2164 case NL80211_IFTYPE_P2P_CLIENT
:
2167 case NL80211_IFTYPE_STATION
:
2168 wlvif
->bss_type
= BSS_TYPE_STA_BSS
;
2170 case NL80211_IFTYPE_ADHOC
:
2171 wlvif
->bss_type
= BSS_TYPE_IBSS
;
2173 case NL80211_IFTYPE_P2P_GO
:
2176 case NL80211_IFTYPE_AP
:
2177 wlvif
->bss_type
= BSS_TYPE_AP_BSS
;
2180 wlvif
->bss_type
= MAX_BSS_TYPE
;
2184 wlvif
->role_id
= WL12XX_INVALID_ROLE_ID
;
2185 wlvif
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
2186 wlvif
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
2188 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2189 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2190 /* init sta/ibss data */
2191 wlvif
->sta
.hlid
= WL12XX_INVALID_LINK_ID
;
2192 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.basic_rate_idx
);
2193 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.ap_rate_idx
);
2194 wl12xx_allocate_rate_policy(wl
, &wlvif
->sta
.p2p_rate_idx
);
2195 wlcore_allocate_klv_template(wl
, &wlvif
->sta
.klv_template_id
);
2196 wlvif
->basic_rate_set
= CONF_TX_RATE_MASK_BASIC
;
2197 wlvif
->basic_rate
= CONF_TX_RATE_MASK_BASIC
;
2198 wlvif
->rate_set
= CONF_TX_RATE_MASK_BASIC
;
2201 wlvif
->ap
.bcast_hlid
= WL12XX_INVALID_LINK_ID
;
2202 wlvif
->ap
.global_hlid
= WL12XX_INVALID_LINK_ID
;
2203 wl12xx_allocate_rate_policy(wl
, &wlvif
->ap
.mgmt_rate_idx
);
2204 wl12xx_allocate_rate_policy(wl
, &wlvif
->ap
.bcast_rate_idx
);
2205 for (i
= 0; i
< CONF_TX_MAX_AC_COUNT
; i
++)
2206 wl12xx_allocate_rate_policy(wl
,
2207 &wlvif
->ap
.ucast_rate_idx
[i
]);
2208 wlvif
->basic_rate_set
= CONF_TX_ENABLED_RATES
;
2210 * TODO: check if basic_rate shouldn't be
2211 * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2212 * instead (the same thing for STA above).
2214 wlvif
->basic_rate
= CONF_TX_ENABLED_RATES
;
2215 /* TODO: this seems to be used only for STA, check it */
2216 wlvif
->rate_set
= CONF_TX_ENABLED_RATES
;
2219 wlvif
->bitrate_masks
[IEEE80211_BAND_2GHZ
] = wl
->conf
.tx
.basic_rate
;
2220 wlvif
->bitrate_masks
[IEEE80211_BAND_5GHZ
] = wl
->conf
.tx
.basic_rate_5
;
2221 wlvif
->beacon_int
= WL1271_DEFAULT_BEACON_INT
;
2224 * mac80211 configures some values globally, while we treat them
2225 * per-interface. thus, on init, we have to copy them from wl
2227 wlvif
->band
= wl
->band
;
2228 wlvif
->channel
= wl
->channel
;
2229 wlvif
->power_level
= wl
->power_level
;
2230 wlvif
->channel_type
= wl
->channel_type
;
2232 INIT_WORK(&wlvif
->rx_streaming_enable_work
,
2233 wl1271_rx_streaming_enable_work
);
2234 INIT_WORK(&wlvif
->rx_streaming_disable_work
,
2235 wl1271_rx_streaming_disable_work
);
2236 INIT_DELAYED_WORK(&wlvif
->channel_switch_work
,
2237 wlcore_channel_switch_work
);
2238 INIT_DELAYED_WORK(&wlvif
->connection_loss_work
,
2239 wlcore_connection_loss_work
);
2240 INIT_DELAYED_WORK(&wlvif
->pending_auth_complete_work
,
2241 wlcore_pending_auth_complete_work
);
2242 INIT_LIST_HEAD(&wlvif
->list
);
2244 setup_timer(&wlvif
->rx_streaming_timer
, wl1271_rx_streaming_timer
,
2245 (unsigned long) wlvif
);
2249 static int wl12xx_init_fw(struct wl1271
*wl
)
2251 int retries
= WL1271_BOOT_RETRIES
;
2252 bool booted
= false;
2253 struct wiphy
*wiphy
= wl
->hw
->wiphy
;
2258 ret
= wl12xx_chip_wakeup(wl
, false);
2262 ret
= wl
->ops
->boot(wl
);
2266 ret
= wl1271_hw_init(wl
);
2274 mutex_unlock(&wl
->mutex
);
2275 /* Unlocking the mutex in the middle of handling is
2276 inherently unsafe. In this case we deem it safe to do,
2277 because we need to let any possibly pending IRQ out of
2278 the system (and while we are WLCORE_STATE_OFF the IRQ
2279 work function will not do anything.) Also, any other
2280 possible concurrent operations will fail due to the
2281 current state, hence the wl1271 struct should be safe. */
2282 wlcore_disable_interrupts(wl
);
2283 wl1271_flush_deferred_work(wl
);
2284 cancel_work_sync(&wl
->netstack_work
);
2285 mutex_lock(&wl
->mutex
);
2287 wl1271_power_off(wl
);
2291 wl1271_error("firmware boot failed despite %d retries",
2292 WL1271_BOOT_RETRIES
);
2296 wl1271_info("firmware booted (%s)", wl
->chip
.fw_ver_str
);
2298 /* update hw/fw version info in wiphy struct */
2299 wiphy
->hw_version
= wl
->chip
.id
;
2300 strncpy(wiphy
->fw_version
, wl
->chip
.fw_ver_str
,
2301 sizeof(wiphy
->fw_version
));
2304 * Now we know if 11a is supported (info from the NVS), so disable
2305 * 11a channels if not supported
2307 if (!wl
->enable_11a
)
2308 wiphy
->bands
[IEEE80211_BAND_5GHZ
]->n_channels
= 0;
2310 wl1271_debug(DEBUG_MAC80211
, "11a is %ssupported",
2311 wl
->enable_11a
? "" : "not ");
2313 wl
->state
= WLCORE_STATE_ON
;
2318 static bool wl12xx_dev_role_started(struct wl12xx_vif
*wlvif
)
2320 return wlvif
->dev_hlid
!= WL12XX_INVALID_LINK_ID
;
2324 * Check whether a fw switch (i.e. moving from one loaded
2325 * fw to another) is needed. This function is also responsible
2326 * for updating wl->last_vif_count, so it must be called before
2327 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2330 static bool wl12xx_need_fw_change(struct wl1271
*wl
,
2331 struct vif_counter_data vif_counter_data
,
2334 enum wl12xx_fw_type current_fw
= wl
->fw_type
;
2335 u8 vif_count
= vif_counter_data
.counter
;
2337 if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
))
2340 /* increase the vif count if this is a new vif */
2341 if (add
&& !vif_counter_data
.cur_vif_running
)
2344 wl
->last_vif_count
= vif_count
;
2346 /* no need for fw change if the device is OFF */
2347 if (wl
->state
== WLCORE_STATE_OFF
)
2350 /* no need for fw change if a single fw is used */
2351 if (!wl
->mr_fw_name
)
2354 if (vif_count
> 1 && current_fw
== WL12XX_FW_TYPE_NORMAL
)
2356 if (vif_count
<= 1 && current_fw
== WL12XX_FW_TYPE_MULTI
)
2363 * Enter "forced psm". Make sure the sta is in psm against the ap,
2364 * to make the fw switch a bit more disconnection-persistent.
2366 static void wl12xx_force_active_psm(struct wl1271
*wl
)
2368 struct wl12xx_vif
*wlvif
;
2370 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
2371 wl1271_ps_set_mode(wl
, wlvif
, STATION_POWER_SAVE_MODE
);
2375 struct wlcore_hw_queue_iter_data
{
2376 unsigned long hw_queue_map
[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES
)];
2378 struct ieee80211_vif
*vif
;
2379 /* is the current vif among those iterated */
2383 static void wlcore_hw_queue_iter(void *data
, u8
*mac
,
2384 struct ieee80211_vif
*vif
)
2386 struct wlcore_hw_queue_iter_data
*iter_data
= data
;
2388 if (WARN_ON_ONCE(vif
->hw_queue
[0] == IEEE80211_INVAL_HW_QUEUE
))
2391 if (iter_data
->cur_running
|| vif
== iter_data
->vif
) {
2392 iter_data
->cur_running
= true;
2396 __set_bit(vif
->hw_queue
[0] / NUM_TX_QUEUES
, iter_data
->hw_queue_map
);
2399 static int wlcore_allocate_hw_queue_base(struct wl1271
*wl
,
2400 struct wl12xx_vif
*wlvif
)
2402 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2403 struct wlcore_hw_queue_iter_data iter_data
= {};
2406 iter_data
.vif
= vif
;
2408 /* mark all bits taken by active interfaces */
2409 ieee80211_iterate_active_interfaces_atomic(wl
->hw
,
2410 IEEE80211_IFACE_ITER_RESUME_ALL
,
2411 wlcore_hw_queue_iter
, &iter_data
);
2413 /* the current vif is already running in mac80211 (resume/recovery) */
2414 if (iter_data
.cur_running
) {
2415 wlvif
->hw_queue_base
= vif
->hw_queue
[0];
2416 wl1271_debug(DEBUG_MAC80211
,
2417 "using pre-allocated hw queue base %d",
2418 wlvif
->hw_queue_base
);
2420 /* interface type might have changed type */
2421 goto adjust_cab_queue
;
2424 q_base
= find_first_zero_bit(iter_data
.hw_queue_map
,
2425 WLCORE_NUM_MAC_ADDRESSES
);
2426 if (q_base
>= WLCORE_NUM_MAC_ADDRESSES
)
2429 wlvif
->hw_queue_base
= q_base
* NUM_TX_QUEUES
;
2430 wl1271_debug(DEBUG_MAC80211
, "allocating hw queue base: %d",
2431 wlvif
->hw_queue_base
);
2433 for (i
= 0; i
< NUM_TX_QUEUES
; i
++) {
2434 wl
->queue_stop_reasons
[wlvif
->hw_queue_base
+ i
] = 0;
2435 /* register hw queues in mac80211 */
2436 vif
->hw_queue
[i
] = wlvif
->hw_queue_base
+ i
;
2440 /* the last places are reserved for cab queues per interface */
2441 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
2442 vif
->cab_queue
= NUM_TX_QUEUES
* WLCORE_NUM_MAC_ADDRESSES
+
2443 wlvif
->hw_queue_base
/ NUM_TX_QUEUES
;
2445 vif
->cab_queue
= IEEE80211_INVAL_HW_QUEUE
;
2450 static int wl1271_op_add_interface(struct ieee80211_hw
*hw
,
2451 struct ieee80211_vif
*vif
)
2453 struct wl1271
*wl
= hw
->priv
;
2454 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2455 struct vif_counter_data vif_count
;
2460 wl1271_error("Adding Interface not allowed while in PLT mode");
2464 vif
->driver_flags
|= IEEE80211_VIF_BEACON_FILTER
|
2465 IEEE80211_VIF_SUPPORTS_CQM_RSSI
;
2467 wl1271_debug(DEBUG_MAC80211
, "mac80211 add interface type %d mac %pM",
2468 ieee80211_vif_type_p2p(vif
), vif
->addr
);
2470 wl12xx_get_vif_count(hw
, vif
, &vif_count
);
2472 mutex_lock(&wl
->mutex
);
2473 ret
= wl1271_ps_elp_wakeup(wl
);
2478 * in some very corner case HW recovery scenarios its possible to
2479 * get here before __wl1271_op_remove_interface is complete, so
2480 * opt out if that is the case.
2482 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
) ||
2483 test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)) {
2489 ret
= wl12xx_init_vif_data(wl
, vif
);
2494 role_type
= wl12xx_get_role_type(wl
, wlvif
);
2495 if (role_type
== WL12XX_INVALID_ROLE_TYPE
) {
2500 ret
= wlcore_allocate_hw_queue_base(wl
, wlvif
);
2504 if (wl12xx_need_fw_change(wl
, vif_count
, true)) {
2505 wl12xx_force_active_psm(wl
);
2506 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
);
2507 mutex_unlock(&wl
->mutex
);
2508 wl1271_recovery_work(&wl
->recovery_work
);
2513 * TODO: after the nvs issue will be solved, move this block
2514 * to start(), and make sure here the driver is ON.
2516 if (wl
->state
== WLCORE_STATE_OFF
) {
2518 * we still need this in order to configure the fw
2519 * while uploading the nvs
2521 memcpy(wl
->addresses
[0].addr
, vif
->addr
, ETH_ALEN
);
2523 ret
= wl12xx_init_fw(wl
);
2528 ret
= wl12xx_cmd_role_enable(wl
, vif
->addr
,
2529 role_type
, &wlvif
->role_id
);
2533 ret
= wl1271_init_vif_specific(wl
, vif
);
2537 list_add(&wlvif
->list
, &wl
->wlvif_list
);
2538 set_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
);
2540 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
2545 wl1271_ps_elp_sleep(wl
);
2547 mutex_unlock(&wl
->mutex
);
2552 static void __wl1271_op_remove_interface(struct wl1271
*wl
,
2553 struct ieee80211_vif
*vif
,
2554 bool reset_tx_queues
)
2556 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2558 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
2560 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove interface");
2562 if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
2565 /* because of hardware recovery, we may get here twice */
2566 if (wl
->state
== WLCORE_STATE_OFF
)
2569 wl1271_info("down");
2571 if (wl
->scan
.state
!= WL1271_SCAN_STATE_IDLE
&&
2572 wl
->scan_wlvif
== wlvif
) {
2574 * Rearm the tx watchdog just before idling scan. This
2575 * prevents just-finished scans from triggering the watchdog
2577 wl12xx_rearm_tx_watchdog_locked(wl
);
2579 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
2580 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
2581 wl
->scan_wlvif
= NULL
;
2582 wl
->scan
.req
= NULL
;
2583 ieee80211_scan_completed(wl
->hw
, true);
2586 if (wl
->sched_vif
== wlvif
)
2587 wl
->sched_vif
= NULL
;
2589 if (wl
->roc_vif
== vif
) {
2591 ieee80211_remain_on_channel_expired(wl
->hw
);
2594 if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
)) {
2595 /* disable active roles */
2596 ret
= wl1271_ps_elp_wakeup(wl
);
2600 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2601 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2602 if (wl12xx_dev_role_started(wlvif
))
2603 wl12xx_stop_dev(wl
, wlvif
);
2606 ret
= wl12xx_cmd_role_disable(wl
, &wlvif
->role_id
);
2610 wl1271_ps_elp_sleep(wl
);
2613 wl12xx_tx_reset_wlvif(wl
, wlvif
);
2615 /* clear all hlids (except system_hlid) */
2616 wlvif
->dev_hlid
= WL12XX_INVALID_LINK_ID
;
2618 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
||
2619 wlvif
->bss_type
== BSS_TYPE_IBSS
) {
2620 wlvif
->sta
.hlid
= WL12XX_INVALID_LINK_ID
;
2621 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.basic_rate_idx
);
2622 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.ap_rate_idx
);
2623 wl12xx_free_rate_policy(wl
, &wlvif
->sta
.p2p_rate_idx
);
2624 wlcore_free_klv_template(wl
, &wlvif
->sta
.klv_template_id
);
2626 wlvif
->ap
.bcast_hlid
= WL12XX_INVALID_LINK_ID
;
2627 wlvif
->ap
.global_hlid
= WL12XX_INVALID_LINK_ID
;
2628 wl12xx_free_rate_policy(wl
, &wlvif
->ap
.mgmt_rate_idx
);
2629 wl12xx_free_rate_policy(wl
, &wlvif
->ap
.bcast_rate_idx
);
2630 for (i
= 0; i
< CONF_TX_MAX_AC_COUNT
; i
++)
2631 wl12xx_free_rate_policy(wl
,
2632 &wlvif
->ap
.ucast_rate_idx
[i
]);
2633 wl1271_free_ap_keys(wl
, wlvif
);
2636 dev_kfree_skb(wlvif
->probereq
);
2637 wlvif
->probereq
= NULL
;
2638 if (wl
->last_wlvif
== wlvif
)
2639 wl
->last_wlvif
= NULL
;
2640 list_del(&wlvif
->list
);
2641 memset(wlvif
->ap
.sta_hlid_map
, 0, sizeof(wlvif
->ap
.sta_hlid_map
));
2642 wlvif
->role_id
= WL12XX_INVALID_ROLE_ID
;
2643 wlvif
->dev_role_id
= WL12XX_INVALID_ROLE_ID
;
2651 * Last AP, have more stations. Configure sleep auth according to STA.
2652 * Don't do thin on unintended recovery.
2654 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
) &&
2655 !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
))
2658 if (wl
->ap_count
== 0 && is_ap
) {
2659 /* mask ap events */
2660 wl
->event_mask
&= ~wl
->ap_event_mask
;
2661 wl1271_event_unmask(wl
);
2664 if (wl
->ap_count
== 0 && is_ap
&& wl
->sta_count
) {
2665 u8 sta_auth
= wl
->conf
.conn
.sta_sleep_auth
;
2666 /* Configure for power according to debugfs */
2667 if (sta_auth
!= WL1271_PSM_ILLEGAL
)
2668 wl1271_acx_sleep_auth(wl
, sta_auth
);
2669 /* Configure for ELP power saving */
2671 wl1271_acx_sleep_auth(wl
, WL1271_PSM_ELP
);
2675 mutex_unlock(&wl
->mutex
);
2677 del_timer_sync(&wlvif
->rx_streaming_timer
);
2678 cancel_work_sync(&wlvif
->rx_streaming_enable_work
);
2679 cancel_work_sync(&wlvif
->rx_streaming_disable_work
);
2680 cancel_delayed_work_sync(&wlvif
->connection_loss_work
);
2681 cancel_delayed_work_sync(&wlvif
->channel_switch_work
);
2682 cancel_delayed_work_sync(&wlvif
->pending_auth_complete_work
);
2684 mutex_lock(&wl
->mutex
);
2687 static void wl1271_op_remove_interface(struct ieee80211_hw
*hw
,
2688 struct ieee80211_vif
*vif
)
2690 struct wl1271
*wl
= hw
->priv
;
2691 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
2692 struct wl12xx_vif
*iter
;
2693 struct vif_counter_data vif_count
;
2695 wl12xx_get_vif_count(hw
, vif
, &vif_count
);
2696 mutex_lock(&wl
->mutex
);
2698 if (wl
->state
== WLCORE_STATE_OFF
||
2699 !test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
2703 * wl->vif can be null here if someone shuts down the interface
2704 * just when hardware recovery has been started.
2706 wl12xx_for_each_wlvif(wl
, iter
) {
2710 __wl1271_op_remove_interface(wl
, vif
, true);
2713 WARN_ON(iter
!= wlvif
);
2714 if (wl12xx_need_fw_change(wl
, vif_count
, false)) {
2715 wl12xx_force_active_psm(wl
);
2716 set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY
, &wl
->flags
);
2717 wl12xx_queue_recovery_work(wl
);
2720 mutex_unlock(&wl
->mutex
);
2723 static int wl12xx_op_change_interface(struct ieee80211_hw
*hw
,
2724 struct ieee80211_vif
*vif
,
2725 enum nl80211_iftype new_type
, bool p2p
)
2727 struct wl1271
*wl
= hw
->priv
;
2730 set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
);
2731 wl1271_op_remove_interface(hw
, vif
);
2733 vif
->type
= new_type
;
2735 ret
= wl1271_op_add_interface(hw
, vif
);
2737 clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS
, &wl
->flags
);
2741 static int wlcore_join(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2744 bool is_ibss
= (wlvif
->bss_type
== BSS_TYPE_IBSS
);
2747 * One of the side effects of the JOIN command is that is clears
2748 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2749 * to a WPA/WPA2 access point will therefore kill the data-path.
2750 * Currently the only valid scenario for JOIN during association
2751 * is on roaming, in which case we will also be given new keys.
2752 * Keep the below message for now, unless it starts bothering
2753 * users who really like to roam a lot :)
2755 if (test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2756 wl1271_info("JOIN while associated.");
2758 /* clear encryption type */
2759 wlvif
->encryption_type
= KEY_NONE
;
2762 ret
= wl12xx_cmd_role_start_ibss(wl
, wlvif
);
2764 if (wl
->quirks
& WLCORE_QUIRK_START_STA_FAILS
) {
2766 * TODO: this is an ugly workaround for wl12xx fw
2767 * bug - we are not able to tx/rx after the first
2768 * start_sta, so make dummy start+stop calls,
2769 * and then call start_sta again.
2770 * this should be fixed in the fw.
2772 wl12xx_cmd_role_start_sta(wl
, wlvif
);
2773 wl12xx_cmd_role_stop_sta(wl
, wlvif
);
2776 ret
= wl12xx_cmd_role_start_sta(wl
, wlvif
);
2782 static int wl1271_ssid_set(struct wl12xx_vif
*wlvif
, struct sk_buff
*skb
,
2786 const u8
*ptr
= cfg80211_find_ie(WLAN_EID_SSID
, skb
->data
+ offset
,
2790 wl1271_error("No SSID in IEs!");
2795 if (ssid_len
> IEEE80211_MAX_SSID_LEN
) {
2796 wl1271_error("SSID is too long!");
2800 wlvif
->ssid_len
= ssid_len
;
2801 memcpy(wlvif
->ssid
, ptr
+2, ssid_len
);
2805 static int wlcore_set_ssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2807 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2808 struct sk_buff
*skb
;
2811 /* we currently only support setting the ssid from the ap probe req */
2812 if (wlvif
->bss_type
!= BSS_TYPE_STA_BSS
)
2815 skb
= ieee80211_ap_probereq_get(wl
->hw
, vif
);
2819 ieoffset
= offsetof(struct ieee80211_mgmt
,
2820 u
.probe_req
.variable
);
2821 wl1271_ssid_set(wlvif
, skb
, ieoffset
);
2827 static int wlcore_set_assoc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
2828 struct ieee80211_bss_conf
*bss_conf
,
2834 wlvif
->aid
= bss_conf
->aid
;
2835 wlvif
->channel_type
= cfg80211_get_chandef_type(&bss_conf
->chandef
);
2836 wlvif
->beacon_int
= bss_conf
->beacon_int
;
2837 wlvif
->wmm_enabled
= bss_conf
->qos
;
2839 set_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
);
2842 * with wl1271, we don't need to update the
2843 * beacon_int and dtim_period, because the firmware
2844 * updates it by itself when the first beacon is
2845 * received after a join.
2847 ret
= wl1271_cmd_build_ps_poll(wl
, wlvif
, wlvif
->aid
);
2852 * Get a template for hardware connection maintenance
2854 dev_kfree_skb(wlvif
->probereq
);
2855 wlvif
->probereq
= wl1271_cmd_build_ap_probe_req(wl
,
2858 ieoffset
= offsetof(struct ieee80211_mgmt
,
2859 u
.probe_req
.variable
);
2860 wl1271_ssid_set(wlvif
, wlvif
->probereq
, ieoffset
);
2862 /* enable the connection monitoring feature */
2863 ret
= wl1271_acx_conn_monit_params(wl
, wlvif
, true);
2868 * The join command disable the keep-alive mode, shut down its process,
2869 * and also clear the template config, so we need to reset it all after
2870 * the join. The acx_aid starts the keep-alive process, and the order
2871 * of the commands below is relevant.
2873 ret
= wl1271_acx_keep_alive_mode(wl
, wlvif
, true);
2877 ret
= wl1271_acx_aid(wl
, wlvif
, wlvif
->aid
);
2881 ret
= wl12xx_cmd_build_klv_null_data(wl
, wlvif
);
2885 ret
= wl1271_acx_keep_alive_config(wl
, wlvif
,
2886 wlvif
->sta
.klv_template_id
,
2887 ACX_KEEP_ALIVE_TPL_VALID
);
2892 * The default fw psm configuration is AUTO, while mac80211 default
2893 * setting is off (ACTIVE), so sync the fw with the correct value.
2895 ret
= wl1271_ps_set_mode(wl
, wlvif
, STATION_ACTIVE_MODE
);
2901 wl1271_tx_enabled_rates_get(wl
,
2904 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
2912 static int wlcore_unset_assoc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2915 bool sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
2917 /* make sure we are connected (sta) joined */
2919 !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
))
2922 /* make sure we are joined (ibss) */
2924 test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED
, &wlvif
->flags
))
2928 /* use defaults when not associated */
2931 /* free probe-request template */
2932 dev_kfree_skb(wlvif
->probereq
);
2933 wlvif
->probereq
= NULL
;
2935 /* disable connection monitor features */
2936 ret
= wl1271_acx_conn_monit_params(wl
, wlvif
, false);
2940 /* Disable the keep-alive feature */
2941 ret
= wl1271_acx_keep_alive_mode(wl
, wlvif
, false);
2945 /* disable beacon filtering */
2946 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, false);
2951 if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
)) {
2952 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
2954 wl12xx_cmd_stop_channel_switch(wl
, wlvif
);
2955 ieee80211_chswitch_done(vif
, false);
2956 cancel_delayed_work(&wlvif
->channel_switch_work
);
2959 /* invalidate keep-alive template */
2960 wl1271_acx_keep_alive_config(wl
, wlvif
,
2961 wlvif
->sta
.klv_template_id
,
2962 ACX_KEEP_ALIVE_TPL_INVALID
);
2967 static void wl1271_set_band_rate(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
2969 wlvif
->basic_rate_set
= wlvif
->bitrate_masks
[wlvif
->band
];
2970 wlvif
->rate_set
= wlvif
->basic_rate_set
;
2973 static void wl1271_sta_handle_idle(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
2976 bool cur_idle
= !test_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
2978 if (idle
== cur_idle
)
2982 clear_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
2984 /* The current firmware only supports sched_scan in idle */
2985 if (wl
->sched_vif
== wlvif
)
2986 wl
->ops
->sched_scan_stop(wl
, wlvif
);
2988 set_bit(WLVIF_FLAG_ACTIVE
, &wlvif
->flags
);
2992 static int wl12xx_config_vif(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
2993 struct ieee80211_conf
*conf
, u32 changed
)
2997 if (conf
->power_level
!= wlvif
->power_level
) {
2998 ret
= wl1271_acx_tx_power(wl
, wlvif
, conf
->power_level
);
3002 wlvif
->power_level
= conf
->power_level
;
3008 static int wl1271_op_config(struct ieee80211_hw
*hw
, u32 changed
)
3010 struct wl1271
*wl
= hw
->priv
;
3011 struct wl12xx_vif
*wlvif
;
3012 struct ieee80211_conf
*conf
= &hw
->conf
;
3015 wl1271_debug(DEBUG_MAC80211
, "mac80211 config psm %s power %d %s"
3017 conf
->flags
& IEEE80211_CONF_PS
? "on" : "off",
3019 conf
->flags
& IEEE80211_CONF_IDLE
? "idle" : "in use",
3022 mutex_lock(&wl
->mutex
);
3024 if (changed
& IEEE80211_CONF_CHANGE_POWER
)
3025 wl
->power_level
= conf
->power_level
;
3027 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3030 ret
= wl1271_ps_elp_wakeup(wl
);
3034 /* configure each interface */
3035 wl12xx_for_each_wlvif(wl
, wlvif
) {
3036 ret
= wl12xx_config_vif(wl
, wlvif
, conf
, changed
);
3042 wl1271_ps_elp_sleep(wl
);
3045 mutex_unlock(&wl
->mutex
);
3050 struct wl1271_filter_params
{
3053 u8 mc_list
[ACX_MC_ADDRESS_GROUP_MAX
][ETH_ALEN
];
3056 static u64
wl1271_op_prepare_multicast(struct ieee80211_hw
*hw
,
3057 struct netdev_hw_addr_list
*mc_list
)
3059 struct wl1271_filter_params
*fp
;
3060 struct netdev_hw_addr
*ha
;
3062 fp
= kzalloc(sizeof(*fp
), GFP_ATOMIC
);
3064 wl1271_error("Out of memory setting filters.");
3068 /* update multicast filtering parameters */
3069 fp
->mc_list_length
= 0;
3070 if (netdev_hw_addr_list_count(mc_list
) > ACX_MC_ADDRESS_GROUP_MAX
) {
3071 fp
->enabled
= false;
3074 netdev_hw_addr_list_for_each(ha
, mc_list
) {
3075 memcpy(fp
->mc_list
[fp
->mc_list_length
],
3076 ha
->addr
, ETH_ALEN
);
3077 fp
->mc_list_length
++;
3081 return (u64
)(unsigned long)fp
;
3084 #define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
3087 FIF_BCN_PRBRESP_PROMISC | \
3091 static void wl1271_op_configure_filter(struct ieee80211_hw
*hw
,
3092 unsigned int changed
,
3093 unsigned int *total
, u64 multicast
)
3095 struct wl1271_filter_params
*fp
= (void *)(unsigned long)multicast
;
3096 struct wl1271
*wl
= hw
->priv
;
3097 struct wl12xx_vif
*wlvif
;
3101 wl1271_debug(DEBUG_MAC80211
, "mac80211 configure filter changed %x"
3102 " total %x", changed
, *total
);
3104 mutex_lock(&wl
->mutex
);
3106 *total
&= WL1271_SUPPORTED_FILTERS
;
3107 changed
&= WL1271_SUPPORTED_FILTERS
;
3109 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3112 ret
= wl1271_ps_elp_wakeup(wl
);
3116 wl12xx_for_each_wlvif(wl
, wlvif
) {
3117 if (wlvif
->bss_type
!= BSS_TYPE_AP_BSS
) {
3118 if (*total
& FIF_ALLMULTI
)
3119 ret
= wl1271_acx_group_address_tbl(wl
, wlvif
,
3123 ret
= wl1271_acx_group_address_tbl(wl
, wlvif
,
3126 fp
->mc_list_length
);
3133 * the fw doesn't provide an api to configure the filters. instead,
3134 * the filters configuration is based on the active roles / ROC
3139 wl1271_ps_elp_sleep(wl
);
3142 mutex_unlock(&wl
->mutex
);
3146 static int wl1271_record_ap_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3147 u8 id
, u8 key_type
, u8 key_size
,
3148 const u8
*key
, u8 hlid
, u32 tx_seq_32
,
3151 struct wl1271_ap_key
*ap_key
;
3154 wl1271_debug(DEBUG_CRYPT
, "record ap key id %d", (int)id
);
3156 if (key_size
> MAX_KEY_SIZE
)
3160 * Find next free entry in ap_keys. Also check we are not replacing
3163 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3164 if (wlvif
->ap
.recorded_keys
[i
] == NULL
)
3167 if (wlvif
->ap
.recorded_keys
[i
]->id
== id
) {
3168 wl1271_warning("trying to record key replacement");
3173 if (i
== MAX_NUM_KEYS
)
3176 ap_key
= kzalloc(sizeof(*ap_key
), GFP_KERNEL
);
3181 ap_key
->key_type
= key_type
;
3182 ap_key
->key_size
= key_size
;
3183 memcpy(ap_key
->key
, key
, key_size
);
3184 ap_key
->hlid
= hlid
;
3185 ap_key
->tx_seq_32
= tx_seq_32
;
3186 ap_key
->tx_seq_16
= tx_seq_16
;
3188 wlvif
->ap
.recorded_keys
[i
] = ap_key
;
3192 static void wl1271_free_ap_keys(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
3196 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3197 kfree(wlvif
->ap
.recorded_keys
[i
]);
3198 wlvif
->ap
.recorded_keys
[i
] = NULL
;
3202 static int wl1271_ap_init_hwenc(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
3205 struct wl1271_ap_key
*key
;
3206 bool wep_key_added
= false;
3208 for (i
= 0; i
< MAX_NUM_KEYS
; i
++) {
3210 if (wlvif
->ap
.recorded_keys
[i
] == NULL
)
3213 key
= wlvif
->ap
.recorded_keys
[i
];
3215 if (hlid
== WL12XX_INVALID_LINK_ID
)
3216 hlid
= wlvif
->ap
.bcast_hlid
;
3218 ret
= wl1271_cmd_set_ap_key(wl
, wlvif
, KEY_ADD_OR_REPLACE
,
3219 key
->id
, key
->key_type
,
3220 key
->key_size
, key
->key
,
3221 hlid
, key
->tx_seq_32
,
3226 if (key
->key_type
== KEY_WEP
)
3227 wep_key_added
= true;
3230 if (wep_key_added
) {
3231 ret
= wl12xx_cmd_set_default_wep_key(wl
, wlvif
->default_key
,
3232 wlvif
->ap
.bcast_hlid
);
3238 wl1271_free_ap_keys(wl
, wlvif
);
3242 static int wl1271_set_key(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
3243 u16 action
, u8 id
, u8 key_type
,
3244 u8 key_size
, const u8
*key
, u32 tx_seq_32
,
3245 u16 tx_seq_16
, struct ieee80211_sta
*sta
)
3248 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
3251 struct wl1271_station
*wl_sta
;
3255 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
3256 hlid
= wl_sta
->hlid
;
3258 hlid
= wlvif
->ap
.bcast_hlid
;
3261 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
3263 * We do not support removing keys after AP shutdown.
3264 * Pretend we do to make mac80211 happy.
3266 if (action
!= KEY_ADD_OR_REPLACE
)
3269 ret
= wl1271_record_ap_key(wl
, wlvif
, id
,
3271 key
, hlid
, tx_seq_32
,
3274 ret
= wl1271_cmd_set_ap_key(wl
, wlvif
, action
,
3275 id
, key_type
, key_size
,
3276 key
, hlid
, tx_seq_32
,
3284 static const u8 bcast_addr
[ETH_ALEN
] = {
3285 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
3288 addr
= sta
? sta
->addr
: bcast_addr
;
3290 if (is_zero_ether_addr(addr
)) {
3291 /* We dont support TX only encryption */
3295 /* The wl1271 does not allow to remove unicast keys - they
3296 will be cleared automatically on next CMD_JOIN. Ignore the
3297 request silently, as we dont want the mac80211 to emit
3298 an error message. */
3299 if (action
== KEY_REMOVE
&& !is_broadcast_ether_addr(addr
))
3302 /* don't remove key if hlid was already deleted */
3303 if (action
== KEY_REMOVE
&&
3304 wlvif
->sta
.hlid
== WL12XX_INVALID_LINK_ID
)
3307 ret
= wl1271_cmd_set_sta_key(wl
, wlvif
, action
,
3308 id
, key_type
, key_size
,
3309 key
, addr
, tx_seq_32
,
3319 static int wlcore_op_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
3320 struct ieee80211_vif
*vif
,
3321 struct ieee80211_sta
*sta
,
3322 struct ieee80211_key_conf
*key_conf
)
3324 struct wl1271
*wl
= hw
->priv
;
3326 bool might_change_spare
=
3327 key_conf
->cipher
== WL1271_CIPHER_SUITE_GEM
||
3328 key_conf
->cipher
== WLAN_CIPHER_SUITE_TKIP
;
3330 if (might_change_spare
) {
3332 * stop the queues and flush to ensure the next packets are
3333 * in sync with FW spare block accounting
3335 wlcore_stop_queues(wl
, WLCORE_QUEUE_STOP_REASON_SPARE_BLK
);
3336 wl1271_tx_flush(wl
);
3339 mutex_lock(&wl
->mutex
);
3341 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3343 goto out_wake_queues
;
3346 ret
= wl1271_ps_elp_wakeup(wl
);
3348 goto out_wake_queues
;
3350 ret
= wlcore_hw_set_key(wl
, cmd
, vif
, sta
, key_conf
);
3352 wl1271_ps_elp_sleep(wl
);
3355 if (might_change_spare
)
3356 wlcore_wake_queues(wl
, WLCORE_QUEUE_STOP_REASON_SPARE_BLK
);
3358 mutex_unlock(&wl
->mutex
);
3363 int wlcore_set_key(struct wl1271
*wl
, enum set_key_cmd cmd
,
3364 struct ieee80211_vif
*vif
,
3365 struct ieee80211_sta
*sta
,
3366 struct ieee80211_key_conf
*key_conf
)
3368 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3375 wl1271_debug(DEBUG_MAC80211
, "mac80211 set key");
3377 wl1271_debug(DEBUG_CRYPT
, "CMD: 0x%x sta: %p", cmd
, sta
);
3378 wl1271_debug(DEBUG_CRYPT
, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3379 key_conf
->cipher
, key_conf
->keyidx
,
3380 key_conf
->keylen
, key_conf
->flags
);
3381 wl1271_dump(DEBUG_CRYPT
, "KEY: ", key_conf
->key
, key_conf
->keylen
);
3383 if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
)
3385 struct wl1271_station
*wl_sta
= (void *)sta
->drv_priv
;
3386 hlid
= wl_sta
->hlid
;
3388 hlid
= wlvif
->ap
.bcast_hlid
;
3391 hlid
= wlvif
->sta
.hlid
;
3393 if (hlid
!= WL12XX_INVALID_LINK_ID
) {
3394 u64 tx_seq
= wl
->links
[hlid
].total_freed_pkts
;
3395 tx_seq_32
= WL1271_TX_SECURITY_HI32(tx_seq
);
3396 tx_seq_16
= WL1271_TX_SECURITY_LO16(tx_seq
);
3399 switch (key_conf
->cipher
) {
3400 case WLAN_CIPHER_SUITE_WEP40
:
3401 case WLAN_CIPHER_SUITE_WEP104
:
3404 key_conf
->hw_key_idx
= key_conf
->keyidx
;
3406 case WLAN_CIPHER_SUITE_TKIP
:
3407 key_type
= KEY_TKIP
;
3408 key_conf
->hw_key_idx
= key_conf
->keyidx
;
3410 case WLAN_CIPHER_SUITE_CCMP
:
3412 key_conf
->flags
|= IEEE80211_KEY_FLAG_PUT_IV_SPACE
;
3414 case WL1271_CIPHER_SUITE_GEM
:
3418 wl1271_error("Unknown key algo 0x%x", key_conf
->cipher
);
3425 ret
= wl1271_set_key(wl
, wlvif
, KEY_ADD_OR_REPLACE
,
3426 key_conf
->keyidx
, key_type
,
3427 key_conf
->keylen
, key_conf
->key
,
3428 tx_seq_32
, tx_seq_16
, sta
);
3430 wl1271_error("Could not add or replace key");
3435 * reconfiguring arp response if the unicast (or common)
3436 * encryption key type was changed
3438 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
3439 (sta
|| key_type
== KEY_WEP
) &&
3440 wlvif
->encryption_type
!= key_type
) {
3441 wlvif
->encryption_type
= key_type
;
3442 ret
= wl1271_cmd_build_arp_rsp(wl
, wlvif
);
3444 wl1271_warning("build arp rsp failed: %d", ret
);
3451 ret
= wl1271_set_key(wl
, wlvif
, KEY_REMOVE
,
3452 key_conf
->keyidx
, key_type
,
3453 key_conf
->keylen
, key_conf
->key
,
3456 wl1271_error("Could not remove key");
3462 wl1271_error("Unsupported key cmd 0x%x", cmd
);
3468 EXPORT_SYMBOL_GPL(wlcore_set_key
);
3470 static void wl1271_op_set_default_key_idx(struct ieee80211_hw
*hw
,
3471 struct ieee80211_vif
*vif
,
3474 struct wl1271
*wl
= hw
->priv
;
3475 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3478 wl1271_debug(DEBUG_MAC80211
, "mac80211 set default key idx %d",
3481 /* we don't handle unsetting of default key */
3485 mutex_lock(&wl
->mutex
);
3487 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3492 ret
= wl1271_ps_elp_wakeup(wl
);
3496 wlvif
->default_key
= key_idx
;
3498 /* the default WEP key needs to be configured at least once */
3499 if (wlvif
->encryption_type
== KEY_WEP
) {
3500 ret
= wl12xx_cmd_set_default_wep_key(wl
,
3508 wl1271_ps_elp_sleep(wl
);
3511 mutex_unlock(&wl
->mutex
);
3514 void wlcore_regdomain_config(struct wl1271
*wl
)
3518 if (!(wl
->quirks
& WLCORE_QUIRK_REGDOMAIN_CONF
))
3521 mutex_lock(&wl
->mutex
);
3523 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3526 ret
= wl1271_ps_elp_wakeup(wl
);
3530 ret
= wlcore_cmd_regdomain_config_locked(wl
);
3532 wl12xx_queue_recovery_work(wl
);
3536 wl1271_ps_elp_sleep(wl
);
3538 mutex_unlock(&wl
->mutex
);
3541 static int wl1271_op_hw_scan(struct ieee80211_hw
*hw
,
3542 struct ieee80211_vif
*vif
,
3543 struct ieee80211_scan_request
*hw_req
)
3545 struct cfg80211_scan_request
*req
= &hw_req
->req
;
3546 struct wl1271
*wl
= hw
->priv
;
3551 wl1271_debug(DEBUG_MAC80211
, "mac80211 hw scan");
3554 ssid
= req
->ssids
[0].ssid
;
3555 len
= req
->ssids
[0].ssid_len
;
3558 mutex_lock(&wl
->mutex
);
3560 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3562 * We cannot return -EBUSY here because cfg80211 will expect
3563 * a call to ieee80211_scan_completed if we do - in this case
3564 * there won't be any call.
3570 ret
= wl1271_ps_elp_wakeup(wl
);
3574 /* fail if there is any role in ROC */
3575 if (find_first_bit(wl
->roc_map
, WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
) {
3576 /* don't allow scanning right now */
3581 ret
= wlcore_scan(hw
->priv
, vif
, ssid
, len
, req
);
3583 wl1271_ps_elp_sleep(wl
);
3585 mutex_unlock(&wl
->mutex
);
3590 static void wl1271_op_cancel_hw_scan(struct ieee80211_hw
*hw
,
3591 struct ieee80211_vif
*vif
)
3593 struct wl1271
*wl
= hw
->priv
;
3594 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3597 wl1271_debug(DEBUG_MAC80211
, "mac80211 cancel hw scan");
3599 mutex_lock(&wl
->mutex
);
3601 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3604 if (wl
->scan
.state
== WL1271_SCAN_STATE_IDLE
)
3607 ret
= wl1271_ps_elp_wakeup(wl
);
3611 if (wl
->scan
.state
!= WL1271_SCAN_STATE_DONE
) {
3612 ret
= wl
->ops
->scan_stop(wl
, wlvif
);
3618 * Rearm the tx watchdog just before idling scan. This
3619 * prevents just-finished scans from triggering the watchdog
3621 wl12xx_rearm_tx_watchdog_locked(wl
);
3623 wl
->scan
.state
= WL1271_SCAN_STATE_IDLE
;
3624 memset(wl
->scan
.scanned_ch
, 0, sizeof(wl
->scan
.scanned_ch
));
3625 wl
->scan_wlvif
= NULL
;
3626 wl
->scan
.req
= NULL
;
3627 ieee80211_scan_completed(wl
->hw
, true);
3630 wl1271_ps_elp_sleep(wl
);
3632 mutex_unlock(&wl
->mutex
);
3634 cancel_delayed_work_sync(&wl
->scan_complete_work
);
3637 static int wl1271_op_sched_scan_start(struct ieee80211_hw
*hw
,
3638 struct ieee80211_vif
*vif
,
3639 struct cfg80211_sched_scan_request
*req
,
3640 struct ieee80211_sched_scan_ies
*ies
)
3642 struct wl1271
*wl
= hw
->priv
;
3643 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3646 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_start");
3648 mutex_lock(&wl
->mutex
);
3650 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3655 ret
= wl1271_ps_elp_wakeup(wl
);
3659 ret
= wl
->ops
->sched_scan_start(wl
, wlvif
, req
, ies
);
3663 wl
->sched_vif
= wlvif
;
3666 wl1271_ps_elp_sleep(wl
);
3668 mutex_unlock(&wl
->mutex
);
3672 static int wl1271_op_sched_scan_stop(struct ieee80211_hw
*hw
,
3673 struct ieee80211_vif
*vif
)
3675 struct wl1271
*wl
= hw
->priv
;
3676 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3679 wl1271_debug(DEBUG_MAC80211
, "wl1271_op_sched_scan_stop");
3681 mutex_lock(&wl
->mutex
);
3683 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
3686 ret
= wl1271_ps_elp_wakeup(wl
);
3690 wl
->ops
->sched_scan_stop(wl
, wlvif
);
3692 wl1271_ps_elp_sleep(wl
);
3694 mutex_unlock(&wl
->mutex
);
3699 static int wl1271_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
3701 struct wl1271
*wl
= hw
->priv
;
3704 mutex_lock(&wl
->mutex
);
3706 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3711 ret
= wl1271_ps_elp_wakeup(wl
);
3715 ret
= wl1271_acx_frag_threshold(wl
, value
);
3717 wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret
);
3719 wl1271_ps_elp_sleep(wl
);
3722 mutex_unlock(&wl
->mutex
);
3727 static int wl1271_op_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
3729 struct wl1271
*wl
= hw
->priv
;
3730 struct wl12xx_vif
*wlvif
;
3733 mutex_lock(&wl
->mutex
);
3735 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
3740 ret
= wl1271_ps_elp_wakeup(wl
);
3744 wl12xx_for_each_wlvif(wl
, wlvif
) {
3745 ret
= wl1271_acx_rts_threshold(wl
, wlvif
, value
);
3747 wl1271_warning("set rts threshold failed: %d", ret
);
3749 wl1271_ps_elp_sleep(wl
);
3752 mutex_unlock(&wl
->mutex
);
3757 static void wl12xx_remove_ie(struct sk_buff
*skb
, u8 eid
, int ieoffset
)
3760 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3761 u8
*ie
= (u8
*)cfg80211_find_ie(eid
, skb
->data
+ ieoffset
,
3762 skb
->len
- ieoffset
);
3767 memmove(ie
, next
, end
- next
);
3768 skb_trim(skb
, skb
->len
- len
);
3771 static void wl12xx_remove_vendor_ie(struct sk_buff
*skb
,
3772 unsigned int oui
, u8 oui_type
,
3776 const u8
*next
, *end
= skb
->data
+ skb
->len
;
3777 u8
*ie
= (u8
*)cfg80211_find_vendor_ie(oui
, oui_type
,
3778 skb
->data
+ ieoffset
,
3779 skb
->len
- ieoffset
);
3784 memmove(ie
, next
, end
- next
);
3785 skb_trim(skb
, skb
->len
- len
);
3788 static int wl1271_ap_set_probe_resp_tmpl(struct wl1271
*wl
, u32 rates
,
3789 struct ieee80211_vif
*vif
)
3791 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3792 struct sk_buff
*skb
;
3795 skb
= ieee80211_proberesp_get(wl
->hw
, vif
);
3799 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3800 CMD_TEMPL_AP_PROBE_RESPONSE
,
3809 wl1271_debug(DEBUG_AP
, "probe response updated");
3810 set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
, &wlvif
->flags
);
3816 static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271
*wl
,
3817 struct ieee80211_vif
*vif
,
3819 size_t probe_rsp_len
,
3822 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3823 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
3824 u8 probe_rsp_templ
[WL1271_CMD_TEMPL_MAX_SIZE
];
3825 int ssid_ie_offset
, ie_offset
, templ_len
;
3828 /* no need to change probe response if the SSID is set correctly */
3829 if (wlvif
->ssid_len
> 0)
3830 return wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3831 CMD_TEMPL_AP_PROBE_RESPONSE
,
3836 if (probe_rsp_len
+ bss_conf
->ssid_len
> WL1271_CMD_TEMPL_MAX_SIZE
) {
3837 wl1271_error("probe_rsp template too big");
3841 /* start searching from IE offset */
3842 ie_offset
= offsetof(struct ieee80211_mgmt
, u
.probe_resp
.variable
);
3844 ptr
= cfg80211_find_ie(WLAN_EID_SSID
, probe_rsp_data
+ ie_offset
,
3845 probe_rsp_len
- ie_offset
);
3847 wl1271_error("No SSID in beacon!");
3851 ssid_ie_offset
= ptr
- probe_rsp_data
;
3852 ptr
+= (ptr
[1] + 2);
3854 memcpy(probe_rsp_templ
, probe_rsp_data
, ssid_ie_offset
);
3856 /* insert SSID from bss_conf */
3857 probe_rsp_templ
[ssid_ie_offset
] = WLAN_EID_SSID
;
3858 probe_rsp_templ
[ssid_ie_offset
+ 1] = bss_conf
->ssid_len
;
3859 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2,
3860 bss_conf
->ssid
, bss_conf
->ssid_len
);
3861 templ_len
= ssid_ie_offset
+ 2 + bss_conf
->ssid_len
;
3863 memcpy(probe_rsp_templ
+ ssid_ie_offset
+ 2 + bss_conf
->ssid_len
,
3864 ptr
, probe_rsp_len
- (ptr
- probe_rsp_data
));
3865 templ_len
+= probe_rsp_len
- (ptr
- probe_rsp_data
);
3867 return wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3868 CMD_TEMPL_AP_PROBE_RESPONSE
,
3874 static int wl1271_bss_erp_info_changed(struct wl1271
*wl
,
3875 struct ieee80211_vif
*vif
,
3876 struct ieee80211_bss_conf
*bss_conf
,
3879 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3882 if (changed
& BSS_CHANGED_ERP_SLOT
) {
3883 if (bss_conf
->use_short_slot
)
3884 ret
= wl1271_acx_slot(wl
, wlvif
, SLOT_TIME_SHORT
);
3886 ret
= wl1271_acx_slot(wl
, wlvif
, SLOT_TIME_LONG
);
3888 wl1271_warning("Set slot time failed %d", ret
);
3893 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
3894 if (bss_conf
->use_short_preamble
)
3895 wl1271_acx_set_preamble(wl
, wlvif
, ACX_PREAMBLE_SHORT
);
3897 wl1271_acx_set_preamble(wl
, wlvif
, ACX_PREAMBLE_LONG
);
3900 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
3901 if (bss_conf
->use_cts_prot
)
3902 ret
= wl1271_acx_cts_protect(wl
, wlvif
,
3905 ret
= wl1271_acx_cts_protect(wl
, wlvif
,
3906 CTSPROTECT_DISABLE
);
3908 wl1271_warning("Set ctsprotect failed %d", ret
);
3917 static int wlcore_set_beacon_template(struct wl1271
*wl
,
3918 struct ieee80211_vif
*vif
,
3921 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
3922 struct ieee80211_hdr
*hdr
;
3925 int ieoffset
= offsetof(struct ieee80211_mgmt
, u
.beacon
.variable
);
3926 struct sk_buff
*beacon
= ieee80211_beacon_get(wl
->hw
, vif
);
3934 wl1271_debug(DEBUG_MASTER
, "beacon updated");
3936 ret
= wl1271_ssid_set(wlvif
, beacon
, ieoffset
);
3938 dev_kfree_skb(beacon
);
3941 min_rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
3942 tmpl_id
= is_ap
? CMD_TEMPL_AP_BEACON
:
3944 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
, tmpl_id
,
3949 dev_kfree_skb(beacon
);
3953 wlvif
->wmm_enabled
=
3954 cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT
,
3955 WLAN_OUI_TYPE_MICROSOFT_WMM
,
3956 beacon
->data
+ ieoffset
,
3957 beacon
->len
- ieoffset
);
3960 * In case we already have a probe-resp beacon set explicitly
3961 * by usermode, don't use the beacon data.
3963 if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
, &wlvif
->flags
))
3966 /* remove TIM ie from probe response */
3967 wl12xx_remove_ie(beacon
, WLAN_EID_TIM
, ieoffset
);
3970 * remove p2p ie from probe response.
3971 * the fw reponds to probe requests that don't include
3972 * the p2p ie. probe requests with p2p ie will be passed,
3973 * and will be responded by the supplicant (the spec
3974 * forbids including the p2p ie when responding to probe
3975 * requests that didn't include it).
3977 wl12xx_remove_vendor_ie(beacon
, WLAN_OUI_WFA
,
3978 WLAN_OUI_TYPE_WFA_P2P
, ieoffset
);
3980 hdr
= (struct ieee80211_hdr
*) beacon
->data
;
3981 hdr
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
3982 IEEE80211_STYPE_PROBE_RESP
);
3984 ret
= wl1271_ap_set_probe_resp_tmpl_legacy(wl
, vif
,
3989 ret
= wl1271_cmd_template_set(wl
, wlvif
->role_id
,
3990 CMD_TEMPL_PROBE_RESPONSE
,
3995 dev_kfree_skb(beacon
);
4003 static int wl1271_bss_beacon_info_changed(struct wl1271
*wl
,
4004 struct ieee80211_vif
*vif
,
4005 struct ieee80211_bss_conf
*bss_conf
,
4008 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4009 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
4012 if (changed
& BSS_CHANGED_BEACON_INT
) {
4013 wl1271_debug(DEBUG_MASTER
, "beacon interval updated: %d",
4014 bss_conf
->beacon_int
);
4016 wlvif
->beacon_int
= bss_conf
->beacon_int
;
4019 if ((changed
& BSS_CHANGED_AP_PROBE_RESP
) && is_ap
) {
4020 u32 rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
4022 wl1271_ap_set_probe_resp_tmpl(wl
, rate
, vif
);
4025 if (changed
& BSS_CHANGED_BEACON
) {
4026 ret
= wlcore_set_beacon_template(wl
, vif
, is_ap
);
4033 wl1271_error("beacon info change failed: %d", ret
);
4037 /* AP mode changes */
4038 static void wl1271_bss_info_changed_ap(struct wl1271
*wl
,
4039 struct ieee80211_vif
*vif
,
4040 struct ieee80211_bss_conf
*bss_conf
,
4043 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4046 if (changed
& BSS_CHANGED_BASIC_RATES
) {
4047 u32 rates
= bss_conf
->basic_rates
;
4049 wlvif
->basic_rate_set
= wl1271_tx_enabled_rates_get(wl
, rates
,
4051 wlvif
->basic_rate
= wl1271_tx_min_rate_get(wl
,
4052 wlvif
->basic_rate_set
);
4054 ret
= wl1271_init_ap_rates(wl
, wlvif
);
4056 wl1271_error("AP rate policy change failed %d", ret
);
4060 ret
= wl1271_ap_init_templates(wl
, vif
);
4064 ret
= wl1271_ap_set_probe_resp_tmpl(wl
, wlvif
->basic_rate
, vif
);
4068 ret
= wlcore_set_beacon_template(wl
, vif
, true);
4073 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
, changed
);
4077 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
4078 if (bss_conf
->enable_beacon
) {
4079 if (!test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
4080 ret
= wl12xx_cmd_role_start_ap(wl
, wlvif
);
4084 ret
= wl1271_ap_init_hwenc(wl
, wlvif
);
4088 set_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
);
4089 wl1271_debug(DEBUG_AP
, "started AP");
4092 if (test_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
)) {
4094 * AP might be in ROC in case we have just
4095 * sent auth reply. handle it.
4097 if (test_bit(wlvif
->role_id
, wl
->roc_map
))
4098 wl12xx_croc(wl
, wlvif
->role_id
);
4100 ret
= wl12xx_cmd_role_stop_ap(wl
, wlvif
);
4104 clear_bit(WLVIF_FLAG_AP_STARTED
, &wlvif
->flags
);
4105 clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET
,
4107 wl1271_debug(DEBUG_AP
, "stopped AP");
4112 ret
= wl1271_bss_erp_info_changed(wl
, vif
, bss_conf
, changed
);
4116 /* Handle HT information change */
4117 if ((changed
& BSS_CHANGED_HT
) &&
4118 (bss_conf
->chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
)) {
4119 ret
= wl1271_acx_set_ht_information(wl
, wlvif
,
4120 bss_conf
->ht_operation_mode
);
4122 wl1271_warning("Set ht information failed %d", ret
);
4131 static int wlcore_set_bssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
4132 struct ieee80211_bss_conf
*bss_conf
,
4138 wl1271_debug(DEBUG_MAC80211
,
4139 "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
4140 bss_conf
->bssid
, bss_conf
->aid
,
4141 bss_conf
->beacon_int
,
4142 bss_conf
->basic_rates
, sta_rate_set
);
4144 wlvif
->beacon_int
= bss_conf
->beacon_int
;
4145 rates
= bss_conf
->basic_rates
;
4146 wlvif
->basic_rate_set
=
4147 wl1271_tx_enabled_rates_get(wl
, rates
,
4150 wl1271_tx_min_rate_get(wl
,
4151 wlvif
->basic_rate_set
);
4155 wl1271_tx_enabled_rates_get(wl
,
4159 /* we only support sched_scan while not connected */
4160 if (wl
->sched_vif
== wlvif
)
4161 wl
->ops
->sched_scan_stop(wl
, wlvif
);
4163 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4167 ret
= wl12xx_cmd_build_null_data(wl
, wlvif
);
4171 ret
= wl1271_build_qos_null_data(wl
, wl12xx_wlvif_to_vif(wlvif
));
4175 wlcore_set_ssid(wl
, wlvif
);
4177 set_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
);
4182 static int wlcore_clear_bssid(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
)
4186 /* revert back to minimum rates for the current band */
4187 wl1271_set_band_rate(wl
, wlvif
);
4188 wlvif
->basic_rate
= wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
4190 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4194 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
4195 test_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
)) {
4196 ret
= wl12xx_cmd_role_stop_sta(wl
, wlvif
);
4201 clear_bit(WLVIF_FLAG_IN_USE
, &wlvif
->flags
);
4204 /* STA/IBSS mode changes */
4205 static void wl1271_bss_info_changed_sta(struct wl1271
*wl
,
4206 struct ieee80211_vif
*vif
,
4207 struct ieee80211_bss_conf
*bss_conf
,
4210 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4211 bool do_join
= false;
4212 bool is_ibss
= (wlvif
->bss_type
== BSS_TYPE_IBSS
);
4213 bool ibss_joined
= false;
4214 u32 sta_rate_set
= 0;
4216 struct ieee80211_sta
*sta
;
4217 bool sta_exists
= false;
4218 struct ieee80211_sta_ht_cap sta_ht_cap
;
4221 ret
= wl1271_bss_beacon_info_changed(wl
, vif
, bss_conf
,
4227 if (changed
& BSS_CHANGED_IBSS
) {
4228 if (bss_conf
->ibss_joined
) {
4229 set_bit(WLVIF_FLAG_IBSS_JOINED
, &wlvif
->flags
);
4232 wlcore_unset_assoc(wl
, wlvif
);
4233 wl12xx_cmd_role_stop_sta(wl
, wlvif
);
4237 if ((changed
& BSS_CHANGED_BEACON_INT
) && ibss_joined
)
4240 /* Need to update the SSID (for filtering etc) */
4241 if ((changed
& BSS_CHANGED_BEACON
) && ibss_joined
)
4244 if ((changed
& BSS_CHANGED_BEACON_ENABLED
) && ibss_joined
) {
4245 wl1271_debug(DEBUG_ADHOC
, "ad-hoc beaconing: %s",
4246 bss_conf
->enable_beacon
? "enabled" : "disabled");
4251 if (changed
& BSS_CHANGED_IDLE
&& !is_ibss
)
4252 wl1271_sta_handle_idle(wl
, wlvif
, bss_conf
->idle
);
4254 if (changed
& BSS_CHANGED_CQM
) {
4255 bool enable
= false;
4256 if (bss_conf
->cqm_rssi_thold
)
4258 ret
= wl1271_acx_rssi_snr_trigger(wl
, wlvif
, enable
,
4259 bss_conf
->cqm_rssi_thold
,
4260 bss_conf
->cqm_rssi_hyst
);
4263 wlvif
->rssi_thold
= bss_conf
->cqm_rssi_thold
;
4266 if (changed
& (BSS_CHANGED_BSSID
| BSS_CHANGED_HT
|
4267 BSS_CHANGED_ASSOC
)) {
4269 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
4271 u8
*rx_mask
= sta
->ht_cap
.mcs
.rx_mask
;
4273 /* save the supp_rates of the ap */
4274 sta_rate_set
= sta
->supp_rates
[wlvif
->band
];
4275 if (sta
->ht_cap
.ht_supported
)
4277 (rx_mask
[0] << HW_HT_RATES_OFFSET
) |
4278 (rx_mask
[1] << HW_MIMO_RATES_OFFSET
);
4279 sta_ht_cap
= sta
->ht_cap
;
4286 if (changed
& BSS_CHANGED_BSSID
) {
4287 if (!is_zero_ether_addr(bss_conf
->bssid
)) {
4288 ret
= wlcore_set_bssid(wl
, wlvif
, bss_conf
,
4293 /* Need to update the BSSID (for filtering etc) */
4296 ret
= wlcore_clear_bssid(wl
, wlvif
);
4302 if (changed
& BSS_CHANGED_IBSS
) {
4303 wl1271_debug(DEBUG_ADHOC
, "ibss_joined: %d",
4304 bss_conf
->ibss_joined
);
4306 if (bss_conf
->ibss_joined
) {
4307 u32 rates
= bss_conf
->basic_rates
;
4308 wlvif
->basic_rate_set
=
4309 wl1271_tx_enabled_rates_get(wl
, rates
,
4312 wl1271_tx_min_rate_get(wl
,
4313 wlvif
->basic_rate_set
);
4315 /* by default, use 11b + OFDM rates */
4316 wlvif
->rate_set
= CONF_TX_IBSS_DEFAULT_RATES
;
4317 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
4323 if ((changed
& BSS_CHANGED_BEACON_INFO
) && bss_conf
->dtim_period
) {
4324 /* enable beacon filtering */
4325 ret
= wl1271_acx_beacon_filter_opt(wl
, wlvif
, true);
4330 ret
= wl1271_bss_erp_info_changed(wl
, vif
, bss_conf
, changed
);
4335 ret
= wlcore_join(wl
, wlvif
);
4337 wl1271_warning("cmd join failed %d", ret
);
4342 if (changed
& BSS_CHANGED_ASSOC
) {
4343 if (bss_conf
->assoc
) {
4344 ret
= wlcore_set_assoc(wl
, wlvif
, bss_conf
,
4349 if (test_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
))
4350 wl12xx_set_authorized(wl
, wlvif
);
4352 wlcore_unset_assoc(wl
, wlvif
);
4356 if (changed
& BSS_CHANGED_PS
) {
4357 if ((bss_conf
->ps
) &&
4358 test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
) &&
4359 !test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
)) {
4363 if (wl
->conf
.conn
.forced_ps
) {
4364 ps_mode
= STATION_POWER_SAVE_MODE
;
4365 ps_mode_str
= "forced";
4367 ps_mode
= STATION_AUTO_PS_MODE
;
4368 ps_mode_str
= "auto";
4371 wl1271_debug(DEBUG_PSM
, "%s ps enabled", ps_mode_str
);
4373 ret
= wl1271_ps_set_mode(wl
, wlvif
, ps_mode
);
4375 wl1271_warning("enter %s ps failed %d",
4377 } else if (!bss_conf
->ps
&&
4378 test_bit(WLVIF_FLAG_IN_PS
, &wlvif
->flags
)) {
4379 wl1271_debug(DEBUG_PSM
, "auto ps disabled");
4381 ret
= wl1271_ps_set_mode(wl
, wlvif
,
4382 STATION_ACTIVE_MODE
);
4384 wl1271_warning("exit auto ps failed %d", ret
);
4388 /* Handle new association with HT. Do this after join. */
4391 bss_conf
->chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
;
4393 ret
= wlcore_hw_set_peer_cap(wl
,
4399 wl1271_warning("Set ht cap failed %d", ret
);
4405 ret
= wl1271_acx_set_ht_information(wl
, wlvif
,
4406 bss_conf
->ht_operation_mode
);
4408 wl1271_warning("Set ht information failed %d",
4415 /* Handle arp filtering. Done after join. */
4416 if ((changed
& BSS_CHANGED_ARP_FILTER
) ||
4417 (!is_ibss
&& (changed
& BSS_CHANGED_QOS
))) {
4418 __be32 addr
= bss_conf
->arp_addr_list
[0];
4419 wlvif
->sta
.qos
= bss_conf
->qos
;
4420 WARN_ON(wlvif
->bss_type
!= BSS_TYPE_STA_BSS
);
4422 if (bss_conf
->arp_addr_cnt
== 1 && bss_conf
->assoc
) {
4423 wlvif
->ip_addr
= addr
;
4425 * The template should have been configured only upon
4426 * association. however, it seems that the correct ip
4427 * isn't being set (when sending), so we have to
4428 * reconfigure the template upon every ip change.
4430 ret
= wl1271_cmd_build_arp_rsp(wl
, wlvif
);
4432 wl1271_warning("build arp rsp failed: %d", ret
);
4436 ret
= wl1271_acx_arp_ip_filter(wl
, wlvif
,
4437 (ACX_ARP_FILTER_ARP_FILTERING
|
4438 ACX_ARP_FILTER_AUTO_ARP
),
4442 ret
= wl1271_acx_arp_ip_filter(wl
, wlvif
, 0, addr
);
4453 static void wl1271_op_bss_info_changed(struct ieee80211_hw
*hw
,
4454 struct ieee80211_vif
*vif
,
4455 struct ieee80211_bss_conf
*bss_conf
,
4458 struct wl1271
*wl
= hw
->priv
;
4459 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4460 bool is_ap
= (wlvif
->bss_type
== BSS_TYPE_AP_BSS
);
4463 wl1271_debug(DEBUG_MAC80211
, "mac80211 bss info role %d changed 0x%x",
4464 wlvif
->role_id
, (int)changed
);
4467 * make sure to cancel pending disconnections if our association
4470 if (!is_ap
&& (changed
& BSS_CHANGED_ASSOC
))
4471 cancel_delayed_work_sync(&wlvif
->connection_loss_work
);
4473 if (is_ap
&& (changed
& BSS_CHANGED_BEACON_ENABLED
) &&
4474 !bss_conf
->enable_beacon
)
4475 wl1271_tx_flush(wl
);
4477 mutex_lock(&wl
->mutex
);
4479 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4482 if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
)))
4485 ret
= wl1271_ps_elp_wakeup(wl
);
4489 if ((changed
& BSS_CHANGED_TXPOWER
) &&
4490 bss_conf
->txpower
!= wlvif
->power_level
) {
4492 ret
= wl1271_acx_tx_power(wl
, wlvif
, bss_conf
->txpower
);
4496 wlvif
->power_level
= bss_conf
->txpower
;
4500 wl1271_bss_info_changed_ap(wl
, vif
, bss_conf
, changed
);
4502 wl1271_bss_info_changed_sta(wl
, vif
, bss_conf
, changed
);
4504 wl1271_ps_elp_sleep(wl
);
4507 mutex_unlock(&wl
->mutex
);
4510 static int wlcore_op_add_chanctx(struct ieee80211_hw
*hw
,
4511 struct ieee80211_chanctx_conf
*ctx
)
4513 wl1271_debug(DEBUG_MAC80211
, "mac80211 add chanctx %d (type %d)",
4514 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4515 cfg80211_get_chandef_type(&ctx
->def
));
4519 static void wlcore_op_remove_chanctx(struct ieee80211_hw
*hw
,
4520 struct ieee80211_chanctx_conf
*ctx
)
4522 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove chanctx %d (type %d)",
4523 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4524 cfg80211_get_chandef_type(&ctx
->def
));
4527 static void wlcore_op_change_chanctx(struct ieee80211_hw
*hw
,
4528 struct ieee80211_chanctx_conf
*ctx
,
4531 wl1271_debug(DEBUG_MAC80211
,
4532 "mac80211 change chanctx %d (type %d) changed 0x%x",
4533 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4534 cfg80211_get_chandef_type(&ctx
->def
), changed
);
4537 static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw
*hw
,
4538 struct ieee80211_vif
*vif
,
4539 struct ieee80211_chanctx_conf
*ctx
)
4541 struct wl1271
*wl
= hw
->priv
;
4542 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4543 int channel
= ieee80211_frequency_to_channel(
4544 ctx
->def
.chan
->center_freq
);
4546 wl1271_debug(DEBUG_MAC80211
,
4547 "mac80211 assign chanctx (role %d) %d (type %d)",
4548 wlvif
->role_id
, channel
, cfg80211_get_chandef_type(&ctx
->def
));
4550 mutex_lock(&wl
->mutex
);
4552 wlvif
->band
= ctx
->def
.chan
->band
;
4553 wlvif
->channel
= channel
;
4554 wlvif
->channel_type
= cfg80211_get_chandef_type(&ctx
->def
);
4556 /* update default rates according to the band */
4557 wl1271_set_band_rate(wl
, wlvif
);
4559 mutex_unlock(&wl
->mutex
);
4564 static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw
*hw
,
4565 struct ieee80211_vif
*vif
,
4566 struct ieee80211_chanctx_conf
*ctx
)
4568 struct wl1271
*wl
= hw
->priv
;
4569 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4571 wl1271_debug(DEBUG_MAC80211
,
4572 "mac80211 unassign chanctx (role %d) %d (type %d)",
4574 ieee80211_frequency_to_channel(ctx
->def
.chan
->center_freq
),
4575 cfg80211_get_chandef_type(&ctx
->def
));
4577 wl1271_tx_flush(wl
);
4580 static int wl1271_op_conf_tx(struct ieee80211_hw
*hw
,
4581 struct ieee80211_vif
*vif
, u16 queue
,
4582 const struct ieee80211_tx_queue_params
*params
)
4584 struct wl1271
*wl
= hw
->priv
;
4585 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4589 mutex_lock(&wl
->mutex
);
4591 wl1271_debug(DEBUG_MAC80211
, "mac80211 conf tx %d", queue
);
4594 ps_scheme
= CONF_PS_SCHEME_UPSD_TRIGGER
;
4596 ps_scheme
= CONF_PS_SCHEME_LEGACY
;
4598 if (!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
4601 ret
= wl1271_ps_elp_wakeup(wl
);
4606 * the txop is confed in units of 32us by the mac80211,
4609 ret
= wl1271_acx_ac_cfg(wl
, wlvif
, wl1271_tx_get_queue(queue
),
4610 params
->cw_min
, params
->cw_max
,
4611 params
->aifs
, params
->txop
<< 5);
4615 ret
= wl1271_acx_tid_cfg(wl
, wlvif
, wl1271_tx_get_queue(queue
),
4616 CONF_CHANNEL_TYPE_EDCF
,
4617 wl1271_tx_get_queue(queue
),
4618 ps_scheme
, CONF_ACK_POLICY_LEGACY
,
4622 wl1271_ps_elp_sleep(wl
);
4625 mutex_unlock(&wl
->mutex
);
4630 static u64
wl1271_op_get_tsf(struct ieee80211_hw
*hw
,
4631 struct ieee80211_vif
*vif
)
4634 struct wl1271
*wl
= hw
->priv
;
4635 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4636 u64 mactime
= ULLONG_MAX
;
4639 wl1271_debug(DEBUG_MAC80211
, "mac80211 get tsf");
4641 mutex_lock(&wl
->mutex
);
4643 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
4646 ret
= wl1271_ps_elp_wakeup(wl
);
4650 ret
= wl12xx_acx_tsf_info(wl
, wlvif
, &mactime
);
4655 wl1271_ps_elp_sleep(wl
);
4658 mutex_unlock(&wl
->mutex
);
4662 static int wl1271_op_get_survey(struct ieee80211_hw
*hw
, int idx
,
4663 struct survey_info
*survey
)
4665 struct ieee80211_conf
*conf
= &hw
->conf
;
4670 survey
->channel
= conf
->chandef
.chan
;
4675 static int wl1271_allocate_sta(struct wl1271
*wl
,
4676 struct wl12xx_vif
*wlvif
,
4677 struct ieee80211_sta
*sta
)
4679 struct wl1271_station
*wl_sta
;
4683 if (wl
->active_sta_count
>= wl
->max_ap_stations
) {
4684 wl1271_warning("could not allocate HLID - too much stations");
4688 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4689 ret
= wl12xx_allocate_link(wl
, wlvif
, &wl_sta
->hlid
);
4691 wl1271_warning("could not allocate HLID - too many links");
4695 /* use the previous security seq, if this is a recovery/resume */
4696 wl
->links
[wl_sta
->hlid
].total_freed_pkts
= wl_sta
->total_freed_pkts
;
4698 set_bit(wl_sta
->hlid
, wlvif
->ap
.sta_hlid_map
);
4699 memcpy(wl
->links
[wl_sta
->hlid
].addr
, sta
->addr
, ETH_ALEN
);
4700 wl
->active_sta_count
++;
4704 void wl1271_free_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
, u8 hlid
)
4706 struct wl1271_station
*wl_sta
;
4707 struct ieee80211_sta
*sta
;
4708 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
4710 if (!test_bit(hlid
, wlvif
->ap
.sta_hlid_map
))
4713 clear_bit(hlid
, wlvif
->ap
.sta_hlid_map
);
4714 __clear_bit(hlid
, &wl
->ap_ps_map
);
4715 __clear_bit(hlid
, (unsigned long *)&wl
->ap_fw_ps_map
);
4718 * save the last used PN in the private part of iee80211_sta,
4719 * in case of recovery/suspend
4722 sta
= ieee80211_find_sta(vif
, wl
->links
[hlid
].addr
);
4724 wl_sta
= (void *)sta
->drv_priv
;
4725 wl_sta
->total_freed_pkts
= wl
->links
[hlid
].total_freed_pkts
;
4728 * increment the initial seq number on recovery to account for
4729 * transmitted packets that we haven't yet got in the FW status
4731 if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS
, &wl
->flags
))
4732 wl_sta
->total_freed_pkts
+=
4733 WL1271_TX_SQN_POST_RECOVERY_PADDING
;
4737 wl12xx_free_link(wl
, wlvif
, &hlid
);
4738 wl
->active_sta_count
--;
4741 * rearm the tx watchdog when the last STA is freed - give the FW a
4742 * chance to return STA-buffered packets before complaining.
4744 if (wl
->active_sta_count
== 0)
4745 wl12xx_rearm_tx_watchdog_locked(wl
);
4748 static int wl12xx_sta_add(struct wl1271
*wl
,
4749 struct wl12xx_vif
*wlvif
,
4750 struct ieee80211_sta
*sta
)
4752 struct wl1271_station
*wl_sta
;
4756 wl1271_debug(DEBUG_MAC80211
, "mac80211 add sta %d", (int)sta
->aid
);
4758 ret
= wl1271_allocate_sta(wl
, wlvif
, sta
);
4762 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4763 hlid
= wl_sta
->hlid
;
4765 ret
= wl12xx_cmd_add_peer(wl
, wlvif
, sta
, hlid
);
4767 wl1271_free_sta(wl
, wlvif
, hlid
);
4772 static int wl12xx_sta_remove(struct wl1271
*wl
,
4773 struct wl12xx_vif
*wlvif
,
4774 struct ieee80211_sta
*sta
)
4776 struct wl1271_station
*wl_sta
;
4779 wl1271_debug(DEBUG_MAC80211
, "mac80211 remove sta %d", (int)sta
->aid
);
4781 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4783 if (WARN_ON(!test_bit(id
, wlvif
->ap
.sta_hlid_map
)))
4786 ret
= wl12xx_cmd_remove_peer(wl
, wlvif
, wl_sta
->hlid
);
4790 wl1271_free_sta(wl
, wlvif
, wl_sta
->hlid
);
4794 static void wlcore_roc_if_possible(struct wl1271
*wl
,
4795 struct wl12xx_vif
*wlvif
)
4797 if (find_first_bit(wl
->roc_map
,
4798 WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
)
4801 if (WARN_ON(wlvif
->role_id
== WL12XX_INVALID_ROLE_ID
))
4804 wl12xx_roc(wl
, wlvif
, wlvif
->role_id
, wlvif
->band
, wlvif
->channel
);
4808 * when wl_sta is NULL, we treat this call as if coming from a
4809 * pending auth reply.
4810 * wl->mutex must be taken and the FW must be awake when the call
4813 void wlcore_update_inconn_sta(struct wl1271
*wl
, struct wl12xx_vif
*wlvif
,
4814 struct wl1271_station
*wl_sta
, bool in_conn
)
4817 if (WARN_ON(wl_sta
&& wl_sta
->in_connection
))
4820 if (!wlvif
->ap_pending_auth_reply
&&
4821 !wlvif
->inconn_count
)
4822 wlcore_roc_if_possible(wl
, wlvif
);
4825 wl_sta
->in_connection
= true;
4826 wlvif
->inconn_count
++;
4828 wlvif
->ap_pending_auth_reply
= true;
4831 if (wl_sta
&& !wl_sta
->in_connection
)
4834 if (WARN_ON(!wl_sta
&& !wlvif
->ap_pending_auth_reply
))
4837 if (WARN_ON(wl_sta
&& !wlvif
->inconn_count
))
4841 wl_sta
->in_connection
= false;
4842 wlvif
->inconn_count
--;
4844 wlvif
->ap_pending_auth_reply
= false;
4847 if (!wlvif
->inconn_count
&& !wlvif
->ap_pending_auth_reply
&&
4848 test_bit(wlvif
->role_id
, wl
->roc_map
))
4849 wl12xx_croc(wl
, wlvif
->role_id
);
4853 static int wl12xx_update_sta_state(struct wl1271
*wl
,
4854 struct wl12xx_vif
*wlvif
,
4855 struct ieee80211_sta
*sta
,
4856 enum ieee80211_sta_state old_state
,
4857 enum ieee80211_sta_state new_state
)
4859 struct wl1271_station
*wl_sta
;
4860 bool is_ap
= wlvif
->bss_type
== BSS_TYPE_AP_BSS
;
4861 bool is_sta
= wlvif
->bss_type
== BSS_TYPE_STA_BSS
;
4864 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
4866 /* Add station (AP mode) */
4868 old_state
== IEEE80211_STA_NOTEXIST
&&
4869 new_state
== IEEE80211_STA_NONE
) {
4870 ret
= wl12xx_sta_add(wl
, wlvif
, sta
);
4874 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, true);
4877 /* Remove station (AP mode) */
4879 old_state
== IEEE80211_STA_NONE
&&
4880 new_state
== IEEE80211_STA_NOTEXIST
) {
4882 wl12xx_sta_remove(wl
, wlvif
, sta
);
4884 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, false);
4887 /* Authorize station (AP mode) */
4889 new_state
== IEEE80211_STA_AUTHORIZED
) {
4890 ret
= wl12xx_cmd_set_peer_state(wl
, wlvif
, wl_sta
->hlid
);
4894 ret
= wl1271_acx_set_ht_capabilities(wl
, &sta
->ht_cap
, true,
4899 wlcore_update_inconn_sta(wl
, wlvif
, wl_sta
, false);
4902 /* Authorize station */
4904 new_state
== IEEE80211_STA_AUTHORIZED
) {
4905 set_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
);
4906 ret
= wl12xx_set_authorized(wl
, wlvif
);
4912 old_state
== IEEE80211_STA_AUTHORIZED
&&
4913 new_state
== IEEE80211_STA_ASSOC
) {
4914 clear_bit(WLVIF_FLAG_STA_AUTHORIZED
, &wlvif
->flags
);
4915 clear_bit(WLVIF_FLAG_STA_STATE_SENT
, &wlvif
->flags
);
4918 /* clear ROCs on failure or authorization */
4920 (new_state
== IEEE80211_STA_AUTHORIZED
||
4921 new_state
== IEEE80211_STA_NOTEXIST
)) {
4922 if (test_bit(wlvif
->role_id
, wl
->roc_map
))
4923 wl12xx_croc(wl
, wlvif
->role_id
);
4927 old_state
== IEEE80211_STA_NOTEXIST
&&
4928 new_state
== IEEE80211_STA_NONE
) {
4929 if (find_first_bit(wl
->roc_map
,
4930 WL12XX_MAX_ROLES
) >= WL12XX_MAX_ROLES
) {
4931 WARN_ON(wlvif
->role_id
== WL12XX_INVALID_ROLE_ID
);
4932 wl12xx_roc(wl
, wlvif
, wlvif
->role_id
,
4933 wlvif
->band
, wlvif
->channel
);
4939 static int wl12xx_op_sta_state(struct ieee80211_hw
*hw
,
4940 struct ieee80211_vif
*vif
,
4941 struct ieee80211_sta
*sta
,
4942 enum ieee80211_sta_state old_state
,
4943 enum ieee80211_sta_state new_state
)
4945 struct wl1271
*wl
= hw
->priv
;
4946 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4949 wl1271_debug(DEBUG_MAC80211
, "mac80211 sta %d state=%d->%d",
4950 sta
->aid
, old_state
, new_state
);
4952 mutex_lock(&wl
->mutex
);
4954 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
4959 ret
= wl1271_ps_elp_wakeup(wl
);
4963 ret
= wl12xx_update_sta_state(wl
, wlvif
, sta
, old_state
, new_state
);
4965 wl1271_ps_elp_sleep(wl
);
4967 mutex_unlock(&wl
->mutex
);
4968 if (new_state
< old_state
)
4973 static int wl1271_op_ampdu_action(struct ieee80211_hw
*hw
,
4974 struct ieee80211_vif
*vif
,
4975 enum ieee80211_ampdu_mlme_action action
,
4976 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
4979 struct wl1271
*wl
= hw
->priv
;
4980 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
4982 u8 hlid
, *ba_bitmap
;
4984 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu action %d tid %d", action
,
4987 /* sanity check - the fields in FW are only 8bits wide */
4988 if (WARN_ON(tid
> 0xFF))
4991 mutex_lock(&wl
->mutex
);
4993 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
4998 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
) {
4999 hlid
= wlvif
->sta
.hlid
;
5000 } else if (wlvif
->bss_type
== BSS_TYPE_AP_BSS
) {
5001 struct wl1271_station
*wl_sta
;
5003 wl_sta
= (struct wl1271_station
*)sta
->drv_priv
;
5004 hlid
= wl_sta
->hlid
;
5010 ba_bitmap
= &wl
->links
[hlid
].ba_bitmap
;
5012 ret
= wl1271_ps_elp_wakeup(wl
);
5016 wl1271_debug(DEBUG_MAC80211
, "mac80211 ampdu: Rx tid %d action %d",
5020 case IEEE80211_AMPDU_RX_START
:
5021 if (!wlvif
->ba_support
|| !wlvif
->ba_allowed
) {
5026 if (wl
->ba_rx_session_count
>= wl
->ba_rx_session_count_max
) {
5028 wl1271_error("exceeded max RX BA sessions");
5032 if (*ba_bitmap
& BIT(tid
)) {
5034 wl1271_error("cannot enable RX BA session on active "
5039 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, *ssn
, true,
5042 *ba_bitmap
|= BIT(tid
);
5043 wl
->ba_rx_session_count
++;
5047 case IEEE80211_AMPDU_RX_STOP
:
5048 if (!(*ba_bitmap
& BIT(tid
))) {
5050 * this happens on reconfig - so only output a debug
5051 * message for now, and don't fail the function.
5053 wl1271_debug(DEBUG_MAC80211
,
5054 "no active RX BA session on tid: %d",
5060 ret
= wl12xx_acx_set_ba_receiver_session(wl
, tid
, 0, false,
5063 *ba_bitmap
&= ~BIT(tid
);
5064 wl
->ba_rx_session_count
--;
5069 * The BA initiator session management in FW independently.
5070 * Falling break here on purpose for all TX APDU commands.
5072 case IEEE80211_AMPDU_TX_START
:
5073 case IEEE80211_AMPDU_TX_STOP_CONT
:
5074 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
5075 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
5076 case IEEE80211_AMPDU_TX_OPERATIONAL
:
5081 wl1271_error("Incorrect ampdu action id=%x\n", action
);
5085 wl1271_ps_elp_sleep(wl
);
5088 mutex_unlock(&wl
->mutex
);
5093 static int wl12xx_set_bitrate_mask(struct ieee80211_hw
*hw
,
5094 struct ieee80211_vif
*vif
,
5095 const struct cfg80211_bitrate_mask
*mask
)
5097 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5098 struct wl1271
*wl
= hw
->priv
;
5101 wl1271_debug(DEBUG_MAC80211
, "mac80211 set_bitrate_mask 0x%x 0x%x",
5102 mask
->control
[NL80211_BAND_2GHZ
].legacy
,
5103 mask
->control
[NL80211_BAND_5GHZ
].legacy
);
5105 mutex_lock(&wl
->mutex
);
5107 for (i
= 0; i
< WLCORE_NUM_BANDS
; i
++)
5108 wlvif
->bitrate_masks
[i
] =
5109 wl1271_tx_enabled_rates_get(wl
,
5110 mask
->control
[i
].legacy
,
5113 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5116 if (wlvif
->bss_type
== BSS_TYPE_STA_BSS
&&
5117 !test_bit(WLVIF_FLAG_STA_ASSOCIATED
, &wlvif
->flags
)) {
5119 ret
= wl1271_ps_elp_wakeup(wl
);
5123 wl1271_set_band_rate(wl
, wlvif
);
5125 wl1271_tx_min_rate_get(wl
, wlvif
->basic_rate_set
);
5126 ret
= wl1271_acx_sta_rate_policies(wl
, wlvif
);
5128 wl1271_ps_elp_sleep(wl
);
5131 mutex_unlock(&wl
->mutex
);
5136 static void wl12xx_op_channel_switch(struct ieee80211_hw
*hw
,
5137 struct ieee80211_channel_switch
*ch_switch
)
5139 struct wl1271
*wl
= hw
->priv
;
5140 struct wl12xx_vif
*wlvif
;
5143 wl1271_debug(DEBUG_MAC80211
, "mac80211 channel switch");
5145 wl1271_tx_flush(wl
);
5147 mutex_lock(&wl
->mutex
);
5149 if (unlikely(wl
->state
== WLCORE_STATE_OFF
)) {
5150 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
5151 struct ieee80211_vif
*vif
= wl12xx_wlvif_to_vif(wlvif
);
5152 ieee80211_chswitch_done(vif
, false);
5155 } else if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5159 ret
= wl1271_ps_elp_wakeup(wl
);
5163 /* TODO: change mac80211 to pass vif as param */
5164 wl12xx_for_each_wlvif_sta(wl
, wlvif
) {
5165 unsigned long delay_usec
;
5167 ret
= wl
->ops
->channel_switch(wl
, wlvif
, ch_switch
);
5171 set_bit(WLVIF_FLAG_CS_PROGRESS
, &wlvif
->flags
);
5173 /* indicate failure 5 seconds after channel switch time */
5174 delay_usec
= ieee80211_tu_to_usec(wlvif
->beacon_int
) *
5176 ieee80211_queue_delayed_work(hw
, &wlvif
->channel_switch_work
,
5177 usecs_to_jiffies(delay_usec
) +
5178 msecs_to_jiffies(5000));
5182 wl1271_ps_elp_sleep(wl
);
5185 mutex_unlock(&wl
->mutex
);
5188 static void wlcore_op_flush(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
5189 u32 queues
, bool drop
)
5191 struct wl1271
*wl
= hw
->priv
;
5193 wl1271_tx_flush(wl
);
5196 static int wlcore_op_remain_on_channel(struct ieee80211_hw
*hw
,
5197 struct ieee80211_vif
*vif
,
5198 struct ieee80211_channel
*chan
,
5200 enum ieee80211_roc_type type
)
5202 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5203 struct wl1271
*wl
= hw
->priv
;
5204 int channel
, ret
= 0;
5206 channel
= ieee80211_frequency_to_channel(chan
->center_freq
);
5208 wl1271_debug(DEBUG_MAC80211
, "mac80211 roc %d (%d)",
5209 channel
, wlvif
->role_id
);
5211 mutex_lock(&wl
->mutex
);
5213 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5216 /* return EBUSY if we can't ROC right now */
5217 if (WARN_ON(wl
->roc_vif
||
5218 find_first_bit(wl
->roc_map
,
5219 WL12XX_MAX_ROLES
) < WL12XX_MAX_ROLES
)) {
5224 ret
= wl1271_ps_elp_wakeup(wl
);
5228 ret
= wl12xx_start_dev(wl
, wlvif
, chan
->band
, channel
);
5233 ieee80211_queue_delayed_work(hw
, &wl
->roc_complete_work
,
5234 msecs_to_jiffies(duration
));
5236 wl1271_ps_elp_sleep(wl
);
5238 mutex_unlock(&wl
->mutex
);
5242 static int __wlcore_roc_completed(struct wl1271
*wl
)
5244 struct wl12xx_vif
*wlvif
;
5247 /* already completed */
5248 if (unlikely(!wl
->roc_vif
))
5251 wlvif
= wl12xx_vif_to_data(wl
->roc_vif
);
5253 if (!test_bit(WLVIF_FLAG_INITIALIZED
, &wlvif
->flags
))
5256 ret
= wl12xx_stop_dev(wl
, wlvif
);
5265 static int wlcore_roc_completed(struct wl1271
*wl
)
5269 wl1271_debug(DEBUG_MAC80211
, "roc complete");
5271 mutex_lock(&wl
->mutex
);
5273 if (unlikely(wl
->state
!= WLCORE_STATE_ON
)) {
5278 ret
= wl1271_ps_elp_wakeup(wl
);
5282 ret
= __wlcore_roc_completed(wl
);
5284 wl1271_ps_elp_sleep(wl
);
5286 mutex_unlock(&wl
->mutex
);
5291 static void wlcore_roc_complete_work(struct work_struct
*work
)
5293 struct delayed_work
*dwork
;
5297 dwork
= container_of(work
, struct delayed_work
, work
);
5298 wl
= container_of(dwork
, struct wl1271
, roc_complete_work
);
5300 ret
= wlcore_roc_completed(wl
);
5302 ieee80211_remain_on_channel_expired(wl
->hw
);
5305 static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw
*hw
)
5307 struct wl1271
*wl
= hw
->priv
;
5309 wl1271_debug(DEBUG_MAC80211
, "mac80211 croc");
5312 wl1271_tx_flush(wl
);
5315 * we can't just flush_work here, because it might deadlock
5316 * (as we might get called from the same workqueue)
5318 cancel_delayed_work_sync(&wl
->roc_complete_work
);
5319 wlcore_roc_completed(wl
);
5324 static void wlcore_op_sta_rc_update(struct ieee80211_hw
*hw
,
5325 struct ieee80211_vif
*vif
,
5326 struct ieee80211_sta
*sta
,
5329 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5330 struct wl1271
*wl
= hw
->priv
;
5332 wlcore_hw_sta_rc_update(wl
, wlvif
, sta
, changed
);
5335 static int wlcore_op_get_rssi(struct ieee80211_hw
*hw
,
5336 struct ieee80211_vif
*vif
,
5337 struct ieee80211_sta
*sta
,
5340 struct wl1271
*wl
= hw
->priv
;
5341 struct wl12xx_vif
*wlvif
= wl12xx_vif_to_data(vif
);
5344 wl1271_debug(DEBUG_MAC80211
, "mac80211 get_rssi");
5346 mutex_lock(&wl
->mutex
);
5348 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5351 ret
= wl1271_ps_elp_wakeup(wl
);
5355 ret
= wlcore_acx_average_rssi(wl
, wlvif
, rssi_dbm
);
5360 wl1271_ps_elp_sleep(wl
);
5363 mutex_unlock(&wl
->mutex
);
5368 static bool wl1271_tx_frames_pending(struct ieee80211_hw
*hw
)
5370 struct wl1271
*wl
= hw
->priv
;
5373 mutex_lock(&wl
->mutex
);
5375 if (unlikely(wl
->state
!= WLCORE_STATE_ON
))
5378 /* packets are considered pending if in the TX queue or the FW */
5379 ret
= (wl1271_tx_total_queue_count(wl
) > 0) || (wl
->tx_frames_cnt
> 0);
5381 mutex_unlock(&wl
->mutex
);
5386 /* can't be const, mac80211 writes to this */
5387 static struct ieee80211_rate wl1271_rates
[] = {
5389 .hw_value
= CONF_HW_BIT_RATE_1MBPS
,
5390 .hw_value_short
= CONF_HW_BIT_RATE_1MBPS
, },
5392 .hw_value
= CONF_HW_BIT_RATE_2MBPS
,
5393 .hw_value_short
= CONF_HW_BIT_RATE_2MBPS
,
5394 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5396 .hw_value
= CONF_HW_BIT_RATE_5_5MBPS
,
5397 .hw_value_short
= CONF_HW_BIT_RATE_5_5MBPS
,
5398 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5400 .hw_value
= CONF_HW_BIT_RATE_11MBPS
,
5401 .hw_value_short
= CONF_HW_BIT_RATE_11MBPS
,
5402 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
5404 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
5405 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
5407 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
5408 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
5410 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
5411 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
5413 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
5414 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
5416 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
5417 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
5419 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
5420 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
5422 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
5423 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
5425 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
5426 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
5429 /* can't be const, mac80211 writes to this */
5430 static struct ieee80211_channel wl1271_channels
[] = {
5431 { .hw_value
= 1, .center_freq
= 2412, .max_power
= WLCORE_MAX_TXPWR
},
5432 { .hw_value
= 2, .center_freq
= 2417, .max_power
= WLCORE_MAX_TXPWR
},
5433 { .hw_value
= 3, .center_freq
= 2422, .max_power
= WLCORE_MAX_TXPWR
},
5434 { .hw_value
= 4, .center_freq
= 2427, .max_power
= WLCORE_MAX_TXPWR
},
5435 { .hw_value
= 5, .center_freq
= 2432, .max_power
= WLCORE_MAX_TXPWR
},
5436 { .hw_value
= 6, .center_freq
= 2437, .max_power
= WLCORE_MAX_TXPWR
},
5437 { .hw_value
= 7, .center_freq
= 2442, .max_power
= WLCORE_MAX_TXPWR
},
5438 { .hw_value
= 8, .center_freq
= 2447, .max_power
= WLCORE_MAX_TXPWR
},
5439 { .hw_value
= 9, .center_freq
= 2452, .max_power
= WLCORE_MAX_TXPWR
},
5440 { .hw_value
= 10, .center_freq
= 2457, .max_power
= WLCORE_MAX_TXPWR
},
5441 { .hw_value
= 11, .center_freq
= 2462, .max_power
= WLCORE_MAX_TXPWR
},
5442 { .hw_value
= 12, .center_freq
= 2467, .max_power
= WLCORE_MAX_TXPWR
},
5443 { .hw_value
= 13, .center_freq
= 2472, .max_power
= WLCORE_MAX_TXPWR
},
5444 { .hw_value
= 14, .center_freq
= 2484, .max_power
= WLCORE_MAX_TXPWR
},
5447 /* can't be const, mac80211 writes to this */
5448 static struct ieee80211_supported_band wl1271_band_2ghz
= {
5449 .channels
= wl1271_channels
,
5450 .n_channels
= ARRAY_SIZE(wl1271_channels
),
5451 .bitrates
= wl1271_rates
,
5452 .n_bitrates
= ARRAY_SIZE(wl1271_rates
),
5455 /* 5 GHz data rates for WL1273 */
5456 static struct ieee80211_rate wl1271_rates_5ghz
[] = {
5458 .hw_value
= CONF_HW_BIT_RATE_6MBPS
,
5459 .hw_value_short
= CONF_HW_BIT_RATE_6MBPS
, },
5461 .hw_value
= CONF_HW_BIT_RATE_9MBPS
,
5462 .hw_value_short
= CONF_HW_BIT_RATE_9MBPS
, },
5464 .hw_value
= CONF_HW_BIT_RATE_12MBPS
,
5465 .hw_value_short
= CONF_HW_BIT_RATE_12MBPS
, },
5467 .hw_value
= CONF_HW_BIT_RATE_18MBPS
,
5468 .hw_value_short
= CONF_HW_BIT_RATE_18MBPS
, },
5470 .hw_value
= CONF_HW_BIT_RATE_24MBPS
,
5471 .hw_value_short
= CONF_HW_BIT_RATE_24MBPS
, },
5473 .hw_value
= CONF_HW_BIT_RATE_36MBPS
,
5474 .hw_value_short
= CONF_HW_BIT_RATE_36MBPS
, },
5476 .hw_value
= CONF_HW_BIT_RATE_48MBPS
,
5477 .hw_value_short
= CONF_HW_BIT_RATE_48MBPS
, },
5479 .hw_value
= CONF_HW_BIT_RATE_54MBPS
,
5480 .hw_value_short
= CONF_HW_BIT_RATE_54MBPS
, },
5483 /* 5 GHz band channels for WL1273 */
5484 static struct ieee80211_channel wl1271_channels_5ghz
[] = {
5485 { .hw_value
= 8, .center_freq
= 5040, .max_power
= WLCORE_MAX_TXPWR
},
5486 { .hw_value
= 12, .center_freq
= 5060, .max_power
= WLCORE_MAX_TXPWR
},
5487 { .hw_value
= 16, .center_freq
= 5080, .max_power
= WLCORE_MAX_TXPWR
},
5488 { .hw_value
= 34, .center_freq
= 5170, .max_power
= WLCORE_MAX_TXPWR
},
5489 { .hw_value
= 36, .center_freq
= 5180, .max_power
= WLCORE_MAX_TXPWR
},
5490 { .hw_value
= 38, .center_freq
= 5190, .max_power
= WLCORE_MAX_TXPWR
},
5491 { .hw_value
= 40, .center_freq
= 5200, .max_power
= WLCORE_MAX_TXPWR
},
5492 { .hw_value
= 42, .center_freq
= 5210, .max_power
= WLCORE_MAX_TXPWR
},
5493 { .hw_value
= 44, .center_freq
= 5220, .max_power
= WLCORE_MAX_TXPWR
},
5494 { .hw_value
= 46, .center_freq
= 5230, .max_power
= WLCORE_MAX_TXPWR
},
5495 { .hw_value
= 48, .center_freq
= 5240, .max_power
= WLCORE_MAX_TXPWR
},
5496 { .hw_value
= 52, .center_freq
= 5260, .max_power
= WLCORE_MAX_TXPWR
},
5497 { .hw_value
= 56, .center_freq
= 5280, .max_power
= WLCORE_MAX_TXPWR
},
5498 { .hw_value
= 60, .center_freq
= 5300, .max_power
= WLCORE_MAX_TXPWR
},
5499 { .hw_value
= 64, .center_freq
= 5320, .max_power
= WLCORE_MAX_TXPWR
},
5500 { .hw_value
= 100, .center_freq
= 5500, .max_power
= WLCORE_MAX_TXPWR
},
5501 { .hw_value
= 104, .center_freq
= 5520, .max_power
= WLCORE_MAX_TXPWR
},
5502 { .hw_value
= 108, .center_freq
= 5540, .max_power
= WLCORE_MAX_TXPWR
},
5503 { .hw_value
= 112, .center_freq
= 5560, .max_power
= WLCORE_MAX_TXPWR
},
5504 { .hw_value
= 116, .center_freq
= 5580, .max_power
= WLCORE_MAX_TXPWR
},
5505 { .hw_value
= 120, .center_freq
= 5600, .max_power
= WLCORE_MAX_TXPWR
},
5506 { .hw_value
= 124, .center_freq
= 5620, .max_power
= WLCORE_MAX_TXPWR
},
5507 { .hw_value
= 128, .center_freq
= 5640, .max_power
= WLCORE_MAX_TXPWR
},
5508 { .hw_value
= 132, .center_freq
= 5660, .max_power
= WLCORE_MAX_TXPWR
},
5509 { .hw_value
= 136, .center_freq
= 5680, .max_power
= WLCORE_MAX_TXPWR
},
5510 { .hw_value
= 140, .center_freq
= 5700, .max_power
= WLCORE_MAX_TXPWR
},
5511 { .hw_value
= 149, .center_freq
= 5745, .max_power
= WLCORE_MAX_TXPWR
},
5512 { .hw_value
= 153, .center_freq
= 5765, .max_power
= WLCORE_MAX_TXPWR
},
5513 { .hw_value
= 157, .center_freq
= 5785, .max_power
= WLCORE_MAX_TXPWR
},
5514 { .hw_value
= 161, .center_freq
= 5805, .max_power
= WLCORE_MAX_TXPWR
},
5515 { .hw_value
= 165, .center_freq
= 5825, .max_power
= WLCORE_MAX_TXPWR
},
5518 static struct ieee80211_supported_band wl1271_band_5ghz
= {
5519 .channels
= wl1271_channels_5ghz
,
5520 .n_channels
= ARRAY_SIZE(wl1271_channels_5ghz
),
5521 .bitrates
= wl1271_rates_5ghz
,
5522 .n_bitrates
= ARRAY_SIZE(wl1271_rates_5ghz
),
5525 static const struct ieee80211_ops wl1271_ops
= {
5526 .start
= wl1271_op_start
,
5527 .stop
= wlcore_op_stop
,
5528 .add_interface
= wl1271_op_add_interface
,
5529 .remove_interface
= wl1271_op_remove_interface
,
5530 .change_interface
= wl12xx_op_change_interface
,
5532 .suspend
= wl1271_op_suspend
,
5533 .resume
= wl1271_op_resume
,
5535 .config
= wl1271_op_config
,
5536 .prepare_multicast
= wl1271_op_prepare_multicast
,
5537 .configure_filter
= wl1271_op_configure_filter
,
5539 .set_key
= wlcore_op_set_key
,
5540 .hw_scan
= wl1271_op_hw_scan
,
5541 .cancel_hw_scan
= wl1271_op_cancel_hw_scan
,
5542 .sched_scan_start
= wl1271_op_sched_scan_start
,
5543 .sched_scan_stop
= wl1271_op_sched_scan_stop
,
5544 .bss_info_changed
= wl1271_op_bss_info_changed
,
5545 .set_frag_threshold
= wl1271_op_set_frag_threshold
,
5546 .set_rts_threshold
= wl1271_op_set_rts_threshold
,
5547 .conf_tx
= wl1271_op_conf_tx
,
5548 .get_tsf
= wl1271_op_get_tsf
,
5549 .get_survey
= wl1271_op_get_survey
,
5550 .sta_state
= wl12xx_op_sta_state
,
5551 .ampdu_action
= wl1271_op_ampdu_action
,
5552 .tx_frames_pending
= wl1271_tx_frames_pending
,
5553 .set_bitrate_mask
= wl12xx_set_bitrate_mask
,
5554 .set_default_unicast_key
= wl1271_op_set_default_key_idx
,
5555 .channel_switch
= wl12xx_op_channel_switch
,
5556 .flush
= wlcore_op_flush
,
5557 .remain_on_channel
= wlcore_op_remain_on_channel
,
5558 .cancel_remain_on_channel
= wlcore_op_cancel_remain_on_channel
,
5559 .add_chanctx
= wlcore_op_add_chanctx
,
5560 .remove_chanctx
= wlcore_op_remove_chanctx
,
5561 .change_chanctx
= wlcore_op_change_chanctx
,
5562 .assign_vif_chanctx
= wlcore_op_assign_vif_chanctx
,
5563 .unassign_vif_chanctx
= wlcore_op_unassign_vif_chanctx
,
5564 .sta_rc_update
= wlcore_op_sta_rc_update
,
5565 .get_rssi
= wlcore_op_get_rssi
,
5566 CFG80211_TESTMODE_CMD(wl1271_tm_cmd
)
5570 u8
wlcore_rate_to_idx(struct wl1271
*wl
, u8 rate
, enum ieee80211_band band
)
5576 if (unlikely(rate
>= wl
->hw_tx_rate_tbl_size
)) {
5577 wl1271_error("Illegal RX rate from HW: %d", rate
);
5581 idx
= wl
->band_rate_to_idx
[band
][rate
];
5582 if (unlikely(idx
== CONF_HW_RXTX_RATE_UNSUPPORTED
)) {
5583 wl1271_error("Unsupported RX rate from HW: %d", rate
);
5590 static void wl12xx_derive_mac_addresses(struct wl1271
*wl
, u32 oui
, u32 nic
)
5594 wl1271_debug(DEBUG_PROBE
, "base address: oui %06x nic %06x",
5597 if (nic
+ WLCORE_NUM_MAC_ADDRESSES
- wl
->num_mac_addr
> 0xffffff)
5598 wl1271_warning("NIC part of the MAC address wraps around!");
5600 for (i
= 0; i
< wl
->num_mac_addr
; i
++) {
5601 wl
->addresses
[i
].addr
[0] = (u8
)(oui
>> 16);
5602 wl
->addresses
[i
].addr
[1] = (u8
)(oui
>> 8);
5603 wl
->addresses
[i
].addr
[2] = (u8
) oui
;
5604 wl
->addresses
[i
].addr
[3] = (u8
)(nic
>> 16);
5605 wl
->addresses
[i
].addr
[4] = (u8
)(nic
>> 8);
5606 wl
->addresses
[i
].addr
[5] = (u8
) nic
;
5610 /* we may be one address short at the most */
5611 WARN_ON(wl
->num_mac_addr
+ 1 < WLCORE_NUM_MAC_ADDRESSES
);
5614 * turn on the LAA bit in the first address and use it as
5617 if (wl
->num_mac_addr
< WLCORE_NUM_MAC_ADDRESSES
) {
5618 int idx
= WLCORE_NUM_MAC_ADDRESSES
- 1;
5619 memcpy(&wl
->addresses
[idx
], &wl
->addresses
[0],
5620 sizeof(wl
->addresses
[0]));
5622 wl
->addresses
[idx
].addr
[2] |= BIT(1);
5625 wl
->hw
->wiphy
->n_addresses
= WLCORE_NUM_MAC_ADDRESSES
;
5626 wl
->hw
->wiphy
->addresses
= wl
->addresses
;
5629 static int wl12xx_get_hw_info(struct wl1271
*wl
)
5633 ret
= wl12xx_set_power_on(wl
);
5637 ret
= wlcore_read_reg(wl
, REG_CHIP_ID_B
, &wl
->chip
.id
);
5641 wl
->fuse_oui_addr
= 0;
5642 wl
->fuse_nic_addr
= 0;
5644 ret
= wl
->ops
->get_pg_ver(wl
, &wl
->hw_pg_ver
);
5648 if (wl
->ops
->get_mac
)
5649 ret
= wl
->ops
->get_mac(wl
);
5652 wl1271_power_off(wl
);
5656 static int wl1271_register_hw(struct wl1271
*wl
)
5659 u32 oui_addr
= 0, nic_addr
= 0;
5661 if (wl
->mac80211_registered
)
5664 if (wl
->nvs_len
>= 12) {
5665 /* NOTE: The wl->nvs->nvs element must be first, in
5666 * order to simplify the casting, we assume it is at
5667 * the beginning of the wl->nvs structure.
5669 u8
*nvs_ptr
= (u8
*)wl
->nvs
;
5672 (nvs_ptr
[11] << 16) + (nvs_ptr
[10] << 8) + nvs_ptr
[6];
5674 (nvs_ptr
[5] << 16) + (nvs_ptr
[4] << 8) + nvs_ptr
[3];
5677 /* if the MAC address is zeroed in the NVS derive from fuse */
5678 if (oui_addr
== 0 && nic_addr
== 0) {
5679 oui_addr
= wl
->fuse_oui_addr
;
5680 /* fuse has the BD_ADDR, the WLAN addresses are the next two */
5681 nic_addr
= wl
->fuse_nic_addr
+ 1;
5684 wl12xx_derive_mac_addresses(wl
, oui_addr
, nic_addr
);
5686 ret
= ieee80211_register_hw(wl
->hw
);
5688 wl1271_error("unable to register mac80211 hw: %d", ret
);
5692 wl
->mac80211_registered
= true;
5694 wl1271_debugfs_init(wl
);
5696 wl1271_notice("loaded");
5702 static void wl1271_unregister_hw(struct wl1271
*wl
)
5705 wl1271_plt_stop(wl
);
5707 ieee80211_unregister_hw(wl
->hw
);
5708 wl
->mac80211_registered
= false;
5712 static int wl1271_init_ieee80211(struct wl1271
*wl
)
5715 static const u32 cipher_suites
[] = {
5716 WLAN_CIPHER_SUITE_WEP40
,
5717 WLAN_CIPHER_SUITE_WEP104
,
5718 WLAN_CIPHER_SUITE_TKIP
,
5719 WLAN_CIPHER_SUITE_CCMP
,
5720 WL1271_CIPHER_SUITE_GEM
,
5723 /* The tx descriptor buffer */
5724 wl
->hw
->extra_tx_headroom
= sizeof(struct wl1271_tx_hw_descr
);
5726 if (wl
->quirks
& WLCORE_QUIRK_TKIP_HEADER_SPACE
)
5727 wl
->hw
->extra_tx_headroom
+= WL1271_EXTRA_SPACE_TKIP
;
5730 /* FIXME: find a proper value */
5731 wl
->hw
->max_listen_interval
= wl
->conf
.conn
.max_listen_interval
;
5733 wl
->hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
5734 IEEE80211_HW_SUPPORTS_PS
|
5735 IEEE80211_HW_SUPPORTS_DYNAMIC_PS
|
5736 IEEE80211_HW_SUPPORTS_UAPSD
|
5737 IEEE80211_HW_HAS_RATE_CONTROL
|
5738 IEEE80211_HW_CONNECTION_MONITOR
|
5739 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
5740 IEEE80211_HW_SPECTRUM_MGMT
|
5741 IEEE80211_HW_AP_LINK_PS
|
5742 IEEE80211_HW_AMPDU_AGGREGATION
|
5743 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW
|
5744 IEEE80211_HW_QUEUE_CONTROL
|
5745 IEEE80211_HW_CHANCTX_STA_CSA
;
5747 wl
->hw
->wiphy
->cipher_suites
= cipher_suites
;
5748 wl
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
5750 wl
->hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
5751 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
) |
5752 BIT(NL80211_IFTYPE_P2P_CLIENT
) | BIT(NL80211_IFTYPE_P2P_GO
);
5753 wl
->hw
->wiphy
->max_scan_ssids
= 1;
5754 wl
->hw
->wiphy
->max_sched_scan_ssids
= 16;
5755 wl
->hw
->wiphy
->max_match_sets
= 16;
5757 * Maximum length of elements in scanning probe request templates
5758 * should be the maximum length possible for a template, without
5759 * the IEEE80211 header of the template
5761 wl
->hw
->wiphy
->max_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
5762 sizeof(struct ieee80211_header
);
5764 wl
->hw
->wiphy
->max_sched_scan_ie_len
= WL1271_CMD_TEMPL_MAX_SIZE
-
5765 sizeof(struct ieee80211_header
);
5767 wl
->hw
->wiphy
->max_remain_on_channel_duration
= 5000;
5769 wl
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
|
5770 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
|
5771 WIPHY_FLAG_SUPPORTS_SCHED_SCAN
;
5773 /* make sure all our channels fit in the scanned_ch bitmask */
5774 BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels
) +
5775 ARRAY_SIZE(wl1271_channels_5ghz
) >
5776 WL1271_MAX_CHANNELS
);
5778 * clear channel flags from the previous usage
5779 * and restore max_power & max_antenna_gain values.
5781 for (i
= 0; i
< ARRAY_SIZE(wl1271_channels
); i
++) {
5782 wl1271_band_2ghz
.channels
[i
].flags
= 0;
5783 wl1271_band_2ghz
.channels
[i
].max_power
= WLCORE_MAX_TXPWR
;
5784 wl1271_band_2ghz
.channels
[i
].max_antenna_gain
= 0;
5787 for (i
= 0; i
< ARRAY_SIZE(wl1271_channels_5ghz
); i
++) {
5788 wl1271_band_5ghz
.channels
[i
].flags
= 0;
5789 wl1271_band_5ghz
.channels
[i
].max_power
= WLCORE_MAX_TXPWR
;
5790 wl1271_band_5ghz
.channels
[i
].max_antenna_gain
= 0;
5794 * We keep local copies of the band structs because we need to
5795 * modify them on a per-device basis.
5797 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
], &wl1271_band_2ghz
,
5798 sizeof(wl1271_band_2ghz
));
5799 memcpy(&wl
->bands
[IEEE80211_BAND_2GHZ
].ht_cap
,
5800 &wl
->ht_cap
[IEEE80211_BAND_2GHZ
],
5801 sizeof(*wl
->ht_cap
));
5802 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
], &wl1271_band_5ghz
,
5803 sizeof(wl1271_band_5ghz
));
5804 memcpy(&wl
->bands
[IEEE80211_BAND_5GHZ
].ht_cap
,
5805 &wl
->ht_cap
[IEEE80211_BAND_5GHZ
],
5806 sizeof(*wl
->ht_cap
));
5808 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
5809 &wl
->bands
[IEEE80211_BAND_2GHZ
];
5810 wl
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
5811 &wl
->bands
[IEEE80211_BAND_5GHZ
];
5814 * allow 4 queues per mac address we support +
5815 * 1 cab queue per mac + one global offchannel Tx queue
5817 wl
->hw
->queues
= (NUM_TX_QUEUES
+ 1) * WLCORE_NUM_MAC_ADDRESSES
+ 1;
5819 /* the last queue is the offchannel queue */
5820 wl
->hw
->offchannel_tx_hw_queue
= wl
->hw
->queues
- 1;
5821 wl
->hw
->max_rates
= 1;
5823 wl
->hw
->wiphy
->reg_notifier
= wl1271_reg_notify
;
5825 /* the FW answers probe-requests in AP-mode */
5826 wl
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
;
5827 wl
->hw
->wiphy
->probe_resp_offload
=
5828 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS
|
5829 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2
|
5830 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P
;
5832 /* allowed interface combinations */
5833 wl
->hw
->wiphy
->iface_combinations
= wl
->iface_combinations
;
5834 wl
->hw
->wiphy
->n_iface_combinations
= wl
->n_iface_combinations
;
5836 SET_IEEE80211_DEV(wl
->hw
, wl
->dev
);
5838 wl
->hw
->sta_data_size
= sizeof(struct wl1271_station
);
5839 wl
->hw
->vif_data_size
= sizeof(struct wl12xx_vif
);
5841 wl
->hw
->max_rx_aggregation_subframes
= wl
->conf
.ht
.rx_ba_win_size
;
5846 struct ieee80211_hw
*wlcore_alloc_hw(size_t priv_size
, u32 aggr_buf_size
,
5849 struct ieee80211_hw
*hw
;
5854 hw
= ieee80211_alloc_hw(sizeof(*wl
), &wl1271_ops
);
5856 wl1271_error("could not alloc ieee80211_hw");
5862 memset(wl
, 0, sizeof(*wl
));
5864 wl
->priv
= kzalloc(priv_size
, GFP_KERNEL
);
5866 wl1271_error("could not alloc wl priv");
5868 goto err_priv_alloc
;
5871 INIT_LIST_HEAD(&wl
->wlvif_list
);
5876 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS.
5877 * we don't allocate any additional resource here, so that's fine.
5879 for (i
= 0; i
< NUM_TX_QUEUES
; i
++)
5880 for (j
= 0; j
< WLCORE_MAX_LINKS
; j
++)
5881 skb_queue_head_init(&wl
->links
[j
].tx_queue
[i
]);
5883 skb_queue_head_init(&wl
->deferred_rx_queue
);
5884 skb_queue_head_init(&wl
->deferred_tx_queue
);
5886 INIT_DELAYED_WORK(&wl
->elp_work
, wl1271_elp_work
);
5887 INIT_WORK(&wl
->netstack_work
, wl1271_netstack_work
);
5888 INIT_WORK(&wl
->tx_work
, wl1271_tx_work
);
5889 INIT_WORK(&wl
->recovery_work
, wl1271_recovery_work
);
5890 INIT_DELAYED_WORK(&wl
->scan_complete_work
, wl1271_scan_complete_work
);
5891 INIT_DELAYED_WORK(&wl
->roc_complete_work
, wlcore_roc_complete_work
);
5892 INIT_DELAYED_WORK(&wl
->tx_watchdog_work
, wl12xx_tx_watchdog_work
);
5894 wl
->freezable_wq
= create_freezable_workqueue("wl12xx_wq");
5895 if (!wl
->freezable_wq
) {
5902 wl
->power_level
= WL1271_DEFAULT_POWER_LEVEL
;
5903 wl
->band
= IEEE80211_BAND_2GHZ
;
5904 wl
->channel_type
= NL80211_CHAN_NO_HT
;
5906 wl
->sg_enabled
= true;
5907 wl
->sleep_auth
= WL1271_PSM_ILLEGAL
;
5908 wl
->recovery_count
= 0;
5911 wl
->ap_fw_ps_map
= 0;
5913 wl
->platform_quirks
= 0;
5914 wl
->system_hlid
= WL12XX_SYSTEM_HLID
;
5915 wl
->active_sta_count
= 0;
5916 wl
->active_link_count
= 0;
5918 init_waitqueue_head(&wl
->fwlog_waitq
);
5920 /* The system link is always allocated */
5921 __set_bit(WL12XX_SYSTEM_HLID
, wl
->links_map
);
5923 memset(wl
->tx_frames_map
, 0, sizeof(wl
->tx_frames_map
));
5924 for (i
= 0; i
< wl
->num_tx_desc
; i
++)
5925 wl
->tx_frames
[i
] = NULL
;
5927 spin_lock_init(&wl
->wl_lock
);
5929 wl
->state
= WLCORE_STATE_OFF
;
5930 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
5931 mutex_init(&wl
->mutex
);
5932 mutex_init(&wl
->flush_mutex
);
5933 init_completion(&wl
->nvs_loading_complete
);
5935 order
= get_order(aggr_buf_size
);
5936 wl
->aggr_buf
= (u8
*)__get_free_pages(GFP_KERNEL
, order
);
5937 if (!wl
->aggr_buf
) {
5941 wl
->aggr_buf_size
= aggr_buf_size
;
5943 wl
->dummy_packet
= wl12xx_alloc_dummy_packet(wl
);
5944 if (!wl
->dummy_packet
) {
5949 /* Allocate one page for the FW log */
5950 wl
->fwlog
= (u8
*)get_zeroed_page(GFP_KERNEL
);
5953 goto err_dummy_packet
;
5956 wl
->mbox_size
= mbox_size
;
5957 wl
->mbox
= kmalloc(wl
->mbox_size
, GFP_KERNEL
| GFP_DMA
);
5963 wl
->buffer_32
= kmalloc(sizeof(*wl
->buffer_32
), GFP_KERNEL
);
5964 if (!wl
->buffer_32
) {
5975 free_page((unsigned long)wl
->fwlog
);
5978 dev_kfree_skb(wl
->dummy_packet
);
5981 free_pages((unsigned long)wl
->aggr_buf
, order
);
5984 destroy_workqueue(wl
->freezable_wq
);
5987 wl1271_debugfs_exit(wl
);
5991 ieee80211_free_hw(hw
);
5995 return ERR_PTR(ret
);
5997 EXPORT_SYMBOL_GPL(wlcore_alloc_hw
);
5999 int wlcore_free_hw(struct wl1271
*wl
)
6001 /* Unblock any fwlog readers */
6002 mutex_lock(&wl
->mutex
);
6003 wl
->fwlog_size
= -1;
6004 wake_up_interruptible_all(&wl
->fwlog_waitq
);
6005 mutex_unlock(&wl
->mutex
);
6007 wlcore_sysfs_free(wl
);
6009 kfree(wl
->buffer_32
);
6011 free_page((unsigned long)wl
->fwlog
);
6012 dev_kfree_skb(wl
->dummy_packet
);
6013 free_pages((unsigned long)wl
->aggr_buf
, get_order(wl
->aggr_buf_size
));
6015 wl1271_debugfs_exit(wl
);
6019 wl
->fw_type
= WL12XX_FW_TYPE_NONE
;
6023 kfree(wl
->raw_fw_status
);
6024 kfree(wl
->fw_status
);
6025 kfree(wl
->tx_res_if
);
6026 destroy_workqueue(wl
->freezable_wq
);
6029 ieee80211_free_hw(wl
->hw
);
6033 EXPORT_SYMBOL_GPL(wlcore_free_hw
);
6036 static const struct wiphy_wowlan_support wlcore_wowlan_support
= {
6037 .flags
= WIPHY_WOWLAN_ANY
,
6038 .n_patterns
= WL1271_MAX_RX_FILTERS
,
6039 .pattern_min_len
= 1,
6040 .pattern_max_len
= WL1271_RX_FILTER_MAX_PATTERN_SIZE
,
6044 static irqreturn_t
wlcore_hardirq(int irq
, void *cookie
)
6046 return IRQ_WAKE_THREAD
;
6049 static void wlcore_nvs_cb(const struct firmware
*fw
, void *context
)
6051 struct wl1271
*wl
= context
;
6052 struct platform_device
*pdev
= wl
->pdev
;
6053 struct wlcore_platdev_data
*pdev_data
= dev_get_platdata(&pdev
->dev
);
6054 struct wl12xx_platform_data
*pdata
= pdev_data
->pdata
;
6055 unsigned long irqflags
;
6057 irq_handler_t hardirq_fn
= NULL
;
6060 wl
->nvs
= kmemdup(fw
->data
, fw
->size
, GFP_KERNEL
);
6062 wl1271_error("Could not allocate nvs data");
6065 wl
->nvs_len
= fw
->size
;
6067 wl1271_debug(DEBUG_BOOT
, "Could not get nvs file %s",
6073 ret
= wl
->ops
->setup(wl
);
6077 BUG_ON(wl
->num_tx_desc
> WLCORE_MAX_TX_DESCRIPTORS
);
6079 /* adjust some runtime configuration parameters */
6080 wlcore_adjust_conf(wl
);
6082 wl
->irq
= platform_get_irq(pdev
, 0);
6083 wl
->platform_quirks
= pdata
->platform_quirks
;
6084 wl
->if_ops
= pdev_data
->if_ops
;
6086 if (wl
->platform_quirks
& WL12XX_PLATFORM_QUIRK_EDGE_IRQ
) {
6087 irqflags
= IRQF_TRIGGER_RISING
;
6088 hardirq_fn
= wlcore_hardirq
;
6090 irqflags
= IRQF_TRIGGER_HIGH
| IRQF_ONESHOT
;
6093 ret
= request_threaded_irq(wl
->irq
, hardirq_fn
, wlcore_irq
,
6094 irqflags
, pdev
->name
, wl
);
6096 wl1271_error("request_irq() failed: %d", ret
);
6101 ret
= enable_irq_wake(wl
->irq
);
6103 wl
->irq_wake_enabled
= true;
6104 device_init_wakeup(wl
->dev
, 1);
6105 if (pdata
->pwr_in_suspend
)
6106 wl
->hw
->wiphy
->wowlan
= &wlcore_wowlan_support
;
6109 disable_irq(wl
->irq
);
6111 ret
= wl12xx_get_hw_info(wl
);
6113 wl1271_error("couldn't get hw info");
6117 ret
= wl
->ops
->identify_chip(wl
);
6121 ret
= wl1271_init_ieee80211(wl
);
6125 ret
= wl1271_register_hw(wl
);
6129 ret
= wlcore_sysfs_init(wl
);
6133 wl
->initialized
= true;
6137 wl1271_unregister_hw(wl
);
6140 free_irq(wl
->irq
, wl
);
6146 release_firmware(fw
);
6147 complete_all(&wl
->nvs_loading_complete
);
6150 int wlcore_probe(struct wl1271
*wl
, struct platform_device
*pdev
)
6154 if (!wl
->ops
|| !wl
->ptable
)
6157 wl
->dev
= &pdev
->dev
;
6159 platform_set_drvdata(pdev
, wl
);
6161 ret
= request_firmware_nowait(THIS_MODULE
, FW_ACTION_HOTPLUG
,
6162 WL12XX_NVS_NAME
, &pdev
->dev
, GFP_KERNEL
,
6165 wl1271_error("request_firmware_nowait failed: %d", ret
);
6166 complete_all(&wl
->nvs_loading_complete
);
6171 EXPORT_SYMBOL_GPL(wlcore_probe
);
6173 int wlcore_remove(struct platform_device
*pdev
)
6175 struct wl1271
*wl
= platform_get_drvdata(pdev
);
6177 wait_for_completion(&wl
->nvs_loading_complete
);
6178 if (!wl
->initialized
)
6181 if (wl
->irq_wake_enabled
) {
6182 device_init_wakeup(wl
->dev
, 0);
6183 disable_irq_wake(wl
->irq
);
6185 wl1271_unregister_hw(wl
);
6186 free_irq(wl
->irq
, wl
);
6191 EXPORT_SYMBOL_GPL(wlcore_remove
);
6193 u32 wl12xx_debug_level
= DEBUG_NONE
;
6194 EXPORT_SYMBOL_GPL(wl12xx_debug_level
);
6195 module_param_named(debug_level
, wl12xx_debug_level
, uint
, S_IRUSR
| S_IWUSR
);
6196 MODULE_PARM_DESC(debug_level
, "wl12xx debugging level");
6198 module_param_named(fwlog
, fwlog_param
, charp
, 0);
6199 MODULE_PARM_DESC(fwlog
,
6200 "FW logger options: continuous, ondemand, dbgpins or disable");
6202 module_param(fwlog_mem_blocks
, int, S_IRUSR
| S_IWUSR
);
6203 MODULE_PARM_DESC(fwlog_mem_blocks
, "fwlog mem_blocks");
6205 module_param(bug_on_recovery
, int, S_IRUSR
| S_IWUSR
);
6206 MODULE_PARM_DESC(bug_on_recovery
, "BUG() on fw recovery");
6208 module_param(no_recovery
, int, S_IRUSR
| S_IWUSR
);
6209 MODULE_PARM_DESC(no_recovery
, "Prevent HW recovery. FW will remain stuck.");
6211 MODULE_LICENSE("GPL");
6212 MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
6213 MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");
6214 MODULE_FIRMWARE(WL12XX_NVS_NAME
);