2 * Copyright (c) 2012 Qualcomm Atheros, Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <linux/kernel.h>
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/hardirq.h>
21 #include <net/ieee80211_radiotap.h>
22 #include <linux/if_arp.h>
23 #include <linux/moduleparam.h>
29 static bool rtap_include_phy_info
;
30 module_param(rtap_include_phy_info
, bool, S_IRUGO
);
31 MODULE_PARM_DESC(rtap_include_phy_info
,
32 " Include PHY info in the radiotap header, default - no");
34 static inline int wil_vring_is_empty(struct vring
*vring
)
36 return vring
->swhead
== vring
->swtail
;
39 static inline u32
wil_vring_next_tail(struct vring
*vring
)
41 return (vring
->swtail
+ 1) % vring
->size
;
44 static inline void wil_vring_advance_head(struct vring
*vring
, int n
)
46 vring
->swhead
= (vring
->swhead
+ n
) % vring
->size
;
49 static inline int wil_vring_is_full(struct vring
*vring
)
51 return wil_vring_next_tail(vring
) == vring
->swhead
;
54 * Available space in Tx Vring
56 static inline int wil_vring_avail_tx(struct vring
*vring
)
58 u32 swhead
= vring
->swhead
;
59 u32 swtail
= vring
->swtail
;
60 int used
= (vring
->size
+ swhead
- swtail
) % vring
->size
;
62 return vring
->size
- used
- 1;
65 static int wil_vring_alloc(struct wil6210_priv
*wil
, struct vring
*vring
)
67 struct device
*dev
= wil_to_dev(wil
);
68 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
71 BUILD_BUG_ON(sizeof(vring
->va
[0]) != 32);
75 vring
->ctx
= kzalloc(vring
->size
* sizeof(vring
->ctx
[0]), GFP_KERNEL
);
81 * vring->va should be aligned on its size rounded up to power of 2
82 * This is granted by the dma_alloc_coherent
84 vring
->va
= dma_alloc_coherent(dev
, sz
, &vring
->pa
, GFP_KERNEL
);
86 wil_err(wil
, "vring_alloc [%d] failed to alloc DMA mem\n",
92 /* initially, all descriptors are SW owned
93 * For Tx and Rx, ownership bit is at the same location, thus
96 for (i
= 0; i
< vring
->size
; i
++) {
97 volatile struct vring_tx_desc
*d
= &(vring
->va
[i
].tx
);
98 d
->dma
.status
= TX_DMA_STATUS_DU
;
101 wil_dbg_misc(wil
, "vring[%d] 0x%p:0x%016llx 0x%p\n", vring
->size
,
102 vring
->va
, (unsigned long long)vring
->pa
, vring
->ctx
);
107 static void wil_vring_free(struct wil6210_priv
*wil
, struct vring
*vring
,
110 struct device
*dev
= wil_to_dev(wil
);
111 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
113 while (!wil_vring_is_empty(vring
)) {
115 volatile struct vring_tx_desc
*d
=
116 &vring
->va
[vring
->swtail
].tx
;
117 dma_addr_t pa
= d
->dma
.addr_low
|
118 ((u64
)d
->dma
.addr_high
<< 32);
119 struct sk_buff
*skb
= vring
->ctx
[vring
->swtail
];
121 dma_unmap_single(dev
, pa
, d
->dma
.length
,
123 dev_kfree_skb_any(skb
);
124 vring
->ctx
[vring
->swtail
] = NULL
;
126 dma_unmap_page(dev
, pa
, d
->dma
.length
,
129 vring
->swtail
= wil_vring_next_tail(vring
);
131 volatile struct vring_rx_desc
*d
=
132 &vring
->va
[vring
->swtail
].rx
;
133 dma_addr_t pa
= d
->dma
.addr_low
|
134 ((u64
)d
->dma
.addr_high
<< 32);
135 struct sk_buff
*skb
= vring
->ctx
[vring
->swhead
];
136 dma_unmap_single(dev
, pa
, d
->dma
.length
,
139 wil_vring_advance_head(vring
, 1);
142 dma_free_coherent(dev
, sz
, (void *)vring
->va
, vring
->pa
);
150 * Allocate one skb for Rx VRING
152 * Safe to call from IRQ
154 static int wil_vring_alloc_skb(struct wil6210_priv
*wil
, struct vring
*vring
,
157 struct device
*dev
= wil_to_dev(wil
);
158 unsigned int sz
= RX_BUF_LEN
;
159 volatile struct vring_rx_desc
*d
= &(vring
->va
[i
].rx
);
163 struct sk_buff
*skb
= dev_alloc_skb(sz
+ headroom
);
167 skb_reserve(skb
, headroom
);
170 pa
= dma_map_single(dev
, skb
->data
, skb
->len
, DMA_FROM_DEVICE
);
171 if (unlikely(dma_mapping_error(dev
, pa
))) {
176 d
->dma
.d0
= BIT(9) | RX_DMA_D0_CMD_DMA_IT
;
177 d
->dma
.addr_low
= lower_32_bits(pa
);
178 d
->dma
.addr_high
= (u16
)upper_32_bits(pa
);
179 /* ip_length don't care */
181 /* error don't care */
182 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
190 * Adds radiotap header
192 * Any error indicated as "Bad FCS"
194 * Vendor data for 04:ce:14-1 (Wilocity-1) consists of:
195 * - Rx descriptor: 32 bytes
198 static void wil_rx_add_radiotap_header(struct wil6210_priv
*wil
,
200 volatile struct vring_rx_desc
*d
)
202 struct wireless_dev
*wdev
= wil
->wdev
;
203 struct wil6210_rtap
{
204 struct ieee80211_radiotap_header rthdr
;
205 /* fields should be in the order of bits in rthdr.it_present */
209 __le16 chnl_freq
__aligned(2);
216 struct wil6210_rtap_vendor
{
217 struct wil6210_rtap rtap
;
219 u8 vendor_oui
[3] __aligned(2);
224 struct wil6210_rtap_vendor
*rtap_vendor
;
225 int rtap_len
= sizeof(struct wil6210_rtap
);
226 int phy_length
= 0; /* phy info header size, bytes */
227 static char phy_data
[128];
228 struct ieee80211_channel
*ch
= wdev
->preset_chandef
.chan
;
230 if (rtap_include_phy_info
) {
231 rtap_len
= sizeof(*rtap_vendor
) + sizeof(*d
);
232 /* calculate additional length */
233 if (d
->dma
.status
& RX_DMA_STATUS_PHY_INFO
) {
235 * PHY info starts from 8-byte boundary
236 * there are 8-byte lines, last line may be partially
237 * written (HW bug), thus FW configures for last line
238 * to be excessive. Driver skips this last line.
240 int len
= min_t(int, 8 + sizeof(phy_data
),
241 wil_rxdesc_phy_length(d
));
243 void *p
= skb_tail_pointer(skb
);
244 void *pa
= PTR_ALIGN(p
, 8);
245 if (skb_tailroom(skb
) >= len
+ (pa
- p
)) {
246 phy_length
= len
- 8;
247 memcpy(phy_data
, pa
, phy_length
);
251 rtap_len
+= phy_length
;
254 if (skb_headroom(skb
) < rtap_len
&&
255 pskb_expand_head(skb
, rtap_len
, 0, GFP_ATOMIC
)) {
256 wil_err(wil
, "Unable to expand headrom to %d\n", rtap_len
);
260 rtap_vendor
= (void *)skb_push(skb
, rtap_len
);
261 memset(rtap_vendor
, 0, rtap_len
);
263 rtap_vendor
->rtap
.rthdr
.it_version
= PKTHDR_RADIOTAP_VERSION
;
264 rtap_vendor
->rtap
.rthdr
.it_len
= cpu_to_le16(rtap_len
);
265 rtap_vendor
->rtap
.rthdr
.it_present
= cpu_to_le32(
266 (1 << IEEE80211_RADIOTAP_FLAGS
) |
267 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
268 (1 << IEEE80211_RADIOTAP_MCS
));
269 if (d
->dma
.status
& RX_DMA_STATUS_ERROR
)
270 rtap_vendor
->rtap
.flags
|= IEEE80211_RADIOTAP_F_BADFCS
;
272 rtap_vendor
->rtap
.chnl_freq
= cpu_to_le16(ch
? ch
->center_freq
: 58320);
273 rtap_vendor
->rtap
.chnl_flags
= cpu_to_le16(0);
275 rtap_vendor
->rtap
.mcs_present
= IEEE80211_RADIOTAP_MCS_HAVE_MCS
;
276 rtap_vendor
->rtap
.mcs_flags
= 0;
277 rtap_vendor
->rtap
.mcs_index
= wil_rxdesc_mcs(d
);
279 if (rtap_include_phy_info
) {
280 rtap_vendor
->rtap
.rthdr
.it_present
|= cpu_to_le32(1 <<
281 IEEE80211_RADIOTAP_VENDOR_NAMESPACE
);
282 /* OUI for Wilocity 04:ce:14 */
283 rtap_vendor
->vendor_oui
[0] = 0x04;
284 rtap_vendor
->vendor_oui
[1] = 0xce;
285 rtap_vendor
->vendor_oui
[2] = 0x14;
286 rtap_vendor
->vendor_ns
= 1;
287 /* Rx descriptor + PHY data */
288 rtap_vendor
->vendor_skip
= cpu_to_le16(sizeof(*d
) +
290 memcpy(rtap_vendor
->vendor_data
, (void *)d
, sizeof(*d
));
291 memcpy(rtap_vendor
->vendor_data
+ sizeof(*d
), phy_data
,
297 * Fast swap in place between 2 registers
299 static void wil_swap_u16(u16
*a
, u16
*b
)
306 static void wil_swap_ethaddr(void *data
)
308 struct ethhdr
*eth
= data
;
309 u16
*s
= (u16
*)eth
->h_source
;
310 u16
*d
= (u16
*)eth
->h_dest
;
312 wil_swap_u16(s
++, d
++);
313 wil_swap_u16(s
++, d
++);
318 * reap 1 frame from @swhead
320 * Safe to call from IRQ
322 static struct sk_buff
*wil_vring_reap_rx(struct wil6210_priv
*wil
,
325 struct device
*dev
= wil_to_dev(wil
);
326 struct net_device
*ndev
= wil_to_ndev(wil
);
327 volatile struct vring_rx_desc
*d
;
330 unsigned int sz
= RX_BUF_LEN
;
334 if (wil_vring_is_empty(vring
))
337 d
= &(vring
->va
[vring
->swhead
].rx
);
338 if (!(d
->dma
.status
& RX_DMA_STATUS_DU
)) {
339 /* it is not error, we just reached end of Rx done area */
343 pa
= d
->dma
.addr_low
| ((u64
)d
->dma
.addr_high
<< 32);
344 skb
= vring
->ctx
[vring
->swhead
];
345 dma_unmap_single(dev
, pa
, sz
, DMA_FROM_DEVICE
);
346 skb_trim(skb
, d
->dma
.length
);
348 wil
->stats
.last_mcs_rx
= wil_rxdesc_mcs(d
);
350 /* use radiotap header only if required */
351 if (ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
)
352 wil_rx_add_radiotap_header(wil
, skb
, d
);
354 wil_dbg_txrx(wil
, "Rx[%3d] : %d bytes\n", vring
->swhead
, d
->dma
.length
);
355 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_NONE
, 32, 4,
356 (const void *)d
, sizeof(*d
), false);
358 wil_vring_advance_head(vring
, 1);
360 /* no extra checks if in sniffer mode */
361 if (ndev
->type
!= ARPHRD_ETHER
)
364 * Non-data frames may be delivered through Rx DMA channel (ex: BAR)
365 * Driver should recognize it by frame type, that is found
366 * in Rx descriptor. If type is not data, it is 802.11 frame as is
368 ftype
= wil_rxdesc_ftype(d
) << 2;
369 if (ftype
!= IEEE80211_FTYPE_DATA
) {
370 wil_dbg_txrx(wil
, "Non-data frame ftype 0x%08x\n", ftype
);
371 /* TODO: process it */
376 if (skb
->len
< ETH_HLEN
) {
377 wil_err(wil
, "Short frame, len = %d\n", skb
->len
);
378 /* TODO: process it (i.e. BAR) */
383 ds_bits
= wil_rxdesc_ds_bits(d
);
386 * HW bug - in ToDS mode, i.e. Rx on AP side,
387 * addresses get swapped
389 wil_swap_ethaddr(skb
->data
);
396 * allocate and fill up to @count buffers in rx ring
397 * buffers posted at @swtail
399 static int wil_rx_refill(struct wil6210_priv
*wil
, int count
)
401 struct net_device
*ndev
= wil_to_ndev(wil
);
402 struct vring
*v
= &wil
->vring_rx
;
405 int headroom
= ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
?
406 WIL6210_RTAP_SIZE
: 0;
408 for (; next_tail
= wil_vring_next_tail(v
),
409 (next_tail
!= v
->swhead
) && (count
-- > 0);
410 v
->swtail
= next_tail
) {
411 rc
= wil_vring_alloc_skb(wil
, v
, v
->swtail
, headroom
);
413 wil_err(wil
, "Error %d in wil_rx_refill[%d]\n",
418 iowrite32(v
->swtail
, wil
->csr
+ HOSTADDR(v
->hwtail
));
424 * Pass Rx packet to the netif. Update statistics.
426 static void wil_netif_rx_any(struct sk_buff
*skb
, struct net_device
*ndev
)
429 unsigned int len
= skb
->len
;
436 rc
= netif_rx_ni(skb
);
438 if (likely(rc
== NET_RX_SUCCESS
)) {
439 ndev
->stats
.rx_packets
++;
440 ndev
->stats
.rx_bytes
+= len
;
443 ndev
->stats
.rx_dropped
++;
448 * Proceed all completed skb's from Rx VRING
450 * Safe to call from IRQ
452 void wil_rx_handle(struct wil6210_priv
*wil
)
454 struct net_device
*ndev
= wil_to_ndev(wil
);
455 struct vring
*v
= &wil
->vring_rx
;
459 wil_err(wil
, "Rx IRQ while Rx not yet initialized\n");
462 wil_dbg_txrx(wil
, "%s()\n", __func__
);
463 while (NULL
!= (skb
= wil_vring_reap_rx(wil
, v
))) {
464 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_OFFSET
, 16, 1,
465 skb
->data
, skb_headlen(skb
), false);
467 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
469 skb_reset_mac_header(skb
);
470 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
471 skb
->pkt_type
= PACKET_OTHERHOST
;
472 skb
->protocol
= htons(ETH_P_802_2
);
475 skb
->protocol
= eth_type_trans(skb
, ndev
);
478 wil_netif_rx_any(skb
, ndev
);
480 wil_rx_refill(wil
, v
->size
);
483 int wil_rx_init(struct wil6210_priv
*wil
)
485 struct vring
*vring
= &wil
->vring_rx
;
488 vring
->size
= WIL6210_RX_RING_SIZE
;
489 rc
= wil_vring_alloc(wil
, vring
);
493 rc
= wmi_rx_chain_add(wil
, vring
);
497 rc
= wil_rx_refill(wil
, vring
->size
);
503 wil_vring_free(wil
, vring
, 0);
508 void wil_rx_fini(struct wil6210_priv
*wil
)
510 struct vring
*vring
= &wil
->vring_rx
;
513 wil_vring_free(wil
, vring
, 0);
516 int wil_vring_init_tx(struct wil6210_priv
*wil
, int id
, int size
,
520 struct wmi_vring_cfg_cmd cmd
= {
521 .action
= cpu_to_le32(WMI_VRING_CMD_ADD
),
524 .max_mpdu_size
= cpu_to_le16(TX_BUF_LEN
),
527 .cidxtid
= (cid
& 0xf) | ((tid
& 0xf) << 4),
528 .encap_trans_type
= WMI_VRING_ENC_TYPE_802_3
,
533 .priority
= cpu_to_le16(0),
534 .timeslot_us
= cpu_to_le16(0xfff),
539 struct wil6210_mbox_hdr_wmi wmi
;
540 struct wmi_vring_cfg_done_event cmd
;
542 struct vring
*vring
= &wil
->vring_tx
[id
];
545 wil_err(wil
, "Tx ring [%d] already allocated\n", id
);
551 rc
= wil_vring_alloc(wil
, vring
);
555 cmd
.vring_cfg
.tx_sw_ring
.ring_mem_base
= cpu_to_le64(vring
->pa
);
556 cmd
.vring_cfg
.tx_sw_ring
.ring_size
= cpu_to_le16(vring
->size
);
558 rc
= wmi_call(wil
, WMI_VRING_CFG_CMDID
, &cmd
, sizeof(cmd
),
559 WMI_VRING_CFG_DONE_EVENTID
, &reply
, sizeof(reply
), 100);
563 if (reply
.cmd
.status
!= WMI_VRING_CFG_SUCCESS
) {
564 wil_err(wil
, "Tx config failed, status 0x%02x\n",
569 vring
->hwtail
= le32_to_cpu(reply
.cmd
.tx_vring_tail_ptr
);
573 wil_vring_free(wil
, vring
, 1);
579 void wil_vring_fini_tx(struct wil6210_priv
*wil
, int id
)
581 struct vring
*vring
= &wil
->vring_tx
[id
];
586 wil_vring_free(wil
, vring
, 1);
589 static struct vring
*wil_find_tx_vring(struct wil6210_priv
*wil
,
592 struct vring
*v
= &wil
->vring_tx
[0];
600 static int wil_tx_desc_map(volatile struct vring_tx_desc
*d
,
601 dma_addr_t pa
, u32 len
)
603 d
->dma
.addr_low
= lower_32_bits(pa
);
604 d
->dma
.addr_high
= (u16
)upper_32_bits(pa
);
605 d
->dma
.ip_length
= 0;
606 /* 0..6: mac_length; 7:ip_version 0-IP6 1-IP4*/
607 d
->dma
.b11
= 0/*14 | BIT(7)*/;
609 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
615 d
->mac
.ucode_cmd
= 0;
616 /* use dst index 0 */
617 d
->mac
.d
[1] |= BIT(MAC_CFG_DESC_TX_1_DST_INDEX_EN_POS
) |
618 (0 << MAC_CFG_DESC_TX_1_DST_INDEX_POS
);
619 /* translation type: 0 - bypass; 1 - 802.3; 2 - native wifi */
620 d
->mac
.d
[2] = BIT(MAC_CFG_DESC_TX_2_SNAP_HDR_INSERTION_EN_POS
) |
621 (1 << MAC_CFG_DESC_TX_2_L2_TRANSLATION_TYPE_POS
);
626 static int wil_tx_vring(struct wil6210_priv
*wil
, struct vring
*vring
,
629 struct device
*dev
= wil_to_dev(wil
);
630 volatile struct vring_tx_desc
*d
;
631 u32 swhead
= vring
->swhead
;
632 int avail
= wil_vring_avail_tx(vring
);
633 int nr_frags
= skb_shinfo(skb
)->nr_frags
;
635 int vring_index
= vring
- wil
->vring_tx
;
639 wil_dbg_txrx(wil
, "%s()\n", __func__
);
641 if (avail
< vring
->size
/8)
642 netif_tx_stop_all_queues(wil_to_ndev(wil
));
643 if (avail
< 1 + nr_frags
) {
644 wil_err(wil
, "Tx ring full. No space for %d fragments\n",
648 d
= &(vring
->va
[i
].tx
);
650 /* FIXME FW can accept only unicast frames for the peer */
651 memcpy(skb
->data
, wil
->dst_addr
[vring_index
], ETH_ALEN
);
653 pa
= dma_map_single(dev
, skb
->data
,
654 skb_headlen(skb
), DMA_TO_DEVICE
);
656 wil_dbg_txrx(wil
, "Tx skb %d bytes %p -> %#08llx\n", skb_headlen(skb
),
657 skb
->data
, (unsigned long long)pa
);
658 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_OFFSET
, 16, 1,
659 skb
->data
, skb_headlen(skb
), false);
661 if (unlikely(dma_mapping_error(dev
, pa
)))
664 wil_tx_desc_map(d
, pa
, skb_headlen(skb
));
665 d
->mac
.d
[2] |= ((nr_frags
+ 1) <<
666 MAC_CFG_DESC_TX_2_NUM_OF_DESCRIPTORS_POS
);
667 /* middle segments */
668 for (f
= 0; f
< nr_frags
; f
++) {
669 const struct skb_frag_struct
*frag
=
670 &skb_shinfo(skb
)->frags
[f
];
671 int len
= skb_frag_size(frag
);
672 i
= (swhead
+ f
+ 1) % vring
->size
;
673 d
= &(vring
->va
[i
].tx
);
674 pa
= skb_frag_dma_map(dev
, frag
, 0, skb_frag_size(frag
),
676 if (unlikely(dma_mapping_error(dev
, pa
)))
678 wil_tx_desc_map(d
, pa
, len
);
679 vring
->ctx
[i
] = NULL
;
681 /* for the last seg only */
682 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_EOP_POS
);
683 d
->dma
.d0
|= BIT(9); /* BUG: undocumented bit */
684 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_DMA_IT_POS
);
685 d
->dma
.d0
|= (vring_index
<< DMA_CFG_DESC_TX_0_QID_POS
);
687 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_NONE
, 32, 4,
688 (const void *)d
, sizeof(*d
), false);
691 wil_vring_advance_head(vring
, nr_frags
+ 1);
692 wil_dbg_txrx(wil
, "Tx swhead %d -> %d\n", swhead
, vring
->swhead
);
693 iowrite32(vring
->swhead
, wil
->csr
+ HOSTADDR(vring
->hwtail
));
694 /* hold reference to skb
695 * to prevent skb release before accounting
696 * in case of immediate "tx done"
698 vring
->ctx
[i
] = skb_get(skb
);
702 /* unmap what we have mapped */
703 /* Note: increment @f to operate with positive index */
704 for (f
++; f
> 0; f
--) {
705 i
= (swhead
+ f
) % vring
->size
;
706 d
= &(vring
->va
[i
].tx
);
707 d
->dma
.status
= TX_DMA_STATUS_DU
;
708 pa
= d
->dma
.addr_low
| ((u64
)d
->dma
.addr_high
<< 32);
710 dma_unmap_single(dev
, pa
, d
->dma
.length
, DMA_TO_DEVICE
);
712 dma_unmap_page(dev
, pa
, d
->dma
.length
, DMA_TO_DEVICE
);
719 netdev_tx_t
wil_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
721 struct wil6210_priv
*wil
= ndev_to_wil(ndev
);
725 wil_dbg_txrx(wil
, "%s()\n", __func__
);
726 if (!test_bit(wil_status_fwready
, &wil
->status
)) {
727 wil_err(wil
, "FW not ready\n");
730 if (!test_bit(wil_status_fwconnected
, &wil
->status
)) {
731 wil_err(wil
, "FW not connected\n");
734 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
735 wil_err(wil
, "Xmit in monitor mode not supported\n");
738 if (skb
->protocol
== cpu_to_be16(ETH_P_PAE
)) {
739 rc
= wmi_tx_eapol(wil
, skb
);
742 vring
= wil_find_tx_vring(wil
, skb
);
744 wil_err(wil
, "No Tx VRING available\n");
747 /* set up vring entry */
748 rc
= wil_tx_vring(wil
, vring
, skb
);
752 /* statistics will be updated on the tx_complete */
753 dev_kfree_skb_any(skb
);
756 return NETDEV_TX_BUSY
;
758 break; /* goto drop; */
761 netif_tx_stop_all_queues(ndev
);
762 ndev
->stats
.tx_dropped
++;
763 dev_kfree_skb_any(skb
);
765 return NET_XMIT_DROP
;
769 * Clean up transmitted skb's from the Tx VRING
771 * Safe to call from IRQ
773 void wil_tx_complete(struct wil6210_priv
*wil
, int ringid
)
775 struct net_device
*ndev
= wil_to_ndev(wil
);
776 struct device
*dev
= wil_to_dev(wil
);
777 struct vring
*vring
= &wil
->vring_tx
[ringid
];
780 wil_err(wil
, "Tx irq[%d]: vring not initialized\n", ringid
);
784 wil_dbg_txrx(wil
, "%s(%d)\n", __func__
, ringid
);
786 while (!wil_vring_is_empty(vring
)) {
787 volatile struct vring_tx_desc
*d
= &vring
->va
[vring
->swtail
].tx
;
790 if (!(d
->dma
.status
& TX_DMA_STATUS_DU
))
794 "Tx[%3d] : %d bytes, status 0x%02x err 0x%02x\n",
795 vring
->swtail
, d
->dma
.length
, d
->dma
.status
,
797 wil_hex_dump_txrx("TxC ", DUMP_PREFIX_NONE
, 32, 4,
798 (const void *)d
, sizeof(*d
), false);
800 pa
= d
->dma
.addr_low
| ((u64
)d
->dma
.addr_high
<< 32);
801 skb
= vring
->ctx
[vring
->swtail
];
803 if (d
->dma
.error
== 0) {
804 ndev
->stats
.tx_packets
++;
805 ndev
->stats
.tx_bytes
+= skb
->len
;
807 ndev
->stats
.tx_errors
++;
810 dma_unmap_single(dev
, pa
, d
->dma
.length
, DMA_TO_DEVICE
);
811 dev_kfree_skb_any(skb
);
812 vring
->ctx
[vring
->swtail
] = NULL
;
814 dma_unmap_page(dev
, pa
, d
->dma
.length
, DMA_TO_DEVICE
);
817 d
->dma
.addr_high
= 0;
819 d
->dma
.status
= TX_DMA_STATUS_DU
;
820 vring
->swtail
= wil_vring_next_tail(vring
);
822 if (wil_vring_avail_tx(vring
) > vring
->size
/4)
823 netif_tx_wake_all_queues(wil_to_ndev(wil
));