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/etherdevice.h>
18 #include <net/ieee80211_radiotap.h>
19 #include <linux/if_arp.h>
20 #include <linux/moduleparam.h>
27 static bool rtap_include_phy_info
;
28 module_param(rtap_include_phy_info
, bool, S_IRUGO
);
29 MODULE_PARM_DESC(rtap_include_phy_info
,
30 " Include PHY info in the radiotap header, default - no");
32 static inline int wil_vring_is_empty(struct vring
*vring
)
34 return vring
->swhead
== vring
->swtail
;
37 static inline u32
wil_vring_next_tail(struct vring
*vring
)
39 return (vring
->swtail
+ 1) % vring
->size
;
42 static inline void wil_vring_advance_head(struct vring
*vring
, int n
)
44 vring
->swhead
= (vring
->swhead
+ n
) % vring
->size
;
47 static inline int wil_vring_is_full(struct vring
*vring
)
49 return wil_vring_next_tail(vring
) == vring
->swhead
;
52 * Available space in Tx Vring
54 static inline int wil_vring_avail_tx(struct vring
*vring
)
56 u32 swhead
= vring
->swhead
;
57 u32 swtail
= vring
->swtail
;
58 int used
= (vring
->size
+ swhead
- swtail
) % vring
->size
;
60 return vring
->size
- used
- 1;
63 static int wil_vring_alloc(struct wil6210_priv
*wil
, struct vring
*vring
)
65 struct device
*dev
= wil_to_dev(wil
);
66 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
69 BUILD_BUG_ON(sizeof(vring
->va
[0]) != 32);
73 vring
->ctx
= kzalloc(vring
->size
* sizeof(vring
->ctx
[0]), GFP_KERNEL
);
79 * vring->va should be aligned on its size rounded up to power of 2
80 * This is granted by the dma_alloc_coherent
82 vring
->va
= dma_alloc_coherent(dev
, sz
, &vring
->pa
, GFP_KERNEL
);
88 /* initially, all descriptors are SW owned
89 * For Tx and Rx, ownership bit is at the same location, thus
92 for (i
= 0; i
< vring
->size
; i
++) {
93 volatile struct vring_tx_desc
*_d
= &(vring
->va
[i
].tx
);
94 _d
->dma
.status
= TX_DMA_STATUS_DU
;
97 wil_dbg_misc(wil
, "vring[%d] 0x%p:0x%016llx 0x%p\n", vring
->size
,
98 vring
->va
, (unsigned long long)vring
->pa
, vring
->ctx
);
103 static void wil_vring_free(struct wil6210_priv
*wil
, struct vring
*vring
,
106 struct device
*dev
= wil_to_dev(wil
);
107 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
109 while (!wil_vring_is_empty(vring
)) {
115 struct vring_tx_desc dd
, *d
= &dd
;
116 volatile struct vring_tx_desc
*_d
=
117 &vring
->va
[vring
->swtail
].tx
;
120 pa
= wil_desc_addr(&d
->dma
.addr
);
121 dmalen
= le16_to_cpu(d
->dma
.length
);
122 skb
= vring
->ctx
[vring
->swtail
];
124 dma_unmap_single(dev
, pa
, dmalen
,
126 dev_kfree_skb_any(skb
);
127 vring
->ctx
[vring
->swtail
] = NULL
;
129 dma_unmap_page(dev
, pa
, dmalen
,
132 vring
->swtail
= wil_vring_next_tail(vring
);
134 struct vring_rx_desc dd
, *d
= &dd
;
135 volatile struct vring_rx_desc
*_d
=
136 &vring
->va
[vring
->swtail
].rx
;
139 pa
= wil_desc_addr(&d
->dma
.addr
);
140 dmalen
= le16_to_cpu(d
->dma
.length
);
141 skb
= vring
->ctx
[vring
->swhead
];
142 dma_unmap_single(dev
, pa
, dmalen
, DMA_FROM_DEVICE
);
144 wil_vring_advance_head(vring
, 1);
147 dma_free_coherent(dev
, sz
, (void *)vring
->va
, vring
->pa
);
155 * Allocate one skb for Rx VRING
157 * Safe to call from IRQ
159 static int wil_vring_alloc_skb(struct wil6210_priv
*wil
, struct vring
*vring
,
162 struct device
*dev
= wil_to_dev(wil
);
163 unsigned int sz
= RX_BUF_LEN
;
164 struct vring_rx_desc dd
, *d
= &dd
;
165 volatile struct vring_rx_desc
*_d
= &(vring
->va
[i
].rx
);
169 struct sk_buff
*skb
= dev_alloc_skb(sz
+ headroom
);
173 skb_reserve(skb
, headroom
);
176 pa
= dma_map_single(dev
, skb
->data
, skb
->len
, DMA_FROM_DEVICE
);
177 if (unlikely(dma_mapping_error(dev
, pa
))) {
182 d
->dma
.d0
= BIT(9) | RX_DMA_D0_CMD_DMA_IT
;
183 wil_desc_addr_set(&d
->dma
.addr
, pa
);
184 /* ip_length don't care */
186 /* error don't care */
187 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
188 d
->dma
.length
= cpu_to_le16(sz
);
196 * Adds radiotap header
198 * Any error indicated as "Bad FCS"
200 * Vendor data for 04:ce:14-1 (Wilocity-1) consists of:
201 * - Rx descriptor: 32 bytes
204 static void wil_rx_add_radiotap_header(struct wil6210_priv
*wil
,
207 struct wireless_dev
*wdev
= wil
->wdev
;
208 struct wil6210_rtap
{
209 struct ieee80211_radiotap_header rthdr
;
210 /* fields should be in the order of bits in rthdr.it_present */
214 __le16 chnl_freq
__aligned(2);
221 struct wil6210_rtap_vendor
{
222 struct wil6210_rtap rtap
;
224 u8 vendor_oui
[3] __aligned(2);
229 struct vring_rx_desc
*d
= wil_skb_rxdesc(skb
);
230 struct wil6210_rtap_vendor
*rtap_vendor
;
231 int rtap_len
= sizeof(struct wil6210_rtap
);
232 int phy_length
= 0; /* phy info header size, bytes */
233 static char phy_data
[128];
234 struct ieee80211_channel
*ch
= wdev
->preset_chandef
.chan
;
236 if (rtap_include_phy_info
) {
237 rtap_len
= sizeof(*rtap_vendor
) + sizeof(*d
);
238 /* calculate additional length */
239 if (d
->dma
.status
& RX_DMA_STATUS_PHY_INFO
) {
241 * PHY info starts from 8-byte boundary
242 * there are 8-byte lines, last line may be partially
243 * written (HW bug), thus FW configures for last line
244 * to be excessive. Driver skips this last line.
246 int len
= min_t(int, 8 + sizeof(phy_data
),
247 wil_rxdesc_phy_length(d
));
249 void *p
= skb_tail_pointer(skb
);
250 void *pa
= PTR_ALIGN(p
, 8);
251 if (skb_tailroom(skb
) >= len
+ (pa
- p
)) {
252 phy_length
= len
- 8;
253 memcpy(phy_data
, pa
, phy_length
);
257 rtap_len
+= phy_length
;
260 if (skb_headroom(skb
) < rtap_len
&&
261 pskb_expand_head(skb
, rtap_len
, 0, GFP_ATOMIC
)) {
262 wil_err(wil
, "Unable to expand headrom to %d\n", rtap_len
);
266 rtap_vendor
= (void *)skb_push(skb
, rtap_len
);
267 memset(rtap_vendor
, 0, rtap_len
);
269 rtap_vendor
->rtap
.rthdr
.it_version
= PKTHDR_RADIOTAP_VERSION
;
270 rtap_vendor
->rtap
.rthdr
.it_len
= cpu_to_le16(rtap_len
);
271 rtap_vendor
->rtap
.rthdr
.it_present
= cpu_to_le32(
272 (1 << IEEE80211_RADIOTAP_FLAGS
) |
273 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
274 (1 << IEEE80211_RADIOTAP_MCS
));
275 if (d
->dma
.status
& RX_DMA_STATUS_ERROR
)
276 rtap_vendor
->rtap
.flags
|= IEEE80211_RADIOTAP_F_BADFCS
;
278 rtap_vendor
->rtap
.chnl_freq
= cpu_to_le16(ch
? ch
->center_freq
: 58320);
279 rtap_vendor
->rtap
.chnl_flags
= cpu_to_le16(0);
281 rtap_vendor
->rtap
.mcs_present
= IEEE80211_RADIOTAP_MCS_HAVE_MCS
;
282 rtap_vendor
->rtap
.mcs_flags
= 0;
283 rtap_vendor
->rtap
.mcs_index
= wil_rxdesc_mcs(d
);
285 if (rtap_include_phy_info
) {
286 rtap_vendor
->rtap
.rthdr
.it_present
|= cpu_to_le32(1 <<
287 IEEE80211_RADIOTAP_VENDOR_NAMESPACE
);
288 /* OUI for Wilocity 04:ce:14 */
289 rtap_vendor
->vendor_oui
[0] = 0x04;
290 rtap_vendor
->vendor_oui
[1] = 0xce;
291 rtap_vendor
->vendor_oui
[2] = 0x14;
292 rtap_vendor
->vendor_ns
= 1;
293 /* Rx descriptor + PHY data */
294 rtap_vendor
->vendor_skip
= cpu_to_le16(sizeof(*d
) +
296 memcpy(rtap_vendor
->vendor_data
, (void *)d
, sizeof(*d
));
297 memcpy(rtap_vendor
->vendor_data
+ sizeof(*d
), phy_data
,
303 * Fast swap in place between 2 registers
305 static void wil_swap_u16(u16
*a
, u16
*b
)
312 static void wil_swap_ethaddr(void *data
)
314 struct ethhdr
*eth
= data
;
315 u16
*s
= (u16
*)eth
->h_source
;
316 u16
*d
= (u16
*)eth
->h_dest
;
318 wil_swap_u16(s
++, d
++);
319 wil_swap_u16(s
++, d
++);
324 * reap 1 frame from @swhead
326 * Rx descriptor copied to skb->cb
328 * Safe to call from IRQ
330 static struct sk_buff
*wil_vring_reap_rx(struct wil6210_priv
*wil
,
333 struct device
*dev
= wil_to_dev(wil
);
334 struct net_device
*ndev
= wil_to_ndev(wil
);
335 volatile struct vring_rx_desc
*_d
;
336 struct vring_rx_desc
*d
;
339 unsigned int sz
= RX_BUF_LEN
;
344 BUILD_BUG_ON(sizeof(struct vring_rx_desc
) > sizeof(skb
->cb
));
346 if (wil_vring_is_empty(vring
))
349 _d
= &(vring
->va
[vring
->swhead
].rx
);
350 if (!(_d
->dma
.status
& RX_DMA_STATUS_DU
)) {
351 /* it is not error, we just reached end of Rx done area */
355 skb
= vring
->ctx
[vring
->swhead
];
356 d
= wil_skb_rxdesc(skb
);
358 pa
= wil_desc_addr(&d
->dma
.addr
);
359 vring
->ctx
[vring
->swhead
] = NULL
;
360 wil_vring_advance_head(vring
, 1);
362 dma_unmap_single(dev
, pa
, sz
, DMA_FROM_DEVICE
);
363 dmalen
= le16_to_cpu(d
->dma
.length
);
365 trace_wil6210_rx(vring
->swhead
, d
);
366 wil_dbg_txrx(wil
, "Rx[%3d] : %d bytes\n", vring
->swhead
, dmalen
);
367 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_NONE
, 32, 4,
368 (const void *)d
, sizeof(*d
), false);
371 wil_err(wil
, "Rx size too large: %d bytes!\n", dmalen
);
375 skb_trim(skb
, dmalen
);
377 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_OFFSET
, 16, 1,
378 skb
->data
, skb_headlen(skb
), false);
381 wil
->stats
.last_mcs_rx
= wil_rxdesc_mcs(d
);
383 /* use radiotap header only if required */
384 if (ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
)
385 wil_rx_add_radiotap_header(wil
, skb
);
387 /* no extra checks if in sniffer mode */
388 if (ndev
->type
!= ARPHRD_ETHER
)
391 * Non-data frames may be delivered through Rx DMA channel (ex: BAR)
392 * Driver should recognize it by frame type, that is found
393 * in Rx descriptor. If type is not data, it is 802.11 frame as is
395 ftype
= wil_rxdesc_ftype(d
) << 2;
396 if (ftype
!= IEEE80211_FTYPE_DATA
) {
397 wil_dbg_txrx(wil
, "Non-data frame ftype 0x%08x\n", ftype
);
398 /* TODO: process it */
403 if (skb
->len
< ETH_HLEN
) {
404 wil_err(wil
, "Short frame, len = %d\n", skb
->len
);
405 /* TODO: process it (i.e. BAR) */
410 ds_bits
= wil_rxdesc_ds_bits(d
);
413 * HW bug - in ToDS mode, i.e. Rx on AP side,
414 * addresses get swapped
416 wil_swap_ethaddr(skb
->data
);
423 * allocate and fill up to @count buffers in rx ring
424 * buffers posted at @swtail
426 static int wil_rx_refill(struct wil6210_priv
*wil
, int count
)
428 struct net_device
*ndev
= wil_to_ndev(wil
);
429 struct vring
*v
= &wil
->vring_rx
;
432 int headroom
= ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
?
433 WIL6210_RTAP_SIZE
: 0;
435 for (; next_tail
= wil_vring_next_tail(v
),
436 (next_tail
!= v
->swhead
) && (count
-- > 0);
437 v
->swtail
= next_tail
) {
438 rc
= wil_vring_alloc_skb(wil
, v
, v
->swtail
, headroom
);
440 wil_err(wil
, "Error %d in wil_rx_refill[%d]\n",
445 iowrite32(v
->swtail
, wil
->csr
+ HOSTADDR(v
->hwtail
));
451 * Pass Rx packet to the netif. Update statistics.
452 * Called in softirq context (NAPI poll).
454 static void wil_netif_rx_any(struct sk_buff
*skb
, struct net_device
*ndev
)
457 unsigned int len
= skb
->len
;
461 rc
= netif_receive_skb(skb
);
463 if (likely(rc
== NET_RX_SUCCESS
)) {
464 ndev
->stats
.rx_packets
++;
465 ndev
->stats
.rx_bytes
+= len
;
468 ndev
->stats
.rx_dropped
++;
473 * Proceed all completed skb's from Rx VRING
475 * Safe to call from NAPI poll, i.e. softirq with interrupts enabled
477 void wil_rx_handle(struct wil6210_priv
*wil
, int *quota
)
479 struct net_device
*ndev
= wil_to_ndev(wil
);
480 struct vring
*v
= &wil
->vring_rx
;
484 wil_err(wil
, "Rx IRQ while Rx not yet initialized\n");
487 wil_dbg_txrx(wil
, "%s()\n", __func__
);
488 while ((*quota
> 0) && (NULL
!= (skb
= wil_vring_reap_rx(wil
, v
)))) {
491 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
493 skb_reset_mac_header(skb
);
494 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
495 skb
->pkt_type
= PACKET_OTHERHOST
;
496 skb
->protocol
= htons(ETH_P_802_2
);
499 skb
->protocol
= eth_type_trans(skb
, ndev
);
502 wil_netif_rx_any(skb
, ndev
);
504 wil_rx_refill(wil
, v
->size
);
507 int wil_rx_init(struct wil6210_priv
*wil
)
509 struct vring
*vring
= &wil
->vring_rx
;
512 vring
->size
= WIL6210_RX_RING_SIZE
;
513 rc
= wil_vring_alloc(wil
, vring
);
517 rc
= wmi_rx_chain_add(wil
, vring
);
521 rc
= wil_rx_refill(wil
, vring
->size
);
527 wil_vring_free(wil
, vring
, 0);
532 void wil_rx_fini(struct wil6210_priv
*wil
)
534 struct vring
*vring
= &wil
->vring_rx
;
537 wil_vring_free(wil
, vring
, 0);
540 int wil_vring_init_tx(struct wil6210_priv
*wil
, int id
, int size
,
544 struct wmi_vring_cfg_cmd cmd
= {
545 .action
= cpu_to_le32(WMI_VRING_CMD_ADD
),
548 .max_mpdu_size
= cpu_to_le16(TX_BUF_LEN
),
549 .ring_size
= cpu_to_le16(size
),
552 .cidxtid
= (cid
& 0xf) | ((tid
& 0xf) << 4),
553 .encap_trans_type
= WMI_VRING_ENC_TYPE_802_3
,
558 .priority
= cpu_to_le16(0),
559 .timeslot_us
= cpu_to_le16(0xfff),
564 struct wil6210_mbox_hdr_wmi wmi
;
565 struct wmi_vring_cfg_done_event cmd
;
567 struct vring
*vring
= &wil
->vring_tx
[id
];
570 wil_err(wil
, "Tx ring [%d] already allocated\n", id
);
576 rc
= wil_vring_alloc(wil
, vring
);
580 cmd
.vring_cfg
.tx_sw_ring
.ring_mem_base
= cpu_to_le64(vring
->pa
);
582 rc
= wmi_call(wil
, WMI_VRING_CFG_CMDID
, &cmd
, sizeof(cmd
),
583 WMI_VRING_CFG_DONE_EVENTID
, &reply
, sizeof(reply
), 100);
587 if (reply
.cmd
.status
!= WMI_FW_STATUS_SUCCESS
) {
588 wil_err(wil
, "Tx config failed, status 0x%02x\n",
593 vring
->hwtail
= le32_to_cpu(reply
.cmd
.tx_vring_tail_ptr
);
597 wil_vring_free(wil
, vring
, 1);
603 void wil_vring_fini_tx(struct wil6210_priv
*wil
, int id
)
605 struct vring
*vring
= &wil
->vring_tx
[id
];
610 wil_vring_free(wil
, vring
, 1);
613 static struct vring
*wil_find_tx_vring(struct wil6210_priv
*wil
,
616 struct vring
*v
= &wil
->vring_tx
[0];
624 static int wil_tx_desc_map(struct vring_tx_desc
*d
, dma_addr_t pa
, u32 len
)
626 wil_desc_addr_set(&d
->dma
.addr
, pa
);
627 d
->dma
.ip_length
= 0;
628 /* 0..6: mac_length; 7:ip_version 0-IP6 1-IP4*/
629 d
->dma
.b11
= 0/*14 | BIT(7)*/;
631 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
632 d
->dma
.length
= cpu_to_le16((u16
)len
);
637 d
->mac
.ucode_cmd
= 0;
638 /* use dst index 0 */
639 d
->mac
.d
[1] |= BIT(MAC_CFG_DESC_TX_1_DST_INDEX_EN_POS
) |
640 (0 << MAC_CFG_DESC_TX_1_DST_INDEX_POS
);
641 /* translation type: 0 - bypass; 1 - 802.3; 2 - native wifi */
642 d
->mac
.d
[2] = BIT(MAC_CFG_DESC_TX_2_SNAP_HDR_INSERTION_EN_POS
) |
643 (1 << MAC_CFG_DESC_TX_2_L2_TRANSLATION_TYPE_POS
);
648 static int wil_tx_vring(struct wil6210_priv
*wil
, struct vring
*vring
,
651 struct device
*dev
= wil_to_dev(wil
);
652 struct vring_tx_desc dd
, *d
= &dd
;
653 volatile struct vring_tx_desc
*_d
;
654 u32 swhead
= vring
->swhead
;
655 int avail
= wil_vring_avail_tx(vring
);
656 int nr_frags
= skb_shinfo(skb
)->nr_frags
;
658 int vring_index
= vring
- wil
->vring_tx
;
662 wil_dbg_txrx(wil
, "%s()\n", __func__
);
664 if (avail
< vring
->size
/8)
665 netif_tx_stop_all_queues(wil_to_ndev(wil
));
666 if (avail
< 1 + nr_frags
) {
667 wil_err(wil
, "Tx ring full. No space for %d fragments\n",
671 _d
= &(vring
->va
[i
].tx
);
673 /* FIXME FW can accept only unicast frames for the peer */
674 memcpy(skb
->data
, wil
->dst_addr
[vring_index
], ETH_ALEN
);
676 pa
= dma_map_single(dev
, skb
->data
,
677 skb_headlen(skb
), DMA_TO_DEVICE
);
679 wil_dbg_txrx(wil
, "Tx skb %d bytes %p -> %#08llx\n", skb_headlen(skb
),
680 skb
->data
, (unsigned long long)pa
);
681 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_OFFSET
, 16, 1,
682 skb
->data
, skb_headlen(skb
), false);
684 if (unlikely(dma_mapping_error(dev
, pa
)))
687 wil_tx_desc_map(d
, pa
, skb_headlen(skb
));
688 d
->mac
.d
[2] |= ((nr_frags
+ 1) <<
689 MAC_CFG_DESC_TX_2_NUM_OF_DESCRIPTORS_POS
);
693 /* middle segments */
694 for (f
= 0; f
< nr_frags
; f
++) {
695 const struct skb_frag_struct
*frag
=
696 &skb_shinfo(skb
)->frags
[f
];
697 int len
= skb_frag_size(frag
);
698 i
= (swhead
+ f
+ 1) % vring
->size
;
699 _d
= &(vring
->va
[i
].tx
);
700 pa
= skb_frag_dma_map(dev
, frag
, 0, skb_frag_size(frag
),
702 if (unlikely(dma_mapping_error(dev
, pa
)))
704 wil_tx_desc_map(d
, pa
, len
);
705 vring
->ctx
[i
] = NULL
;
708 /* for the last seg only */
709 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_EOP_POS
);
710 d
->dma
.d0
|= BIT(9); /* BUG: undocumented bit */
711 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_DMA_IT_POS
);
712 d
->dma
.d0
|= (vring_index
<< DMA_CFG_DESC_TX_0_QID_POS
);
715 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_NONE
, 32, 4,
716 (const void *)d
, sizeof(*d
), false);
719 wil_vring_advance_head(vring
, nr_frags
+ 1);
720 wil_dbg_txrx(wil
, "Tx swhead %d -> %d\n", swhead
, vring
->swhead
);
721 trace_wil6210_tx(vring_index
, swhead
, skb
->len
, nr_frags
);
722 iowrite32(vring
->swhead
, wil
->csr
+ HOSTADDR(vring
->hwtail
));
723 /* hold reference to skb
724 * to prevent skb release before accounting
725 * in case of immediate "tx done"
727 vring
->ctx
[i
] = skb_get(skb
);
731 /* unmap what we have mapped */
732 /* Note: increment @f to operate with positive index */
733 for (f
++; f
> 0; f
--) {
736 i
= (swhead
+ f
) % vring
->size
;
737 _d
= &(vring
->va
[i
].tx
);
739 _d
->dma
.status
= TX_DMA_STATUS_DU
;
740 pa
= wil_desc_addr(&d
->dma
.addr
);
741 dmalen
= le16_to_cpu(d
->dma
.length
);
743 dma_unmap_single(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
745 dma_unmap_page(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
752 netdev_tx_t
wil_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
754 struct wil6210_priv
*wil
= ndev_to_wil(ndev
);
758 wil_dbg_txrx(wil
, "%s()\n", __func__
);
759 if (!test_bit(wil_status_fwready
, &wil
->status
)) {
760 wil_err(wil
, "FW not ready\n");
763 if (!test_bit(wil_status_fwconnected
, &wil
->status
)) {
764 wil_err(wil
, "FW not connected\n");
767 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
768 wil_err(wil
, "Xmit in monitor mode not supported\n");
773 vring
= wil_find_tx_vring(wil
, skb
);
775 wil_err(wil
, "No Tx VRING available\n");
778 /* set up vring entry */
779 rc
= wil_tx_vring(wil
, vring
, skb
);
783 /* statistics will be updated on the tx_complete */
784 dev_kfree_skb_any(skb
);
787 return NETDEV_TX_BUSY
;
789 break; /* goto drop; */
792 ndev
->stats
.tx_dropped
++;
793 dev_kfree_skb_any(skb
);
795 return NET_XMIT_DROP
;
799 * Clean up transmitted skb's from the Tx VRING
801 * Return number of descriptors cleared
803 * Safe to call from IRQ
805 int wil_tx_complete(struct wil6210_priv
*wil
, int ringid
)
807 struct net_device
*ndev
= wil_to_ndev(wil
);
808 struct device
*dev
= wil_to_dev(wil
);
809 struct vring
*vring
= &wil
->vring_tx
[ringid
];
813 wil_err(wil
, "Tx irq[%d]: vring not initialized\n", ringid
);
817 wil_dbg_txrx(wil
, "%s(%d)\n", __func__
, ringid
);
819 while (!wil_vring_is_empty(vring
)) {
820 volatile struct vring_tx_desc
*_d
=
821 &vring
->va
[vring
->swtail
].tx
;
822 struct vring_tx_desc dd
, *d
= &dd
;
829 if (!(d
->dma
.status
& TX_DMA_STATUS_DU
))
832 dmalen
= le16_to_cpu(d
->dma
.length
);
833 trace_wil6210_tx_done(ringid
, vring
->swtail
, dmalen
,
836 "Tx[%3d] : %d bytes, status 0x%02x err 0x%02x\n",
837 vring
->swtail
, dmalen
, d
->dma
.status
,
839 wil_hex_dump_txrx("TxC ", DUMP_PREFIX_NONE
, 32, 4,
840 (const void *)d
, sizeof(*d
), false);
842 pa
= wil_desc_addr(&d
->dma
.addr
);
843 skb
= vring
->ctx
[vring
->swtail
];
845 if (d
->dma
.error
== 0) {
846 ndev
->stats
.tx_packets
++;
847 ndev
->stats
.tx_bytes
+= skb
->len
;
849 ndev
->stats
.tx_errors
++;
852 dma_unmap_single(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
853 dev_kfree_skb_any(skb
);
854 vring
->ctx
[vring
->swtail
] = NULL
;
856 dma_unmap_page(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
858 d
->dma
.addr
.addr_low
= 0;
859 d
->dma
.addr
.addr_high
= 0;
861 d
->dma
.status
= TX_DMA_STATUS_DU
;
862 vring
->swtail
= wil_vring_next_tail(vring
);
865 if (wil_vring_avail_tx(vring
) > vring
->size
/4)
866 netif_tx_wake_all_queues(wil_to_ndev(wil
));