2 * Copyright (c) 2012-2014 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>
22 #include <linux/ipv6.h>
24 #include <linux/prefetch.h>
31 static bool rtap_include_phy_info
;
32 module_param(rtap_include_phy_info
, bool, S_IRUGO
);
33 MODULE_PARM_DESC(rtap_include_phy_info
,
34 " Include PHY info in the radiotap header, default - no");
36 static inline int wil_vring_is_empty(struct vring
*vring
)
38 return vring
->swhead
== vring
->swtail
;
41 static inline u32
wil_vring_next_tail(struct vring
*vring
)
43 return (vring
->swtail
+ 1) % vring
->size
;
46 static inline void wil_vring_advance_head(struct vring
*vring
, int n
)
48 vring
->swhead
= (vring
->swhead
+ n
) % vring
->size
;
51 static inline int wil_vring_is_full(struct vring
*vring
)
53 return wil_vring_next_tail(vring
) == vring
->swhead
;
56 * Available space in Tx Vring
58 static inline int wil_vring_avail_tx(struct vring
*vring
)
60 u32 swhead
= vring
->swhead
;
61 u32 swtail
= vring
->swtail
;
62 int used
= (vring
->size
+ swhead
- swtail
) % vring
->size
;
64 return vring
->size
- used
- 1;
68 * wil_vring_wmark_low - low watermark for available descriptor space
70 static inline int wil_vring_wmark_low(struct vring
*vring
)
76 * wil_vring_wmark_high - high watermark for available descriptor space
78 static inline int wil_vring_wmark_high(struct vring
*vring
)
83 static int wil_vring_alloc(struct wil6210_priv
*wil
, struct vring
*vring
)
85 struct device
*dev
= wil_to_dev(wil
);
86 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
89 BUILD_BUG_ON(sizeof(vring
->va
[0]) != 32);
93 vring
->ctx
= kcalloc(vring
->size
, sizeof(vring
->ctx
[0]), GFP_KERNEL
);
99 * vring->va should be aligned on its size rounded up to power of 2
100 * This is granted by the dma_alloc_coherent
102 vring
->va
= dma_alloc_coherent(dev
, sz
, &vring
->pa
, GFP_KERNEL
);
108 /* initially, all descriptors are SW owned
109 * For Tx and Rx, ownership bit is at the same location, thus
112 for (i
= 0; i
< vring
->size
; i
++) {
113 volatile struct vring_tx_desc
*_d
= &(vring
->va
[i
].tx
);
114 _d
->dma
.status
= TX_DMA_STATUS_DU
;
117 wil_dbg_misc(wil
, "vring[%d] 0x%p:%pad 0x%p\n", vring
->size
,
118 vring
->va
, &vring
->pa
, vring
->ctx
);
123 static void wil_txdesc_unmap(struct device
*dev
, struct vring_tx_desc
*d
,
126 dma_addr_t pa
= wil_desc_addr(&d
->dma
.addr
);
127 u16 dmalen
= le16_to_cpu(d
->dma
.length
);
128 switch (ctx
->mapped_as
) {
129 case wil_mapped_as_single
:
130 dma_unmap_single(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
132 case wil_mapped_as_page
:
133 dma_unmap_page(dev
, pa
, dmalen
, DMA_TO_DEVICE
);
140 static void wil_vring_free(struct wil6210_priv
*wil
, struct vring
*vring
,
143 struct device
*dev
= wil_to_dev(wil
);
144 size_t sz
= vring
->size
* sizeof(vring
->va
[0]);
146 while (!wil_vring_is_empty(vring
)) {
152 struct vring_tx_desc dd
, *d
= &dd
;
153 volatile struct vring_tx_desc
*_d
=
154 &vring
->va
[vring
->swtail
].tx
;
156 ctx
= &vring
->ctx
[vring
->swtail
];
158 wil_txdesc_unmap(dev
, d
, ctx
);
160 dev_kfree_skb_any(ctx
->skb
);
161 vring
->swtail
= wil_vring_next_tail(vring
);
163 struct vring_rx_desc dd
, *d
= &dd
;
164 volatile struct vring_rx_desc
*_d
=
165 &vring
->va
[vring
->swhead
].rx
;
167 ctx
= &vring
->ctx
[vring
->swhead
];
169 pa
= wil_desc_addr(&d
->dma
.addr
);
170 dmalen
= le16_to_cpu(d
->dma
.length
);
171 dma_unmap_single(dev
, pa
, dmalen
, DMA_FROM_DEVICE
);
173 wil_vring_advance_head(vring
, 1);
176 dma_free_coherent(dev
, sz
, (void *)vring
->va
, vring
->pa
);
184 * Allocate one skb for Rx VRING
186 * Safe to call from IRQ
188 static int wil_vring_alloc_skb(struct wil6210_priv
*wil
, struct vring
*vring
,
191 struct device
*dev
= wil_to_dev(wil
);
192 unsigned int sz
= RX_BUF_LEN
;
193 struct vring_rx_desc dd
, *d
= &dd
;
194 volatile struct vring_rx_desc
*_d
= &(vring
->va
[i
].rx
);
198 struct sk_buff
*skb
= dev_alloc_skb(sz
+ headroom
);
202 skb_reserve(skb
, headroom
);
205 pa
= dma_map_single(dev
, skb
->data
, skb
->len
, DMA_FROM_DEVICE
);
206 if (unlikely(dma_mapping_error(dev
, pa
))) {
211 d
->dma
.d0
= BIT(9) | RX_DMA_D0_CMD_DMA_IT
;
212 wil_desc_addr_set(&d
->dma
.addr
, pa
);
213 /* ip_length don't care */
215 /* error don't care */
216 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
217 d
->dma
.length
= cpu_to_le16(sz
);
219 vring
->ctx
[i
].skb
= skb
;
225 * Adds radiotap header
227 * Any error indicated as "Bad FCS"
229 * Vendor data for 04:ce:14-1 (Wilocity-1) consists of:
230 * - Rx descriptor: 32 bytes
233 static void wil_rx_add_radiotap_header(struct wil6210_priv
*wil
,
236 struct wireless_dev
*wdev
= wil
->wdev
;
237 struct wil6210_rtap
{
238 struct ieee80211_radiotap_header rthdr
;
239 /* fields should be in the order of bits in rthdr.it_present */
243 __le16 chnl_freq
__aligned(2);
250 struct wil6210_rtap_vendor
{
251 struct wil6210_rtap rtap
;
253 u8 vendor_oui
[3] __aligned(2);
258 struct vring_rx_desc
*d
= wil_skb_rxdesc(skb
);
259 struct wil6210_rtap_vendor
*rtap_vendor
;
260 int rtap_len
= sizeof(struct wil6210_rtap
);
261 int phy_length
= 0; /* phy info header size, bytes */
262 static char phy_data
[128];
263 struct ieee80211_channel
*ch
= wdev
->preset_chandef
.chan
;
265 if (rtap_include_phy_info
) {
266 rtap_len
= sizeof(*rtap_vendor
) + sizeof(*d
);
267 /* calculate additional length */
268 if (d
->dma
.status
& RX_DMA_STATUS_PHY_INFO
) {
270 * PHY info starts from 8-byte boundary
271 * there are 8-byte lines, last line may be partially
272 * written (HW bug), thus FW configures for last line
273 * to be excessive. Driver skips this last line.
275 int len
= min_t(int, 8 + sizeof(phy_data
),
276 wil_rxdesc_phy_length(d
));
278 void *p
= skb_tail_pointer(skb
);
279 void *pa
= PTR_ALIGN(p
, 8);
280 if (skb_tailroom(skb
) >= len
+ (pa
- p
)) {
281 phy_length
= len
- 8;
282 memcpy(phy_data
, pa
, phy_length
);
286 rtap_len
+= phy_length
;
289 if (skb_headroom(skb
) < rtap_len
&&
290 pskb_expand_head(skb
, rtap_len
, 0, GFP_ATOMIC
)) {
291 wil_err(wil
, "Unable to expand headrom to %d\n", rtap_len
);
295 rtap_vendor
= (void *)skb_push(skb
, rtap_len
);
296 memset(rtap_vendor
, 0, rtap_len
);
298 rtap_vendor
->rtap
.rthdr
.it_version
= PKTHDR_RADIOTAP_VERSION
;
299 rtap_vendor
->rtap
.rthdr
.it_len
= cpu_to_le16(rtap_len
);
300 rtap_vendor
->rtap
.rthdr
.it_present
= cpu_to_le32(
301 (1 << IEEE80211_RADIOTAP_FLAGS
) |
302 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
303 (1 << IEEE80211_RADIOTAP_MCS
));
304 if (d
->dma
.status
& RX_DMA_STATUS_ERROR
)
305 rtap_vendor
->rtap
.flags
|= IEEE80211_RADIOTAP_F_BADFCS
;
307 rtap_vendor
->rtap
.chnl_freq
= cpu_to_le16(ch
? ch
->center_freq
: 58320);
308 rtap_vendor
->rtap
.chnl_flags
= cpu_to_le16(0);
310 rtap_vendor
->rtap
.mcs_present
= IEEE80211_RADIOTAP_MCS_HAVE_MCS
;
311 rtap_vendor
->rtap
.mcs_flags
= 0;
312 rtap_vendor
->rtap
.mcs_index
= wil_rxdesc_mcs(d
);
314 if (rtap_include_phy_info
) {
315 rtap_vendor
->rtap
.rthdr
.it_present
|= cpu_to_le32(1 <<
316 IEEE80211_RADIOTAP_VENDOR_NAMESPACE
);
317 /* OUI for Wilocity 04:ce:14 */
318 rtap_vendor
->vendor_oui
[0] = 0x04;
319 rtap_vendor
->vendor_oui
[1] = 0xce;
320 rtap_vendor
->vendor_oui
[2] = 0x14;
321 rtap_vendor
->vendor_ns
= 1;
322 /* Rx descriptor + PHY data */
323 rtap_vendor
->vendor_skip
= cpu_to_le16(sizeof(*d
) +
325 memcpy(rtap_vendor
->vendor_data
, (void *)d
, sizeof(*d
));
326 memcpy(rtap_vendor
->vendor_data
+ sizeof(*d
), phy_data
,
332 * Fast swap in place between 2 registers
334 static void wil_swap_u16(u16
*a
, u16
*b
)
341 static void wil_swap_ethaddr(void *data
)
343 struct ethhdr
*eth
= data
;
344 u16
*s
= (u16
*)eth
->h_source
;
345 u16
*d
= (u16
*)eth
->h_dest
;
347 wil_swap_u16(s
++, d
++);
348 wil_swap_u16(s
++, d
++);
353 * reap 1 frame from @swhead
355 * Rx descriptor copied to skb->cb
357 * Safe to call from IRQ
359 static struct sk_buff
*wil_vring_reap_rx(struct wil6210_priv
*wil
,
362 struct device
*dev
= wil_to_dev(wil
);
363 struct net_device
*ndev
= wil_to_ndev(wil
);
364 volatile struct vring_rx_desc
*_d
;
365 struct vring_rx_desc
*d
;
368 unsigned int sz
= RX_BUF_LEN
;
373 struct wil_net_stats
*stats
;
376 BUILD_BUG_ON(sizeof(struct vring_rx_desc
) > sizeof(skb
->cb
));
378 if (wil_vring_is_empty(vring
))
381 _d
= &(vring
->va
[vring
->swhead
].rx
);
382 if (!(_d
->dma
.status
& RX_DMA_STATUS_DU
)) {
383 /* it is not error, we just reached end of Rx done area */
387 skb
= vring
->ctx
[vring
->swhead
].skb
;
388 d
= wil_skb_rxdesc(skb
);
390 pa
= wil_desc_addr(&d
->dma
.addr
);
391 vring
->ctx
[vring
->swhead
].skb
= NULL
;
392 wil_vring_advance_head(vring
, 1);
394 dma_unmap_single(dev
, pa
, sz
, DMA_FROM_DEVICE
);
395 dmalen
= le16_to_cpu(d
->dma
.length
);
397 trace_wil6210_rx(vring
->swhead
, d
);
398 wil_dbg_txrx(wil
, "Rx[%3d] : %d bytes\n", vring
->swhead
, dmalen
);
399 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_NONE
, 32, 4,
400 (const void *)d
, sizeof(*d
), false);
403 wil_err(wil
, "Rx size too large: %d bytes!\n", dmalen
);
407 skb_trim(skb
, dmalen
);
411 wil_hex_dump_txrx("Rx ", DUMP_PREFIX_OFFSET
, 16, 1,
412 skb
->data
, skb_headlen(skb
), false);
414 cid
= wil_rxdesc_cid(d
);
415 stats
= &wil
->sta
[cid
].stats
;
416 stats
->last_mcs_rx
= wil_rxdesc_mcs(d
);
417 wil
->stats
.last_mcs_rx
= stats
->last_mcs_rx
;
419 /* use radiotap header only if required */
420 if (ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
)
421 wil_rx_add_radiotap_header(wil
, skb
);
423 /* no extra checks if in sniffer mode */
424 if (ndev
->type
!= ARPHRD_ETHER
)
427 * Non-data frames may be delivered through Rx DMA channel (ex: BAR)
428 * Driver should recognize it by frame type, that is found
429 * in Rx descriptor. If type is not data, it is 802.11 frame as is
431 ftype
= wil_rxdesc_ftype(d
) << 2;
432 if (ftype
!= IEEE80211_FTYPE_DATA
) {
433 wil_dbg_txrx(wil
, "Non-data frame ftype 0x%08x\n", ftype
);
434 /* TODO: process it */
439 if (skb
->len
< ETH_HLEN
) {
440 wil_err(wil
, "Short frame, len = %d\n", skb
->len
);
441 /* TODO: process it (i.e. BAR) */
446 /* L4 IDENT is on when HW calculated checksum, check status
447 * and in case of error drop the packet
448 * higher stack layers will handle retransmission (if required)
450 if (d
->dma
.status
& RX_DMA_STATUS_L4_IDENT
) {
451 /* L4 protocol identified, csum calculated */
452 if ((d
->dma
.error
& RX_DMA_ERROR_L4_ERR
) == 0)
453 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
454 /* If HW reports bad checksum, let IP stack re-check it
455 * For example, HW don't understand Microsoft IP stack that
456 * mis-calculates TCP checksum - if it should be 0x0,
457 * it writes 0xffff in violation of RFC 1624
461 ds_bits
= wil_rxdesc_ds_bits(d
);
464 * HW bug - in ToDS mode, i.e. Rx on AP side,
465 * addresses get swapped
467 wil_swap_ethaddr(skb
->data
);
474 * allocate and fill up to @count buffers in rx ring
475 * buffers posted at @swtail
477 static int wil_rx_refill(struct wil6210_priv
*wil
, int count
)
479 struct net_device
*ndev
= wil_to_ndev(wil
);
480 struct vring
*v
= &wil
->vring_rx
;
483 int headroom
= ndev
->type
== ARPHRD_IEEE80211_RADIOTAP
?
484 WIL6210_RTAP_SIZE
: 0;
486 for (; next_tail
= wil_vring_next_tail(v
),
487 (next_tail
!= v
->swhead
) && (count
-- > 0);
488 v
->swtail
= next_tail
) {
489 rc
= wil_vring_alloc_skb(wil
, v
, v
->swtail
, headroom
);
491 wil_err(wil
, "Error %d in wil_rx_refill[%d]\n",
496 iowrite32(v
->swtail
, wil
->csr
+ HOSTADDR(v
->hwtail
));
502 * Pass Rx packet to the netif. Update statistics.
503 * Called in softirq context (NAPI poll).
505 void wil_netif_rx_any(struct sk_buff
*skb
, struct net_device
*ndev
)
508 struct wil6210_priv
*wil
= ndev_to_wil(ndev
);
509 unsigned int len
= skb
->len
;
510 struct vring_rx_desc
*d
= wil_skb_rxdesc(skb
);
511 int cid
= wil_rxdesc_cid(d
);
512 struct wil_net_stats
*stats
= &wil
->sta
[cid
].stats
;
516 rc
= napi_gro_receive(&wil
->napi_rx
, skb
);
518 if (unlikely(rc
== GRO_DROP
)) {
519 ndev
->stats
.rx_dropped
++;
521 wil_dbg_txrx(wil
, "Rx drop %d bytes\n", len
);
523 ndev
->stats
.rx_packets
++;
525 ndev
->stats
.rx_bytes
+= len
;
526 stats
->rx_bytes
+= len
;
529 static const char * const gro_res_str
[] = {
530 [GRO_MERGED
] = "GRO_MERGED",
531 [GRO_MERGED_FREE
] = "GRO_MERGED_FREE",
532 [GRO_HELD
] = "GRO_HELD",
533 [GRO_NORMAL
] = "GRO_NORMAL",
534 [GRO_DROP
] = "GRO_DROP",
536 wil_dbg_txrx(wil
, "Rx complete %d bytes => %s,\n",
537 len
, gro_res_str
[rc
]);
542 * Proceed all completed skb's from Rx VRING
544 * Safe to call from NAPI poll, i.e. softirq with interrupts enabled
546 void wil_rx_handle(struct wil6210_priv
*wil
, int *quota
)
548 struct net_device
*ndev
= wil_to_ndev(wil
);
549 struct vring
*v
= &wil
->vring_rx
;
553 wil_err(wil
, "Rx IRQ while Rx not yet initialized\n");
556 wil_dbg_txrx(wil
, "%s()\n", __func__
);
557 while ((*quota
> 0) && (NULL
!= (skb
= wil_vring_reap_rx(wil
, v
)))) {
560 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
562 skb_reset_mac_header(skb
);
563 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
564 skb
->pkt_type
= PACKET_OTHERHOST
;
565 skb
->protocol
= htons(ETH_P_802_2
);
566 wil_netif_rx_any(skb
, ndev
);
568 struct ethhdr
*eth
= (void *)skb
->data
;
570 skb
->protocol
= eth_type_trans(skb
, ndev
);
572 if (is_unicast_ether_addr(eth
->h_dest
))
573 wil_rx_reorder(wil
, skb
);
575 wil_netif_rx_any(skb
, ndev
);
579 wil_rx_refill(wil
, v
->size
);
582 int wil_rx_init(struct wil6210_priv
*wil
)
584 struct vring
*vring
= &wil
->vring_rx
;
588 wil_err(wil
, "Rx ring already allocated\n");
592 vring
->size
= WIL6210_RX_RING_SIZE
;
593 rc
= wil_vring_alloc(wil
, vring
);
597 rc
= wmi_rx_chain_add(wil
, vring
);
601 rc
= wil_rx_refill(wil
, vring
->size
);
607 wil_vring_free(wil
, vring
, 0);
612 void wil_rx_fini(struct wil6210_priv
*wil
)
614 struct vring
*vring
= &wil
->vring_rx
;
617 wil_vring_free(wil
, vring
, 0);
620 int wil_vring_init_tx(struct wil6210_priv
*wil
, int id
, int size
,
624 struct wmi_vring_cfg_cmd cmd
= {
625 .action
= cpu_to_le32(WMI_VRING_CMD_ADD
),
628 .max_mpdu_size
= cpu_to_le16(TX_BUF_LEN
),
629 .ring_size
= cpu_to_le16(size
),
632 .cidxtid
= mk_cidxtid(cid
, tid
),
633 .encap_trans_type
= WMI_VRING_ENC_TYPE_802_3
,
638 .priority
= cpu_to_le16(0),
639 .timeslot_us
= cpu_to_le16(0xfff),
644 struct wil6210_mbox_hdr_wmi wmi
;
645 struct wmi_vring_cfg_done_event cmd
;
647 struct vring
*vring
= &wil
->vring_tx
[id
];
648 struct vring_tx_data
*txdata
= &wil
->vring_tx_data
[id
];
651 wil_err(wil
, "Tx ring [%d] already allocated\n", id
);
656 memset(txdata
, 0, sizeof(*txdata
));
658 rc
= wil_vring_alloc(wil
, vring
);
662 wil
->vring2cid_tid
[id
][0] = cid
;
663 wil
->vring2cid_tid
[id
][1] = tid
;
665 cmd
.vring_cfg
.tx_sw_ring
.ring_mem_base
= cpu_to_le64(vring
->pa
);
667 rc
= wmi_call(wil
, WMI_VRING_CFG_CMDID
, &cmd
, sizeof(cmd
),
668 WMI_VRING_CFG_DONE_EVENTID
, &reply
, sizeof(reply
), 100);
672 if (reply
.cmd
.status
!= WMI_FW_STATUS_SUCCESS
) {
673 wil_err(wil
, "Tx config failed, status 0x%02x\n",
678 vring
->hwtail
= le32_to_cpu(reply
.cmd
.tx_vring_tail_ptr
);
684 wil_vring_free(wil
, vring
, 1);
690 void wil_vring_fini_tx(struct wil6210_priv
*wil
, int id
)
692 struct vring
*vring
= &wil
->vring_tx
[id
];
694 WARN_ON(!mutex_is_locked(&wil
->mutex
));
699 /* make sure NAPI won't touch this vring */
700 wil
->vring_tx_data
[id
].enabled
= 0;
701 if (test_bit(wil_status_napi_en
, &wil
->status
))
702 napi_synchronize(&wil
->napi_tx
);
704 wil_vring_free(wil
, vring
, 1);
707 static struct vring
*wil_find_tx_vring(struct wil6210_priv
*wil
,
711 struct ethhdr
*eth
= (void *)skb
->data
;
712 int cid
= wil_find_cid(wil
, eth
->h_dest
);
717 if (!wil
->sta
[cid
].data_port_open
&&
718 (skb
->protocol
!= cpu_to_be16(ETH_P_PAE
)))
721 /* TODO: fix for multiple TID */
722 for (i
= 0; i
< ARRAY_SIZE(wil
->vring2cid_tid
); i
++) {
723 if (wil
->vring2cid_tid
[i
][0] == cid
) {
724 struct vring
*v
= &wil
->vring_tx
[i
];
725 wil_dbg_txrx(wil
, "%s(%pM) -> [%d]\n",
726 __func__
, eth
->h_dest
, i
);
730 wil_dbg_txrx(wil
, "vring[%d] not valid\n", i
);
739 static void wil_set_da_for_vring(struct wil6210_priv
*wil
,
740 struct sk_buff
*skb
, int vring_index
)
742 struct ethhdr
*eth
= (void *)skb
->data
;
743 int cid
= wil
->vring2cid_tid
[vring_index
][0];
744 memcpy(eth
->h_dest
, wil
->sta
[cid
].addr
, ETH_ALEN
);
747 static int wil_tx_vring(struct wil6210_priv
*wil
, struct vring
*vring
,
748 struct sk_buff
*skb
);
750 * Find 1-st vring and return it; set dest address for this vring in skb
751 * duplicate skb and send it to other active vrings
753 static struct vring
*wil_tx_bcast(struct wil6210_priv
*wil
,
756 struct vring
*v
, *v2
;
757 struct sk_buff
*skb2
;
761 /* find 1-st vring eligible for data */
762 for (i
= 0; i
< WIL6210_MAX_TX_RINGS
; i
++) {
763 v
= &wil
->vring_tx
[i
];
767 cid
= wil
->vring2cid_tid
[i
][0];
768 if (!wil
->sta
[cid
].data_port_open
)
774 wil_dbg_txrx(wil
, "Tx while no vrings active?\n");
779 wil_dbg_txrx(wil
, "BCAST -> ring %d\n", i
);
780 wil_set_da_for_vring(wil
, skb
, i
);
782 /* find other active vrings and duplicate skb for each */
783 for (i
++; i
< WIL6210_MAX_TX_RINGS
; i
++) {
784 v2
= &wil
->vring_tx
[i
];
787 cid
= wil
->vring2cid_tid
[i
][0];
788 if (!wil
->sta
[cid
].data_port_open
)
791 skb2
= skb_copy(skb
, GFP_ATOMIC
);
793 wil_dbg_txrx(wil
, "BCAST DUP -> ring %d\n", i
);
794 wil_set_da_for_vring(wil
, skb2
, i
);
795 wil_tx_vring(wil
, v2
, skb2
);
797 wil_err(wil
, "skb_copy failed\n");
804 static int wil_tx_desc_map(struct vring_tx_desc
*d
, dma_addr_t pa
, u32 len
,
807 wil_desc_addr_set(&d
->dma
.addr
, pa
);
808 d
->dma
.ip_length
= 0;
809 /* 0..6: mac_length; 7:ip_version 0-IP6 1-IP4*/
810 d
->dma
.b11
= 0/*14 | BIT(7)*/;
812 d
->dma
.status
= 0; /* BIT(0) should be 0 for HW_OWNED */
813 d
->dma
.length
= cpu_to_le16((u16
)len
);
814 d
->dma
.d0
= (vring_index
<< DMA_CFG_DESC_TX_0_QID_POS
);
818 d
->mac
.ucode_cmd
= 0;
819 /* use dst index 0 */
820 d
->mac
.d
[1] |= BIT(MAC_CFG_DESC_TX_1_DST_INDEX_EN_POS
) |
821 (0 << MAC_CFG_DESC_TX_1_DST_INDEX_POS
);
822 /* translation type: 0 - bypass; 1 - 802.3; 2 - native wifi */
823 d
->mac
.d
[2] = BIT(MAC_CFG_DESC_TX_2_SNAP_HDR_INSERTION_EN_POS
) |
824 (1 << MAC_CFG_DESC_TX_2_L2_TRANSLATION_TYPE_POS
);
830 void wil_tx_desc_set_nr_frags(struct vring_tx_desc
*d
, int nr_frags
)
832 d
->mac
.d
[2] |= ((nr_frags
+ 1) <<
833 MAC_CFG_DESC_TX_2_NUM_OF_DESCRIPTORS_POS
);
836 static int wil_tx_desc_offload_cksum_set(struct wil6210_priv
*wil
,
837 struct vring_tx_desc
*d
,
842 if (skb
->ip_summed
!= CHECKSUM_PARTIAL
)
845 d
->dma
.b11
= ETH_HLEN
; /* MAC header length */
847 switch (skb
->protocol
) {
848 case cpu_to_be16(ETH_P_IP
):
849 protocol
= ip_hdr(skb
)->protocol
;
850 d
->dma
.b11
|= BIT(DMA_CFG_DESC_TX_OFFLOAD_CFG_L3T_IPV4_POS
);
852 case cpu_to_be16(ETH_P_IPV6
):
853 protocol
= ipv6_hdr(skb
)->nexthdr
;
861 d
->dma
.d0
|= (2 << DMA_CFG_DESC_TX_0_L4_TYPE_POS
);
862 /* L4 header len: TCP header length */
864 (tcp_hdrlen(skb
) & DMA_CFG_DESC_TX_0_L4_LENGTH_MSK
);
867 /* L4 header len: UDP header length */
869 (sizeof(struct udphdr
) & DMA_CFG_DESC_TX_0_L4_LENGTH_MSK
);
875 d
->dma
.ip_length
= skb_network_header_len(skb
);
876 /* Enable TCP/UDP checksum */
877 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_TCP_UDP_CHECKSUM_EN_POS
);
878 /* Calculate pseudo-header */
879 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_PSEUDO_HEADER_CALC_EN_POS
);
884 static int wil_tx_vring(struct wil6210_priv
*wil
, struct vring
*vring
,
887 struct device
*dev
= wil_to_dev(wil
);
888 struct vring_tx_desc dd
, *d
= &dd
;
889 volatile struct vring_tx_desc
*_d
;
890 u32 swhead
= vring
->swhead
;
891 int avail
= wil_vring_avail_tx(vring
);
892 int nr_frags
= skb_shinfo(skb
)->nr_frags
;
894 int vring_index
= vring
- wil
->vring_tx
;
895 struct vring_tx_data
*txdata
= &wil
->vring_tx_data
[vring_index
];
899 wil_dbg_txrx(wil
, "%s()\n", __func__
);
901 if (avail
< 1 + nr_frags
) {
902 wil_err(wil
, "Tx ring full. No space for %d fragments\n",
906 _d
= &(vring
->va
[i
].tx
);
908 pa
= dma_map_single(dev
, skb
->data
,
909 skb_headlen(skb
), DMA_TO_DEVICE
);
911 wil_dbg_txrx(wil
, "Tx skb %d bytes 0x%p -> %pad\n", skb_headlen(skb
),
913 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_OFFSET
, 16, 1,
914 skb
->data
, skb_headlen(skb
), false);
916 if (unlikely(dma_mapping_error(dev
, pa
)))
918 vring
->ctx
[i
].mapped_as
= wil_mapped_as_single
;
920 wil_tx_desc_map(d
, pa
, skb_headlen(skb
), vring_index
);
921 /* Process TCP/UDP checksum offloading */
922 if (wil_tx_desc_offload_cksum_set(wil
, d
, skb
)) {
923 wil_err(wil
, "VRING #%d Failed to set cksum, drop packet\n",
928 vring
->ctx
[i
].nr_frags
= nr_frags
;
929 wil_tx_desc_set_nr_frags(d
, nr_frags
);
933 /* middle segments */
934 for (; f
< nr_frags
; f
++) {
935 const struct skb_frag_struct
*frag
=
936 &skb_shinfo(skb
)->frags
[f
];
937 int len
= skb_frag_size(frag
);
938 i
= (swhead
+ f
+ 1) % vring
->size
;
939 _d
= &(vring
->va
[i
].tx
);
940 pa
= skb_frag_dma_map(dev
, frag
, 0, skb_frag_size(frag
),
942 if (unlikely(dma_mapping_error(dev
, pa
)))
944 vring
->ctx
[i
].mapped_as
= wil_mapped_as_page
;
945 wil_tx_desc_map(d
, pa
, len
, vring_index
);
946 /* no need to check return code -
947 * if it succeeded for 1-st descriptor,
948 * it will succeed here too
950 wil_tx_desc_offload_cksum_set(wil
, d
, skb
);
953 /* for the last seg only */
954 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_EOP_POS
);
955 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_MARK_WB_POS
);
956 d
->dma
.d0
|= BIT(DMA_CFG_DESC_TX_0_CMD_DMA_IT_POS
);
959 /* hold reference to skb
960 * to prevent skb release before accounting
961 * in case of immediate "tx done"
963 vring
->ctx
[i
].skb
= skb_get(skb
);
965 wil_hex_dump_txrx("Tx ", DUMP_PREFIX_NONE
, 32, 4,
966 (const void *)d
, sizeof(*d
), false);
968 if (wil_vring_is_empty(vring
)) /* performance monitoring */
969 txdata
->idle
+= get_cycles() - txdata
->last_idle
;
972 wil_vring_advance_head(vring
, nr_frags
+ 1);
973 wil_dbg_txrx(wil
, "Tx swhead %d -> %d\n", swhead
, vring
->swhead
);
974 trace_wil6210_tx(vring_index
, swhead
, skb
->len
, nr_frags
);
975 iowrite32(vring
->swhead
, wil
->csr
+ HOSTADDR(vring
->hwtail
));
979 /* unmap what we have mapped */
980 nr_frags
= f
+ 1; /* frags mapped + one for skb head */
981 for (f
= 0; f
< nr_frags
; f
++) {
984 i
= (swhead
+ f
) % vring
->size
;
985 ctx
= &vring
->ctx
[i
];
986 _d
= &(vring
->va
[i
].tx
);
988 _d
->dma
.status
= TX_DMA_STATUS_DU
;
989 wil_txdesc_unmap(dev
, d
, ctx
);
992 dev_kfree_skb_any(ctx
->skb
);
994 memset(ctx
, 0, sizeof(*ctx
));
1001 netdev_tx_t
wil_start_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
1003 struct wil6210_priv
*wil
= ndev_to_wil(ndev
);
1004 struct ethhdr
*eth
= (void *)skb
->data
;
1005 struct vring
*vring
;
1006 static bool pr_once_fw
;
1009 wil_dbg_txrx(wil
, "%s()\n", __func__
);
1010 if (!test_bit(wil_status_fwready
, &wil
->status
)) {
1012 wil_err(wil
, "FW not ready\n");
1017 if (!test_bit(wil_status_fwconnected
, &wil
->status
)) {
1018 wil_err(wil
, "FW not connected\n");
1021 if (wil
->wdev
->iftype
== NL80211_IFTYPE_MONITOR
) {
1022 wil_err(wil
, "Xmit in monitor mode not supported\n");
1028 if (is_unicast_ether_addr(eth
->h_dest
)) {
1029 vring
= wil_find_tx_vring(wil
, skb
);
1031 vring
= wil_tx_bcast(wil
, skb
);
1034 wil_dbg_txrx(wil
, "No Tx VRING found for %pM\n", eth
->h_dest
);
1037 /* set up vring entry */
1038 rc
= wil_tx_vring(wil
, vring
, skb
);
1040 /* do we still have enough room in the vring? */
1041 if (wil_vring_avail_tx(vring
) < wil_vring_wmark_low(vring
)) {
1042 netif_tx_stop_all_queues(wil_to_ndev(wil
));
1043 wil_dbg_txrx(wil
, "netif_tx_stop : ring full\n");
1048 /* statistics will be updated on the tx_complete */
1049 dev_kfree_skb_any(skb
);
1050 return NETDEV_TX_OK
;
1052 return NETDEV_TX_BUSY
;
1054 break; /* goto drop; */
1057 ndev
->stats
.tx_dropped
++;
1058 dev_kfree_skb_any(skb
);
1060 return NET_XMIT_DROP
;
1064 * Clean up transmitted skb's from the Tx VRING
1066 * Return number of descriptors cleared
1068 * Safe to call from IRQ
1070 int wil_tx_complete(struct wil6210_priv
*wil
, int ringid
)
1072 struct net_device
*ndev
= wil_to_ndev(wil
);
1073 struct device
*dev
= wil_to_dev(wil
);
1074 struct vring
*vring
= &wil
->vring_tx
[ringid
];
1075 struct vring_tx_data
*txdata
= &wil
->vring_tx_data
[ringid
];
1077 int cid
= wil
->vring2cid_tid
[ringid
][0];
1078 struct wil_net_stats
*stats
= &wil
->sta
[cid
].stats
;
1079 volatile struct vring_tx_desc
*_d
;
1082 wil_err(wil
, "Tx irq[%d]: vring not initialized\n", ringid
);
1086 if (!txdata
->enabled
) {
1087 wil_info(wil
, "Tx irq[%d]: vring disabled\n", ringid
);
1091 wil_dbg_txrx(wil
, "%s(%d)\n", __func__
, ringid
);
1093 while (!wil_vring_is_empty(vring
)) {
1095 struct wil_ctx
*ctx
= &vring
->ctx
[vring
->swtail
];
1097 * For the fragmented skb, HW will set DU bit only for the
1098 * last fragment. look for it
1100 int lf
= (vring
->swtail
+ ctx
->nr_frags
) % vring
->size
;
1101 /* TODO: check we are not past head */
1103 _d
= &vring
->va
[lf
].tx
;
1104 if (!(_d
->dma
.status
& TX_DMA_STATUS_DU
))
1107 new_swtail
= (lf
+ 1) % vring
->size
;
1108 while (vring
->swtail
!= new_swtail
) {
1109 struct vring_tx_desc dd
, *d
= &dd
;
1111 struct sk_buff
*skb
;
1113 ctx
= &vring
->ctx
[vring
->swtail
];
1115 _d
= &vring
->va
[vring
->swtail
].tx
;
1119 dmalen
= le16_to_cpu(d
->dma
.length
);
1120 trace_wil6210_tx_done(ringid
, vring
->swtail
, dmalen
,
1123 "Tx[%3d] : %d bytes, status 0x%02x err 0x%02x\n",
1124 vring
->swtail
, dmalen
, d
->dma
.status
,
1126 wil_hex_dump_txrx("TxC ", DUMP_PREFIX_NONE
, 32, 4,
1127 (const void *)d
, sizeof(*d
), false);
1129 wil_txdesc_unmap(dev
, d
, ctx
);
1132 if (d
->dma
.error
== 0) {
1133 ndev
->stats
.tx_packets
++;
1134 stats
->tx_packets
++;
1135 ndev
->stats
.tx_bytes
+= skb
->len
;
1136 stats
->tx_bytes
+= skb
->len
;
1138 ndev
->stats
.tx_errors
++;
1142 dev_kfree_skb_any(skb
);
1144 memset(ctx
, 0, sizeof(*ctx
));
1145 /* There is no need to touch HW descriptor:
1146 * - ststus bit TX_DMA_STATUS_DU is set by design,
1147 * so hardware will not try to process this desc.,
1148 * - rest of descriptor will be initialized on Tx.
1150 vring
->swtail
= wil_vring_next_tail(vring
);
1155 if (wil_vring_is_empty(vring
)) { /* performance monitoring */
1156 wil_dbg_txrx(wil
, "Ring[%2d] empty\n", ringid
);
1157 txdata
->last_idle
= get_cycles();
1160 if (wil_vring_avail_tx(vring
) > wil_vring_wmark_high(vring
)) {
1161 wil_dbg_txrx(wil
, "netif_tx_wake : ring not full\n");
1162 netif_tx_wake_all_queues(wil_to_ndev(wil
));