2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 QLogic Corporation
5 * See LICENSE.qlcnic for copyright and licensing details.
8 #include <linux/netdevice.h>
9 #include <linux/if_vlan.h>
11 #include <linux/ipv6.h>
12 #include <net/checksum.h>
16 #define TX_ETHER_PKT 0x01
17 #define TX_TCP_PKT 0x02
18 #define TX_UDP_PKT 0x03
19 #define TX_IP_PKT 0x04
20 #define TX_TCP_LSO 0x05
21 #define TX_TCP_LSO6 0x06
22 #define TX_TCPV6_PKT 0x0b
23 #define TX_UDPV6_PKT 0x0c
24 #define FLAGS_VLAN_TAGGED 0x10
25 #define FLAGS_VLAN_OOB 0x40
27 #define qlcnic_set_tx_vlan_tci(cmd_desc, v) \
28 (cmd_desc)->vlan_TCI = cpu_to_le16(v);
29 #define qlcnic_set_cmd_desc_port(cmd_desc, var) \
30 ((cmd_desc)->port_ctxid |= ((var) & 0x0F))
31 #define qlcnic_set_cmd_desc_ctxid(cmd_desc, var) \
32 ((cmd_desc)->port_ctxid |= ((var) << 4 & 0xF0))
34 #define qlcnic_set_tx_port(_desc, _port) \
35 ((_desc)->port_ctxid = ((_port) & 0xf) | (((_port) << 4) & 0xf0))
37 #define qlcnic_set_tx_flags_opcode(_desc, _flags, _opcode) \
38 ((_desc)->flags_opcode |= \
39 cpu_to_le16(((_flags) & 0x7f) | (((_opcode) & 0x3f) << 7)))
41 #define qlcnic_set_tx_frags_len(_desc, _frags, _len) \
42 ((_desc)->nfrags__length = \
43 cpu_to_le32(((_frags) & 0xff) | (((_len) & 0xffffff) << 8)))
45 /* owner bits of status_desc */
46 #define STATUS_OWNER_HOST (0x1ULL << 56)
47 #define STATUS_OWNER_PHANTOM (0x2ULL << 56)
50 0-3 port, 4-7 status, 8-11 type, 12-27 total_length
51 28-43 reference_handle, 44-47 protocol, 48-52 pkt_offset
52 53-55 desc_cnt, 56-57 owner, 58-63 opcode
54 #define qlcnic_get_sts_port(sts_data) \
56 #define qlcnic_get_sts_status(sts_data) \
57 (((sts_data) >> 4) & 0x0F)
58 #define qlcnic_get_sts_type(sts_data) \
59 (((sts_data) >> 8) & 0x0F)
60 #define qlcnic_get_sts_totallength(sts_data) \
61 (((sts_data) >> 12) & 0xFFFF)
62 #define qlcnic_get_sts_refhandle(sts_data) \
63 (((sts_data) >> 28) & 0xFFFF)
64 #define qlcnic_get_sts_prot(sts_data) \
65 (((sts_data) >> 44) & 0x0F)
66 #define qlcnic_get_sts_pkt_offset(sts_data) \
67 (((sts_data) >> 48) & 0x1F)
68 #define qlcnic_get_sts_desc_cnt(sts_data) \
69 (((sts_data) >> 53) & 0x7)
70 #define qlcnic_get_sts_opcode(sts_data) \
71 (((sts_data) >> 58) & 0x03F)
73 #define qlcnic_get_lro_sts_refhandle(sts_data) \
74 ((sts_data) & 0x07FFF)
75 #define qlcnic_get_lro_sts_length(sts_data) \
76 (((sts_data) >> 16) & 0x0FFFF)
77 #define qlcnic_get_lro_sts_l2_hdr_offset(sts_data) \
78 (((sts_data) >> 32) & 0x0FF)
79 #define qlcnic_get_lro_sts_l4_hdr_offset(sts_data) \
80 (((sts_data) >> 40) & 0x0FF)
81 #define qlcnic_get_lro_sts_timestamp(sts_data) \
82 (((sts_data) >> 48) & 0x1)
83 #define qlcnic_get_lro_sts_type(sts_data) \
84 (((sts_data) >> 49) & 0x7)
85 #define qlcnic_get_lro_sts_push_flag(sts_data) \
86 (((sts_data) >> 52) & 0x1)
87 #define qlcnic_get_lro_sts_seq_number(sts_data) \
88 ((sts_data) & 0x0FFFFFFFF)
89 #define qlcnic_get_lro_sts_mss(sts_data1) \
90 ((sts_data1 >> 32) & 0x0FFFF)
92 #define qlcnic_83xx_get_lro_sts_mss(sts) ((sts) & 0xffff)
94 /* opcode field in status_desc */
95 #define QLCNIC_SYN_OFFLOAD 0x03
96 #define QLCNIC_RXPKT_DESC 0x04
97 #define QLCNIC_OLD_RXPKT_DESC 0x3f
98 #define QLCNIC_RESPONSE_DESC 0x05
99 #define QLCNIC_LRO_DESC 0x12
101 #define QLCNIC_TX_POLL_BUDGET 128
102 #define QLCNIC_TCP_HDR_SIZE 20
103 #define QLCNIC_TCP_TS_OPTION_SIZE 12
104 #define QLCNIC_FETCH_RING_ID(handle) ((handle) >> 63)
105 #define QLCNIC_DESC_OWNER_FW cpu_to_le64(STATUS_OWNER_PHANTOM)
107 #define QLCNIC_TCP_TS_HDR_SIZE (QLCNIC_TCP_HDR_SIZE + QLCNIC_TCP_TS_OPTION_SIZE)
109 /* for status field in status_desc */
110 #define STATUS_CKSUM_LOOP 0
111 #define STATUS_CKSUM_OK 2
113 #define qlcnic_83xx_pktln(sts) ((sts >> 32) & 0x3FFF)
114 #define qlcnic_83xx_hndl(sts) ((sts >> 48) & 0x7FFF)
115 #define qlcnic_83xx_csum_status(sts) ((sts >> 39) & 7)
116 #define qlcnic_83xx_opcode(sts) ((sts >> 42) & 0xF)
117 #define qlcnic_83xx_vlan_tag(sts) (((sts) >> 48) & 0xFFFF)
118 #define qlcnic_83xx_lro_pktln(sts) (((sts) >> 32) & 0x3FFF)
119 #define qlcnic_83xx_l2_hdr_off(sts) (((sts) >> 16) & 0xFF)
120 #define qlcnic_83xx_l4_hdr_off(sts) (((sts) >> 24) & 0xFF)
121 #define qlcnic_83xx_pkt_cnt(sts) (((sts) >> 16) & 0x7)
122 #define qlcnic_83xx_is_tstamp(sts) (((sts) >> 40) & 1)
123 #define qlcnic_83xx_is_psh_bit(sts) (((sts) >> 41) & 1)
124 #define qlcnic_83xx_is_ip_align(sts) (((sts) >> 46) & 1)
125 #define qlcnic_83xx_has_vlan_tag(sts) (((sts) >> 47) & 1)
127 struct sk_buff
*qlcnic_process_rxbuf(struct qlcnic_adapter
*,
128 struct qlcnic_host_rds_ring
*, u16
, u16
);
130 inline void qlcnic_enable_tx_intr(struct qlcnic_adapter
*adapter
,
131 struct qlcnic_host_tx_ring
*tx_ring
)
133 if (qlcnic_check_multi_tx(adapter
) &&
134 !adapter
->ahw
->diag_test
)
135 writel(0x0, tx_ring
->crb_intr_mask
);
139 static inline void qlcnic_disable_tx_int(struct qlcnic_adapter
*adapter
,
140 struct qlcnic_host_tx_ring
*tx_ring
)
142 if (qlcnic_check_multi_tx(adapter
) &&
143 !adapter
->ahw
->diag_test
)
144 writel(1, tx_ring
->crb_intr_mask
);
147 inline void qlcnic_83xx_enable_tx_intr(struct qlcnic_adapter
*adapter
,
148 struct qlcnic_host_tx_ring
*tx_ring
)
150 writel(0, tx_ring
->crb_intr_mask
);
153 inline void qlcnic_83xx_disable_tx_intr(struct qlcnic_adapter
*adapter
,
154 struct qlcnic_host_tx_ring
*tx_ring
)
156 writel(1, tx_ring
->crb_intr_mask
);
159 static inline u8
qlcnic_mac_hash(u64 mac
)
161 return (u8
)((mac
& 0xff) ^ ((mac
>> 40) & 0xff));
164 static inline u32
qlcnic_get_ref_handle(struct qlcnic_adapter
*adapter
,
165 u16 handle
, u8 ring_id
)
167 if (qlcnic_83xx_check(adapter
))
168 return handle
| (ring_id
<< 15);
173 static inline int qlcnic_82xx_is_lb_pkt(u64 sts_data
)
175 return (qlcnic_get_sts_status(sts_data
) == STATUS_CKSUM_LOOP
) ? 1 : 0;
178 static void qlcnic_delete_rx_list_mac(struct qlcnic_adapter
*adapter
,
179 struct qlcnic_filter
*fil
,
180 void *addr
, u16 vlan_id
)
185 op
= vlan_id
? QLCNIC_MAC_VLAN_ADD
: QLCNIC_MAC_ADD
;
186 ret
= qlcnic_sre_macaddr_change(adapter
, addr
, vlan_id
, op
);
190 op
= vlan_id
? QLCNIC_MAC_VLAN_DEL
: QLCNIC_MAC_DEL
;
191 ret
= qlcnic_sre_macaddr_change(adapter
, addr
, vlan_id
, op
);
193 hlist_del(&fil
->fnode
);
194 adapter
->rx_fhash
.fnum
--;
198 static struct qlcnic_filter
*qlcnic_find_mac_filter(struct hlist_head
*head
,
199 void *addr
, u16 vlan_id
)
201 struct qlcnic_filter
*tmp_fil
= NULL
;
202 struct hlist_node
*n
;
204 hlist_for_each_entry_safe(tmp_fil
, n
, head
, fnode
) {
205 if (!memcmp(tmp_fil
->faddr
, addr
, ETH_ALEN
) &&
206 tmp_fil
->vlan_id
== vlan_id
)
213 void qlcnic_add_lb_filter(struct qlcnic_adapter
*adapter
, struct sk_buff
*skb
,
214 int loopback_pkt
, u16 vlan_id
)
216 struct ethhdr
*phdr
= (struct ethhdr
*)(skb
->data
);
217 struct qlcnic_filter
*fil
, *tmp_fil
;
218 struct hlist_head
*head
;
224 memcpy(&src_addr
, phdr
->h_source
, ETH_ALEN
);
225 hindex
= qlcnic_mac_hash(src_addr
) &
226 (adapter
->fhash
.fbucket_size
- 1);
229 if (adapter
->rx_fhash
.fnum
>= adapter
->rx_fhash
.fmax
)
232 head
= &(adapter
->rx_fhash
.fhead
[hindex
]);
234 tmp_fil
= qlcnic_find_mac_filter(head
, &src_addr
, vlan_id
);
236 time
= tmp_fil
->ftime
;
237 if (time_after(jiffies
, QLCNIC_READD_AGE
* HZ
+ time
))
238 tmp_fil
->ftime
= jiffies
;
242 fil
= kzalloc(sizeof(struct qlcnic_filter
), GFP_ATOMIC
);
246 fil
->ftime
= jiffies
;
247 memcpy(fil
->faddr
, &src_addr
, ETH_ALEN
);
248 fil
->vlan_id
= vlan_id
;
249 spin_lock(&adapter
->rx_mac_learn_lock
);
250 hlist_add_head(&(fil
->fnode
), head
);
251 adapter
->rx_fhash
.fnum
++;
252 spin_unlock(&adapter
->rx_mac_learn_lock
);
254 head
= &adapter
->fhash
.fhead
[hindex
];
256 spin_lock(&adapter
->mac_learn_lock
);
258 tmp_fil
= qlcnic_find_mac_filter(head
, &src_addr
, vlan_id
);
260 op
= vlan_id
? QLCNIC_MAC_VLAN_DEL
: QLCNIC_MAC_DEL
;
261 ret
= qlcnic_sre_macaddr_change(adapter
,
265 hlist_del(&tmp_fil
->fnode
);
266 adapter
->fhash
.fnum
--;
269 spin_unlock(&adapter
->mac_learn_lock
);
274 spin_unlock(&adapter
->mac_learn_lock
);
276 head
= &adapter
->rx_fhash
.fhead
[hindex
];
278 spin_lock(&adapter
->rx_mac_learn_lock
);
280 tmp_fil
= qlcnic_find_mac_filter(head
, &src_addr
, vlan_id
);
282 qlcnic_delete_rx_list_mac(adapter
, tmp_fil
, &src_addr
,
285 spin_unlock(&adapter
->rx_mac_learn_lock
);
289 void qlcnic_82xx_change_filter(struct qlcnic_adapter
*adapter
, u64
*uaddr
,
292 struct cmd_desc_type0
*hwdesc
;
293 struct qlcnic_nic_req
*req
;
294 struct qlcnic_mac_req
*mac_req
;
295 struct qlcnic_vlan_req
*vlan_req
;
296 struct qlcnic_host_tx_ring
*tx_ring
= adapter
->tx_ring
;
300 producer
= tx_ring
->producer
;
301 hwdesc
= &tx_ring
->desc_head
[tx_ring
->producer
];
303 req
= (struct qlcnic_nic_req
*)hwdesc
;
304 memset(req
, 0, sizeof(struct qlcnic_nic_req
));
305 req
->qhdr
= cpu_to_le64(QLCNIC_REQUEST
<< 23);
307 word
= QLCNIC_MAC_EVENT
| ((u64
)(adapter
->portnum
) << 16);
308 req
->req_hdr
= cpu_to_le64(word
);
310 mac_req
= (struct qlcnic_mac_req
*)&(req
->words
[0]);
311 mac_req
->op
= vlan_id
? QLCNIC_MAC_VLAN_ADD
: QLCNIC_MAC_ADD
;
312 memcpy(mac_req
->mac_addr
, uaddr
, ETH_ALEN
);
314 vlan_req
= (struct qlcnic_vlan_req
*)&req
->words
[1];
315 vlan_req
->vlan_id
= cpu_to_le16(vlan_id
);
317 tx_ring
->producer
= get_next_index(producer
, tx_ring
->num_desc
);
321 static void qlcnic_send_filter(struct qlcnic_adapter
*adapter
,
322 struct cmd_desc_type0
*first_desc
,
325 struct qlcnic_filter
*fil
, *tmp_fil
;
326 struct hlist_node
*n
;
327 struct hlist_head
*head
;
328 struct net_device
*netdev
= adapter
->netdev
;
329 struct ethhdr
*phdr
= (struct ethhdr
*)(skb
->data
);
334 if (ether_addr_equal(phdr
->h_source
, adapter
->mac_addr
))
337 if (adapter
->fhash
.fnum
>= adapter
->fhash
.fmax
) {
338 adapter
->stats
.mac_filter_limit_overrun
++;
339 netdev_info(netdev
, "Can not add more than %d mac addresses\n",
340 adapter
->fhash
.fmax
);
344 memcpy(&src_addr
, phdr
->h_source
, ETH_ALEN
);
345 hindex
= qlcnic_mac_hash(src_addr
) & (adapter
->fhash
.fbucket_size
- 1);
346 head
= &(adapter
->fhash
.fhead
[hindex
]);
348 hlist_for_each_entry_safe(tmp_fil
, n
, head
, fnode
) {
349 if (!memcmp(tmp_fil
->faddr
, &src_addr
, ETH_ALEN
) &&
350 tmp_fil
->vlan_id
== vlan_id
) {
351 if (jiffies
> (QLCNIC_READD_AGE
* HZ
+ tmp_fil
->ftime
))
352 qlcnic_change_filter(adapter
, &src_addr
,
354 tmp_fil
->ftime
= jiffies
;
359 fil
= kzalloc(sizeof(struct qlcnic_filter
), GFP_ATOMIC
);
363 qlcnic_change_filter(adapter
, &src_addr
, vlan_id
);
364 fil
->ftime
= jiffies
;
365 fil
->vlan_id
= vlan_id
;
366 memcpy(fil
->faddr
, &src_addr
, ETH_ALEN
);
367 spin_lock(&adapter
->mac_learn_lock
);
368 hlist_add_head(&(fil
->fnode
), head
);
369 adapter
->fhash
.fnum
++;
370 spin_unlock(&adapter
->mac_learn_lock
);
373 static int qlcnic_tx_pkt(struct qlcnic_adapter
*adapter
,
374 struct cmd_desc_type0
*first_desc
, struct sk_buff
*skb
,
375 struct qlcnic_host_tx_ring
*tx_ring
)
377 u8 l4proto
, opcode
= 0, hdr_len
= 0;
378 u16 flags
= 0, vlan_tci
= 0;
379 int copied
, offset
, copy_len
, size
;
380 struct cmd_desc_type0
*hwdesc
;
381 struct vlan_ethhdr
*vh
;
382 u16 protocol
= ntohs(skb
->protocol
);
383 u32 producer
= tx_ring
->producer
;
385 if (protocol
== ETH_P_8021Q
) {
386 vh
= (struct vlan_ethhdr
*)skb
->data
;
387 flags
= FLAGS_VLAN_TAGGED
;
388 vlan_tci
= ntohs(vh
->h_vlan_TCI
);
389 protocol
= ntohs(vh
->h_vlan_encapsulated_proto
);
390 } else if (vlan_tx_tag_present(skb
)) {
391 flags
= FLAGS_VLAN_OOB
;
392 vlan_tci
= vlan_tx_tag_get(skb
);
394 if (unlikely(adapter
->tx_pvid
)) {
395 if (vlan_tci
&& !(adapter
->flags
& QLCNIC_TAGGING_ENABLED
))
397 if (vlan_tci
&& (adapter
->flags
& QLCNIC_TAGGING_ENABLED
))
400 flags
= FLAGS_VLAN_OOB
;
401 vlan_tci
= adapter
->tx_pvid
;
404 qlcnic_set_tx_vlan_tci(first_desc
, vlan_tci
);
405 qlcnic_set_tx_flags_opcode(first_desc
, flags
, opcode
);
407 if (*(skb
->data
) & BIT_0
) {
409 memcpy(&first_desc
->eth_addr
, skb
->data
, ETH_ALEN
);
411 opcode
= TX_ETHER_PKT
;
412 if (skb_is_gso(skb
)) {
413 hdr_len
= skb_transport_offset(skb
) + tcp_hdrlen(skb
);
414 first_desc
->mss
= cpu_to_le16(skb_shinfo(skb
)->gso_size
);
415 first_desc
->total_hdr_length
= hdr_len
;
416 opcode
= (protocol
== ETH_P_IPV6
) ? TX_TCP_LSO6
: TX_TCP_LSO
;
418 /* For LSO, we need to copy the MAC/IP/TCP headers into
419 * the descriptor ring */
423 if (flags
& FLAGS_VLAN_OOB
) {
424 first_desc
->total_hdr_length
+= VLAN_HLEN
;
425 first_desc
->tcp_hdr_offset
= VLAN_HLEN
;
426 first_desc
->ip_hdr_offset
= VLAN_HLEN
;
428 /* Only in case of TSO on vlan device */
429 flags
|= FLAGS_VLAN_TAGGED
;
431 /* Create a TSO vlan header template for firmware */
432 hwdesc
= &tx_ring
->desc_head
[producer
];
433 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
435 copy_len
= min((int)sizeof(struct cmd_desc_type0
) -
436 offset
, hdr_len
+ VLAN_HLEN
);
438 vh
= (struct vlan_ethhdr
*)((char *) hwdesc
+ 2);
439 skb_copy_from_linear_data(skb
, vh
, 12);
440 vh
->h_vlan_proto
= htons(ETH_P_8021Q
);
441 vh
->h_vlan_TCI
= htons(vlan_tci
);
443 skb_copy_from_linear_data_offset(skb
, 12,
446 copied
= copy_len
- VLAN_HLEN
;
448 producer
= get_next_index(producer
, tx_ring
->num_desc
);
451 while (copied
< hdr_len
) {
452 size
= (int)sizeof(struct cmd_desc_type0
) - offset
;
453 copy_len
= min(size
, (hdr_len
- copied
));
454 hwdesc
= &tx_ring
->desc_head
[producer
];
455 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
456 skb_copy_from_linear_data_offset(skb
, copied
,
461 producer
= get_next_index(producer
, tx_ring
->num_desc
);
464 tx_ring
->producer
= producer
;
466 adapter
->stats
.lso_frames
++;
468 } else if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
469 if (protocol
== ETH_P_IP
) {
470 l4proto
= ip_hdr(skb
)->protocol
;
472 if (l4proto
== IPPROTO_TCP
)
474 else if (l4proto
== IPPROTO_UDP
)
476 } else if (protocol
== ETH_P_IPV6
) {
477 l4proto
= ipv6_hdr(skb
)->nexthdr
;
479 if (l4proto
== IPPROTO_TCP
)
480 opcode
= TX_TCPV6_PKT
;
481 else if (l4proto
== IPPROTO_UDP
)
482 opcode
= TX_UDPV6_PKT
;
485 first_desc
->tcp_hdr_offset
+= skb_transport_offset(skb
);
486 first_desc
->ip_hdr_offset
+= skb_network_offset(skb
);
487 qlcnic_set_tx_flags_opcode(first_desc
, flags
, opcode
);
492 static int qlcnic_map_tx_skb(struct pci_dev
*pdev
, struct sk_buff
*skb
,
493 struct qlcnic_cmd_buffer
*pbuf
)
495 struct qlcnic_skb_frag
*nf
;
496 struct skb_frag_struct
*frag
;
500 nr_frags
= skb_shinfo(skb
)->nr_frags
;
501 nf
= &pbuf
->frag_array
[0];
503 map
= pci_map_single(pdev
, skb
->data
, skb_headlen(skb
),
505 if (pci_dma_mapping_error(pdev
, map
))
509 nf
->length
= skb_headlen(skb
);
511 for (i
= 0; i
< nr_frags
; i
++) {
512 frag
= &skb_shinfo(skb
)->frags
[i
];
513 nf
= &pbuf
->frag_array
[i
+1];
514 map
= skb_frag_dma_map(&pdev
->dev
, frag
, 0, skb_frag_size(frag
),
516 if (dma_mapping_error(&pdev
->dev
, map
))
520 nf
->length
= skb_frag_size(frag
);
527 nf
= &pbuf
->frag_array
[i
+1];
528 pci_unmap_page(pdev
, nf
->dma
, nf
->length
, PCI_DMA_TODEVICE
);
531 nf
= &pbuf
->frag_array
[0];
532 pci_unmap_single(pdev
, nf
->dma
, skb_headlen(skb
), PCI_DMA_TODEVICE
);
538 static void qlcnic_unmap_buffers(struct pci_dev
*pdev
, struct sk_buff
*skb
,
539 struct qlcnic_cmd_buffer
*pbuf
)
541 struct qlcnic_skb_frag
*nf
= &pbuf
->frag_array
[0];
542 int i
, nr_frags
= skb_shinfo(skb
)->nr_frags
;
544 for (i
= 0; i
< nr_frags
; i
++) {
545 nf
= &pbuf
->frag_array
[i
+1];
546 pci_unmap_page(pdev
, nf
->dma
, nf
->length
, PCI_DMA_TODEVICE
);
549 nf
= &pbuf
->frag_array
[0];
550 pci_unmap_single(pdev
, nf
->dma
, skb_headlen(skb
), PCI_DMA_TODEVICE
);
554 static inline void qlcnic_clear_cmddesc(u64
*desc
)
561 netdev_tx_t
qlcnic_xmit_frame(struct sk_buff
*skb
, struct net_device
*netdev
)
563 struct qlcnic_adapter
*adapter
= netdev_priv(netdev
);
564 struct qlcnic_host_tx_ring
*tx_ring
;
565 struct qlcnic_cmd_buffer
*pbuf
;
566 struct qlcnic_skb_frag
*buffrag
;
567 struct cmd_desc_type0
*hwdesc
, *first_desc
;
568 struct pci_dev
*pdev
;
570 int i
, k
, frag_count
, delta
= 0;
571 u32 producer
, num_txd
;
573 if (!test_bit(__QLCNIC_DEV_UP
, &adapter
->state
)) {
574 netif_tx_stop_all_queues(netdev
);
575 return NETDEV_TX_BUSY
;
578 if (adapter
->flags
& QLCNIC_MACSPOOF
) {
579 phdr
= (struct ethhdr
*)skb
->data
;
580 if (!ether_addr_equal(phdr
->h_source
, adapter
->mac_addr
))
584 tx_ring
= &adapter
->tx_ring
[skb_get_queue_mapping(skb
)];
585 num_txd
= tx_ring
->num_desc
;
587 frag_count
= skb_shinfo(skb
)->nr_frags
+ 1;
589 /* 14 frags supported for normal packet and
590 * 32 frags supported for TSO packet
592 if (!skb_is_gso(skb
) && frag_count
> QLCNIC_MAX_FRAGS_PER_TX
) {
593 for (i
= 0; i
< (frag_count
- QLCNIC_MAX_FRAGS_PER_TX
); i
++)
594 delta
+= skb_frag_size(&skb_shinfo(skb
)->frags
[i
]);
596 if (!__pskb_pull_tail(skb
, delta
))
599 frag_count
= 1 + skb_shinfo(skb
)->nr_frags
;
602 if (unlikely(qlcnic_tx_avail(tx_ring
) <= TX_STOP_THRESH
)) {
603 netif_tx_stop_queue(tx_ring
->txq
);
604 if (qlcnic_tx_avail(tx_ring
) > TX_STOP_THRESH
) {
605 netif_tx_start_queue(tx_ring
->txq
);
607 tx_ring
->tx_stats
.xmit_off
++;
608 return NETDEV_TX_BUSY
;
612 producer
= tx_ring
->producer
;
613 pbuf
= &tx_ring
->cmd_buf_arr
[producer
];
614 pdev
= adapter
->pdev
;
615 first_desc
= &tx_ring
->desc_head
[producer
];
616 hwdesc
= &tx_ring
->desc_head
[producer
];
617 qlcnic_clear_cmddesc((u64
*)hwdesc
);
619 if (qlcnic_map_tx_skb(pdev
, skb
, pbuf
)) {
620 adapter
->stats
.tx_dma_map_error
++;
625 pbuf
->frag_count
= frag_count
;
627 qlcnic_set_tx_frags_len(first_desc
, frag_count
, skb
->len
);
628 qlcnic_set_tx_port(first_desc
, adapter
->portnum
);
630 for (i
= 0; i
< frag_count
; i
++) {
633 if ((k
== 0) && (i
> 0)) {
634 /* move to next desc.*/
635 producer
= get_next_index(producer
, num_txd
);
636 hwdesc
= &tx_ring
->desc_head
[producer
];
637 qlcnic_clear_cmddesc((u64
*)hwdesc
);
638 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
641 buffrag
= &pbuf
->frag_array
[i
];
642 hwdesc
->buffer_length
[k
] = cpu_to_le16(buffrag
->length
);
645 hwdesc
->addr_buffer1
= cpu_to_le64(buffrag
->dma
);
648 hwdesc
->addr_buffer2
= cpu_to_le64(buffrag
->dma
);
651 hwdesc
->addr_buffer3
= cpu_to_le64(buffrag
->dma
);
654 hwdesc
->addr_buffer4
= cpu_to_le64(buffrag
->dma
);
659 tx_ring
->producer
= get_next_index(producer
, num_txd
);
662 if (unlikely(qlcnic_tx_pkt(adapter
, first_desc
, skb
, tx_ring
)))
665 if (adapter
->drv_mac_learn
)
666 qlcnic_send_filter(adapter
, first_desc
, skb
);
668 tx_ring
->tx_stats
.tx_bytes
+= skb
->len
;
669 tx_ring
->tx_stats
.xmit_called
++;
671 qlcnic_update_cmd_producer(tx_ring
);
676 qlcnic_unmap_buffers(pdev
, skb
, pbuf
);
678 adapter
->stats
.txdropped
++;
679 dev_kfree_skb_any(skb
);
683 void qlcnic_advert_link_change(struct qlcnic_adapter
*adapter
, int linkup
)
685 struct net_device
*netdev
= adapter
->netdev
;
687 if (adapter
->ahw
->linkup
&& !linkup
) {
688 netdev_info(netdev
, "NIC Link is down\n");
689 adapter
->ahw
->linkup
= 0;
690 netif_carrier_off(netdev
);
691 } else if (!adapter
->ahw
->linkup
&& linkup
) {
692 /* Do not advertise Link up if the port is in loopback mode */
693 if (qlcnic_83xx_check(adapter
) && adapter
->ahw
->lb_mode
)
696 netdev_info(netdev
, "NIC Link is up\n");
697 adapter
->ahw
->linkup
= 1;
698 netif_carrier_on(netdev
);
702 static int qlcnic_alloc_rx_skb(struct qlcnic_adapter
*adapter
,
703 struct qlcnic_host_rds_ring
*rds_ring
,
704 struct qlcnic_rx_buffer
*buffer
)
708 struct pci_dev
*pdev
= adapter
->pdev
;
710 skb
= netdev_alloc_skb(adapter
->netdev
, rds_ring
->skb_size
);
712 adapter
->stats
.skb_alloc_failure
++;
716 skb_reserve(skb
, NET_IP_ALIGN
);
717 dma
= pci_map_single(pdev
, skb
->data
,
718 rds_ring
->dma_size
, PCI_DMA_FROMDEVICE
);
720 if (pci_dma_mapping_error(pdev
, dma
)) {
721 adapter
->stats
.rx_dma_map_error
++;
722 dev_kfree_skb_any(skb
);
732 static void qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter
*adapter
,
733 struct qlcnic_host_rds_ring
*rds_ring
,
736 struct rcv_desc
*pdesc
;
737 struct qlcnic_rx_buffer
*buffer
;
739 uint32_t producer
, handle
;
740 struct list_head
*head
;
742 if (!spin_trylock(&rds_ring
->lock
))
745 producer
= rds_ring
->producer
;
746 head
= &rds_ring
->free_list
;
747 while (!list_empty(head
)) {
748 buffer
= list_entry(head
->next
, struct qlcnic_rx_buffer
, list
);
751 if (qlcnic_alloc_rx_skb(adapter
, rds_ring
, buffer
))
755 list_del(&buffer
->list
);
757 /* make a rcv descriptor */
758 pdesc
= &rds_ring
->desc_head
[producer
];
759 handle
= qlcnic_get_ref_handle(adapter
,
760 buffer
->ref_handle
, ring_id
);
761 pdesc
->reference_handle
= cpu_to_le16(handle
);
762 pdesc
->buffer_length
= cpu_to_le32(rds_ring
->dma_size
);
763 pdesc
->addr_buffer
= cpu_to_le64(buffer
->dma
);
764 producer
= get_next_index(producer
, rds_ring
->num_desc
);
767 rds_ring
->producer
= producer
;
768 writel((producer
- 1) & (rds_ring
->num_desc
- 1),
769 rds_ring
->crb_rcv_producer
);
771 spin_unlock(&rds_ring
->lock
);
774 static int qlcnic_process_cmd_ring(struct qlcnic_adapter
*adapter
,
775 struct qlcnic_host_tx_ring
*tx_ring
,
778 u32 sw_consumer
, hw_consumer
;
779 int i
, done
, count
= 0;
780 struct qlcnic_cmd_buffer
*buffer
;
781 struct pci_dev
*pdev
= adapter
->pdev
;
782 struct net_device
*netdev
= adapter
->netdev
;
783 struct qlcnic_skb_frag
*frag
;
785 if (!spin_trylock(&adapter
->tx_clean_lock
))
788 sw_consumer
= tx_ring
->sw_consumer
;
789 hw_consumer
= le32_to_cpu(*(tx_ring
->hw_consumer
));
791 while (sw_consumer
!= hw_consumer
) {
792 buffer
= &tx_ring
->cmd_buf_arr
[sw_consumer
];
794 frag
= &buffer
->frag_array
[0];
795 pci_unmap_single(pdev
, frag
->dma
, frag
->length
,
798 for (i
= 1; i
< buffer
->frag_count
; i
++) {
800 pci_unmap_page(pdev
, frag
->dma
, frag
->length
,
804 tx_ring
->tx_stats
.xmit_finished
++;
805 dev_kfree_skb_any(buffer
->skb
);
809 sw_consumer
= get_next_index(sw_consumer
, tx_ring
->num_desc
);
810 if (++count
>= budget
)
814 if (count
&& netif_running(netdev
)) {
815 tx_ring
->sw_consumer
= sw_consumer
;
817 if (netif_tx_queue_stopped(tx_ring
->txq
) &&
818 netif_carrier_ok(netdev
)) {
819 if (qlcnic_tx_avail(tx_ring
) > TX_STOP_THRESH
) {
820 netif_tx_wake_queue(tx_ring
->txq
);
821 tx_ring
->tx_stats
.xmit_on
++;
824 adapter
->tx_timeo_cnt
= 0;
827 * If everything is freed up to consumer then check if the ring is full
828 * If the ring is full then check if more needs to be freed and
829 * schedule the call back again.
831 * This happens when there are 2 CPUs. One could be freeing and the
832 * other filling it. If the ring is full when we get out of here and
833 * the card has already interrupted the host then the host can miss the
836 * There is still a possible race condition and the host could miss an
837 * interrupt. The card has to take care of this.
839 hw_consumer
= le32_to_cpu(*(tx_ring
->hw_consumer
));
840 done
= (sw_consumer
== hw_consumer
);
841 spin_unlock(&adapter
->tx_clean_lock
);
846 static int qlcnic_poll(struct napi_struct
*napi
, int budget
)
848 int tx_complete
, work_done
;
849 struct qlcnic_host_sds_ring
*sds_ring
;
850 struct qlcnic_adapter
*adapter
;
851 struct qlcnic_host_tx_ring
*tx_ring
;
853 sds_ring
= container_of(napi
, struct qlcnic_host_sds_ring
, napi
);
854 adapter
= sds_ring
->adapter
;
855 tx_ring
= sds_ring
->tx_ring
;
857 tx_complete
= qlcnic_process_cmd_ring(adapter
, tx_ring
,
859 work_done
= qlcnic_process_rcv_ring(sds_ring
, budget
);
860 if ((work_done
< budget
) && tx_complete
) {
861 napi_complete(&sds_ring
->napi
);
862 if (test_bit(__QLCNIC_DEV_UP
, &adapter
->state
)) {
863 qlcnic_enable_int(sds_ring
);
864 qlcnic_enable_tx_intr(adapter
, tx_ring
);
871 static int qlcnic_tx_poll(struct napi_struct
*napi
, int budget
)
873 struct qlcnic_host_tx_ring
*tx_ring
;
874 struct qlcnic_adapter
*adapter
;
877 tx_ring
= container_of(napi
, struct qlcnic_host_tx_ring
, napi
);
878 adapter
= tx_ring
->adapter
;
880 work_done
= qlcnic_process_cmd_ring(adapter
, tx_ring
, budget
);
882 napi_complete(&tx_ring
->napi
);
883 if (test_bit(__QLCNIC_DEV_UP
, &adapter
->state
))
884 qlcnic_enable_tx_intr(adapter
, tx_ring
);
890 static int qlcnic_rx_poll(struct napi_struct
*napi
, int budget
)
892 struct qlcnic_host_sds_ring
*sds_ring
;
893 struct qlcnic_adapter
*adapter
;
896 sds_ring
= container_of(napi
, struct qlcnic_host_sds_ring
, napi
);
897 adapter
= sds_ring
->adapter
;
899 work_done
= qlcnic_process_rcv_ring(sds_ring
, budget
);
901 if (work_done
< budget
) {
902 napi_complete(&sds_ring
->napi
);
903 if (test_bit(__QLCNIC_DEV_UP
, &adapter
->state
))
904 qlcnic_enable_int(sds_ring
);
910 static void qlcnic_handle_linkevent(struct qlcnic_adapter
*adapter
,
911 struct qlcnic_fw_msg
*msg
)
914 u16 cable_len
, link_speed
;
915 u8 link_status
, module
, duplex
, autoneg
, lb_status
= 0;
916 struct net_device
*netdev
= adapter
->netdev
;
918 adapter
->ahw
->has_link_events
= 1;
920 cable_OUI
= msg
->body
[1] & 0xffffffff;
921 cable_len
= (msg
->body
[1] >> 32) & 0xffff;
922 link_speed
= (msg
->body
[1] >> 48) & 0xffff;
924 link_status
= msg
->body
[2] & 0xff;
925 duplex
= (msg
->body
[2] >> 16) & 0xff;
926 autoneg
= (msg
->body
[2] >> 24) & 0xff;
927 lb_status
= (msg
->body
[2] >> 32) & 0x3;
929 module
= (msg
->body
[2] >> 8) & 0xff;
930 if (module
== LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE
)
931 dev_info(&netdev
->dev
,
932 "unsupported cable: OUI 0x%x, length %d\n",
933 cable_OUI
, cable_len
);
934 else if (module
== LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN
)
935 dev_info(&netdev
->dev
, "unsupported cable length %d\n",
938 if (!link_status
&& (lb_status
== QLCNIC_ILB_MODE
||
939 lb_status
== QLCNIC_ELB_MODE
))
940 adapter
->ahw
->loopback_state
|= QLCNIC_LINKEVENT
;
942 qlcnic_advert_link_change(adapter
, link_status
);
944 if (duplex
== LINKEVENT_FULL_DUPLEX
)
945 adapter
->ahw
->link_duplex
= DUPLEX_FULL
;
947 adapter
->ahw
->link_duplex
= DUPLEX_HALF
;
949 adapter
->ahw
->module_type
= module
;
950 adapter
->ahw
->link_autoneg
= autoneg
;
953 adapter
->ahw
->link_speed
= link_speed
;
955 adapter
->ahw
->link_speed
= SPEED_UNKNOWN
;
956 adapter
->ahw
->link_duplex
= DUPLEX_UNKNOWN
;
960 static void qlcnic_handle_fw_message(int desc_cnt
, int index
,
961 struct qlcnic_host_sds_ring
*sds_ring
)
963 struct qlcnic_fw_msg msg
;
964 struct status_desc
*desc
;
965 struct qlcnic_adapter
*adapter
;
967 int i
= 0, opcode
, ret
;
969 while (desc_cnt
> 0 && i
< 8) {
970 desc
= &sds_ring
->desc_head
[index
];
971 msg
.words
[i
++] = le64_to_cpu(desc
->status_desc_data
[0]);
972 msg
.words
[i
++] = le64_to_cpu(desc
->status_desc_data
[1]);
974 index
= get_next_index(index
, sds_ring
->num_desc
);
978 adapter
= sds_ring
->adapter
;
979 dev
= &adapter
->pdev
->dev
;
980 opcode
= qlcnic_get_nic_msg_opcode(msg
.body
[0]);
983 case QLCNIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE
:
984 qlcnic_handle_linkevent(adapter
, &msg
);
986 case QLCNIC_C2H_OPCODE_CONFIG_LOOPBACK
:
987 ret
= (u32
)(msg
.body
[1]);
990 adapter
->ahw
->loopback_state
|= QLCNIC_LB_RESPONSE
;
993 dev_info(dev
, "loopback already in progress\n");
994 adapter
->ahw
->diag_cnt
= -EINPROGRESS
;
997 dev_info(dev
, "loopback cable is not connected\n");
998 adapter
->ahw
->diag_cnt
= -ENODEV
;
1002 "loopback configure request failed, err %x\n",
1004 adapter
->ahw
->diag_cnt
= -EIO
;
1008 case QLCNIC_C2H_OPCODE_GET_DCB_AEN
:
1009 qlcnic_dcb_aen_handler(adapter
->dcb
, (void *)&msg
);
1016 struct sk_buff
*qlcnic_process_rxbuf(struct qlcnic_adapter
*adapter
,
1017 struct qlcnic_host_rds_ring
*ring
,
1018 u16 index
, u16 cksum
)
1020 struct qlcnic_rx_buffer
*buffer
;
1021 struct sk_buff
*skb
;
1023 buffer
= &ring
->rx_buf_arr
[index
];
1024 if (unlikely(buffer
->skb
== NULL
)) {
1029 pci_unmap_single(adapter
->pdev
, buffer
->dma
, ring
->dma_size
,
1030 PCI_DMA_FROMDEVICE
);
1033 if (likely((adapter
->netdev
->features
& NETIF_F_RXCSUM
) &&
1034 (cksum
== STATUS_CKSUM_OK
|| cksum
== STATUS_CKSUM_LOOP
))) {
1035 adapter
->stats
.csummed
++;
1036 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1038 skb_checksum_none_assert(skb
);
1047 static inline int qlcnic_check_rx_tagging(struct qlcnic_adapter
*adapter
,
1048 struct sk_buff
*skb
, u16
*vlan_tag
)
1050 struct ethhdr
*eth_hdr
;
1052 if (!__vlan_get_tag(skb
, vlan_tag
)) {
1053 eth_hdr
= (struct ethhdr
*)skb
->data
;
1054 memmove(skb
->data
+ VLAN_HLEN
, eth_hdr
, ETH_ALEN
* 2);
1055 skb_pull(skb
, VLAN_HLEN
);
1057 if (!adapter
->rx_pvid
)
1060 if (*vlan_tag
== adapter
->rx_pvid
) {
1061 /* Outer vlan tag. Packet should follow non-vlan path */
1065 if (adapter
->flags
& QLCNIC_TAGGING_ENABLED
)
1071 static struct qlcnic_rx_buffer
*
1072 qlcnic_process_rcv(struct qlcnic_adapter
*adapter
,
1073 struct qlcnic_host_sds_ring
*sds_ring
, int ring
,
1076 struct net_device
*netdev
= adapter
->netdev
;
1077 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1078 struct qlcnic_rx_buffer
*buffer
;
1079 struct sk_buff
*skb
;
1080 struct qlcnic_host_rds_ring
*rds_ring
;
1081 int index
, length
, cksum
, pkt_offset
, is_lb_pkt
;
1082 u16 vid
= 0xffff, t_vid
;
1084 if (unlikely(ring
>= adapter
->max_rds_rings
))
1087 rds_ring
= &recv_ctx
->rds_rings
[ring
];
1089 index
= qlcnic_get_sts_refhandle(sts_data0
);
1090 if (unlikely(index
>= rds_ring
->num_desc
))
1093 buffer
= &rds_ring
->rx_buf_arr
[index
];
1094 length
= qlcnic_get_sts_totallength(sts_data0
);
1095 cksum
= qlcnic_get_sts_status(sts_data0
);
1096 pkt_offset
= qlcnic_get_sts_pkt_offset(sts_data0
);
1098 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, cksum
);
1102 if (adapter
->drv_mac_learn
&&
1103 (adapter
->flags
& QLCNIC_ESWITCH_ENABLED
)) {
1105 is_lb_pkt
= qlcnic_82xx_is_lb_pkt(sts_data0
);
1106 qlcnic_add_lb_filter(adapter
, skb
, is_lb_pkt
, t_vid
);
1109 if (length
> rds_ring
->skb_size
)
1110 skb_put(skb
, rds_ring
->skb_size
);
1112 skb_put(skb
, length
);
1115 skb_pull(skb
, pkt_offset
);
1117 if (unlikely(qlcnic_check_rx_tagging(adapter
, skb
, &vid
))) {
1118 adapter
->stats
.rxdropped
++;
1123 skb
->protocol
= eth_type_trans(skb
, netdev
);
1126 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
), vid
);
1128 napi_gro_receive(&sds_ring
->napi
, skb
);
1130 adapter
->stats
.rx_pkts
++;
1131 adapter
->stats
.rxbytes
+= length
;
1136 #define QLC_TCP_HDR_SIZE 20
1137 #define QLC_TCP_TS_OPTION_SIZE 12
1138 #define QLC_TCP_TS_HDR_SIZE (QLC_TCP_HDR_SIZE + QLC_TCP_TS_OPTION_SIZE)
1140 static struct qlcnic_rx_buffer
*
1141 qlcnic_process_lro(struct qlcnic_adapter
*adapter
,
1142 int ring
, u64 sts_data0
, u64 sts_data1
)
1144 struct net_device
*netdev
= adapter
->netdev
;
1145 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1146 struct qlcnic_rx_buffer
*buffer
;
1147 struct sk_buff
*skb
;
1148 struct qlcnic_host_rds_ring
*rds_ring
;
1150 struct ipv6hdr
*ipv6h
;
1152 bool push
, timestamp
;
1153 int index
, l2_hdr_offset
, l4_hdr_offset
, is_lb_pkt
;
1154 u16 lro_length
, length
, data_offset
, t_vid
, vid
= 0xffff;
1157 if (unlikely(ring
> adapter
->max_rds_rings
))
1160 rds_ring
= &recv_ctx
->rds_rings
[ring
];
1162 index
= qlcnic_get_lro_sts_refhandle(sts_data0
);
1163 if (unlikely(index
> rds_ring
->num_desc
))
1166 buffer
= &rds_ring
->rx_buf_arr
[index
];
1168 timestamp
= qlcnic_get_lro_sts_timestamp(sts_data0
);
1169 lro_length
= qlcnic_get_lro_sts_length(sts_data0
);
1170 l2_hdr_offset
= qlcnic_get_lro_sts_l2_hdr_offset(sts_data0
);
1171 l4_hdr_offset
= qlcnic_get_lro_sts_l4_hdr_offset(sts_data0
);
1172 push
= qlcnic_get_lro_sts_push_flag(sts_data0
);
1173 seq_number
= qlcnic_get_lro_sts_seq_number(sts_data1
);
1175 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, STATUS_CKSUM_OK
);
1179 if (adapter
->drv_mac_learn
&&
1180 (adapter
->flags
& QLCNIC_ESWITCH_ENABLED
)) {
1182 is_lb_pkt
= qlcnic_82xx_is_lb_pkt(sts_data0
);
1183 qlcnic_add_lb_filter(adapter
, skb
, is_lb_pkt
, t_vid
);
1187 data_offset
= l4_hdr_offset
+ QLC_TCP_TS_HDR_SIZE
;
1189 data_offset
= l4_hdr_offset
+ QLC_TCP_HDR_SIZE
;
1191 skb_put(skb
, lro_length
+ data_offset
);
1192 skb_pull(skb
, l2_hdr_offset
);
1194 if (unlikely(qlcnic_check_rx_tagging(adapter
, skb
, &vid
))) {
1195 adapter
->stats
.rxdropped
++;
1200 skb
->protocol
= eth_type_trans(skb
, netdev
);
1202 if (ntohs(skb
->protocol
) == ETH_P_IPV6
) {
1203 ipv6h
= (struct ipv6hdr
*)skb
->data
;
1204 th
= (struct tcphdr
*)(skb
->data
+ sizeof(struct ipv6hdr
));
1205 length
= (th
->doff
<< 2) + lro_length
;
1206 ipv6h
->payload_len
= htons(length
);
1208 iph
= (struct iphdr
*)skb
->data
;
1209 th
= (struct tcphdr
*)(skb
->data
+ (iph
->ihl
<< 2));
1210 length
= (iph
->ihl
<< 2) + (th
->doff
<< 2) + lro_length
;
1211 csum_replace2(&iph
->check
, iph
->tot_len
, htons(length
));
1212 iph
->tot_len
= htons(length
);
1216 th
->seq
= htonl(seq_number
);
1219 if (adapter
->flags
& QLCNIC_FW_LRO_MSS_CAP
) {
1220 skb_shinfo(skb
)->gso_size
= qlcnic_get_lro_sts_mss(sts_data1
);
1221 if (skb
->protocol
== htons(ETH_P_IPV6
))
1222 skb_shinfo(skb
)->gso_type
= SKB_GSO_TCPV6
;
1224 skb_shinfo(skb
)->gso_type
= SKB_GSO_TCPV4
;
1228 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
), vid
);
1229 netif_receive_skb(skb
);
1231 adapter
->stats
.lro_pkts
++;
1232 adapter
->stats
.lrobytes
+= length
;
1237 int qlcnic_process_rcv_ring(struct qlcnic_host_sds_ring
*sds_ring
, int max
)
1239 struct qlcnic_host_rds_ring
*rds_ring
;
1240 struct qlcnic_adapter
*adapter
= sds_ring
->adapter
;
1241 struct list_head
*cur
;
1242 struct status_desc
*desc
;
1243 struct qlcnic_rx_buffer
*rxbuf
;
1244 int opcode
, desc_cnt
, count
= 0;
1245 u64 sts_data0
, sts_data1
;
1247 u32 consumer
= sds_ring
->consumer
;
1249 while (count
< max
) {
1250 desc
= &sds_ring
->desc_head
[consumer
];
1251 sts_data0
= le64_to_cpu(desc
->status_desc_data
[0]);
1253 if (!(sts_data0
& STATUS_OWNER_HOST
))
1256 desc_cnt
= qlcnic_get_sts_desc_cnt(sts_data0
);
1257 opcode
= qlcnic_get_sts_opcode(sts_data0
);
1259 case QLCNIC_RXPKT_DESC
:
1260 case QLCNIC_OLD_RXPKT_DESC
:
1261 case QLCNIC_SYN_OFFLOAD
:
1262 ring
= qlcnic_get_sts_type(sts_data0
);
1263 rxbuf
= qlcnic_process_rcv(adapter
, sds_ring
, ring
,
1266 case QLCNIC_LRO_DESC
:
1267 ring
= qlcnic_get_lro_sts_type(sts_data0
);
1268 sts_data1
= le64_to_cpu(desc
->status_desc_data
[1]);
1269 rxbuf
= qlcnic_process_lro(adapter
, ring
, sts_data0
,
1272 case QLCNIC_RESPONSE_DESC
:
1273 qlcnic_handle_fw_message(desc_cnt
, consumer
, sds_ring
);
1277 WARN_ON(desc_cnt
> 1);
1280 list_add_tail(&rxbuf
->list
, &sds_ring
->free_list
[ring
]);
1282 adapter
->stats
.null_rxbuf
++;
1284 for (; desc_cnt
> 0; desc_cnt
--) {
1285 desc
= &sds_ring
->desc_head
[consumer
];
1286 desc
->status_desc_data
[0] = QLCNIC_DESC_OWNER_FW
;
1287 consumer
= get_next_index(consumer
, sds_ring
->num_desc
);
1292 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
1293 rds_ring
= &adapter
->recv_ctx
->rds_rings
[ring
];
1294 if (!list_empty(&sds_ring
->free_list
[ring
])) {
1295 list_for_each(cur
, &sds_ring
->free_list
[ring
]) {
1296 rxbuf
= list_entry(cur
, struct qlcnic_rx_buffer
,
1298 qlcnic_alloc_rx_skb(adapter
, rds_ring
, rxbuf
);
1300 spin_lock(&rds_ring
->lock
);
1301 list_splice_tail_init(&sds_ring
->free_list
[ring
],
1302 &rds_ring
->free_list
);
1303 spin_unlock(&rds_ring
->lock
);
1306 qlcnic_post_rx_buffers_nodb(adapter
, rds_ring
, ring
);
1310 sds_ring
->consumer
= consumer
;
1311 writel(consumer
, sds_ring
->crb_sts_consumer
);
1317 void qlcnic_post_rx_buffers(struct qlcnic_adapter
*adapter
,
1318 struct qlcnic_host_rds_ring
*rds_ring
, u8 ring_id
)
1320 struct rcv_desc
*pdesc
;
1321 struct qlcnic_rx_buffer
*buffer
;
1323 u32 producer
, handle
;
1324 struct list_head
*head
;
1326 producer
= rds_ring
->producer
;
1327 head
= &rds_ring
->free_list
;
1329 while (!list_empty(head
)) {
1331 buffer
= list_entry(head
->next
, struct qlcnic_rx_buffer
, list
);
1334 if (qlcnic_alloc_rx_skb(adapter
, rds_ring
, buffer
))
1339 list_del(&buffer
->list
);
1341 /* make a rcv descriptor */
1342 pdesc
= &rds_ring
->desc_head
[producer
];
1343 pdesc
->addr_buffer
= cpu_to_le64(buffer
->dma
);
1344 handle
= qlcnic_get_ref_handle(adapter
, buffer
->ref_handle
,
1346 pdesc
->reference_handle
= cpu_to_le16(handle
);
1347 pdesc
->buffer_length
= cpu_to_le32(rds_ring
->dma_size
);
1348 producer
= get_next_index(producer
, rds_ring
->num_desc
);
1352 rds_ring
->producer
= producer
;
1353 writel((producer
-1) & (rds_ring
->num_desc
-1),
1354 rds_ring
->crb_rcv_producer
);
1358 static void dump_skb(struct sk_buff
*skb
, struct qlcnic_adapter
*adapter
)
1361 unsigned char *data
= skb
->data
;
1363 pr_info(KERN_INFO
"\n");
1364 for (i
= 0; i
< skb
->len
; i
++) {
1365 QLCDB(adapter
, DRV
, "%02x ", data
[i
]);
1366 if ((i
& 0x0f) == 8)
1367 pr_info(KERN_INFO
"\n");
1371 static void qlcnic_process_rcv_diag(struct qlcnic_adapter
*adapter
, int ring
,
1374 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1375 struct sk_buff
*skb
;
1376 struct qlcnic_host_rds_ring
*rds_ring
;
1377 int index
, length
, cksum
, pkt_offset
;
1379 if (unlikely(ring
>= adapter
->max_rds_rings
))
1382 rds_ring
= &recv_ctx
->rds_rings
[ring
];
1384 index
= qlcnic_get_sts_refhandle(sts_data0
);
1385 length
= qlcnic_get_sts_totallength(sts_data0
);
1386 if (unlikely(index
>= rds_ring
->num_desc
))
1389 cksum
= qlcnic_get_sts_status(sts_data0
);
1390 pkt_offset
= qlcnic_get_sts_pkt_offset(sts_data0
);
1392 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, cksum
);
1396 if (length
> rds_ring
->skb_size
)
1397 skb_put(skb
, rds_ring
->skb_size
);
1399 skb_put(skb
, length
);
1402 skb_pull(skb
, pkt_offset
);
1404 if (!qlcnic_check_loopback_buff(skb
->data
, adapter
->mac_addr
))
1405 adapter
->ahw
->diag_cnt
++;
1407 dump_skb(skb
, adapter
);
1409 dev_kfree_skb_any(skb
);
1410 adapter
->stats
.rx_pkts
++;
1411 adapter
->stats
.rxbytes
+= length
;
1416 void qlcnic_82xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring
*sds_ring
)
1418 struct qlcnic_adapter
*adapter
= sds_ring
->adapter
;
1419 struct status_desc
*desc
;
1421 int ring
, opcode
, desc_cnt
;
1423 u32 consumer
= sds_ring
->consumer
;
1425 desc
= &sds_ring
->desc_head
[consumer
];
1426 sts_data0
= le64_to_cpu(desc
->status_desc_data
[0]);
1428 if (!(sts_data0
& STATUS_OWNER_HOST
))
1431 desc_cnt
= qlcnic_get_sts_desc_cnt(sts_data0
);
1432 opcode
= qlcnic_get_sts_opcode(sts_data0
);
1434 case QLCNIC_RESPONSE_DESC
:
1435 qlcnic_handle_fw_message(desc_cnt
, consumer
, sds_ring
);
1438 ring
= qlcnic_get_sts_type(sts_data0
);
1439 qlcnic_process_rcv_diag(adapter
, ring
, sts_data0
);
1443 for (; desc_cnt
> 0; desc_cnt
--) {
1444 desc
= &sds_ring
->desc_head
[consumer
];
1445 desc
->status_desc_data
[0] = cpu_to_le64(STATUS_OWNER_PHANTOM
);
1446 consumer
= get_next_index(consumer
, sds_ring
->num_desc
);
1449 sds_ring
->consumer
= consumer
;
1450 writel(consumer
, sds_ring
->crb_sts_consumer
);
1453 int qlcnic_82xx_napi_add(struct qlcnic_adapter
*adapter
,
1454 struct net_device
*netdev
)
1457 struct qlcnic_host_sds_ring
*sds_ring
;
1458 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1459 struct qlcnic_host_tx_ring
*tx_ring
;
1461 if (qlcnic_alloc_sds_rings(recv_ctx
, adapter
->drv_sds_rings
))
1464 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1465 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1466 if (qlcnic_check_multi_tx(adapter
) &&
1467 !adapter
->ahw
->diag_test
&&
1468 (adapter
->drv_tx_rings
> QLCNIC_SINGLE_RING
)) {
1469 netif_napi_add(netdev
, &sds_ring
->napi
, qlcnic_rx_poll
,
1472 if (ring
== (adapter
->drv_sds_rings
- 1))
1473 netif_napi_add(netdev
, &sds_ring
->napi
,
1477 netif_napi_add(netdev
, &sds_ring
->napi
,
1483 if (qlcnic_alloc_tx_rings(adapter
, netdev
)) {
1484 qlcnic_free_sds_rings(recv_ctx
);
1488 if (qlcnic_check_multi_tx(adapter
) && !adapter
->ahw
->diag_test
) {
1489 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1490 tx_ring
= &adapter
->tx_ring
[ring
];
1491 netif_napi_add(netdev
, &tx_ring
->napi
, qlcnic_tx_poll
,
1499 void qlcnic_82xx_napi_del(struct qlcnic_adapter
*adapter
)
1502 struct qlcnic_host_sds_ring
*sds_ring
;
1503 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1504 struct qlcnic_host_tx_ring
*tx_ring
;
1506 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1507 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1508 netif_napi_del(&sds_ring
->napi
);
1511 qlcnic_free_sds_rings(adapter
->recv_ctx
);
1513 if (qlcnic_check_multi_tx(adapter
) && !adapter
->ahw
->diag_test
) {
1514 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1515 tx_ring
= &adapter
->tx_ring
[ring
];
1516 netif_napi_del(&tx_ring
->napi
);
1520 qlcnic_free_tx_rings(adapter
);
1523 void qlcnic_82xx_napi_enable(struct qlcnic_adapter
*adapter
)
1526 struct qlcnic_host_sds_ring
*sds_ring
;
1527 struct qlcnic_host_tx_ring
*tx_ring
;
1528 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1530 if (adapter
->is_up
!= QLCNIC_ADAPTER_UP_MAGIC
)
1533 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1534 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1535 napi_enable(&sds_ring
->napi
);
1536 qlcnic_enable_int(sds_ring
);
1539 if (qlcnic_check_multi_tx(adapter
) &&
1540 (adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
1541 !adapter
->ahw
->diag_test
&&
1542 (adapter
->drv_tx_rings
> QLCNIC_SINGLE_RING
)) {
1543 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1544 tx_ring
= &adapter
->tx_ring
[ring
];
1545 napi_enable(&tx_ring
->napi
);
1546 qlcnic_enable_tx_intr(adapter
, tx_ring
);
1551 void qlcnic_82xx_napi_disable(struct qlcnic_adapter
*adapter
)
1554 struct qlcnic_host_sds_ring
*sds_ring
;
1555 struct qlcnic_host_tx_ring
*tx_ring
;
1556 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1558 if (adapter
->is_up
!= QLCNIC_ADAPTER_UP_MAGIC
)
1561 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1562 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1563 qlcnic_disable_int(sds_ring
);
1564 napi_synchronize(&sds_ring
->napi
);
1565 napi_disable(&sds_ring
->napi
);
1568 if ((adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
1569 !adapter
->ahw
->diag_test
&&
1570 qlcnic_check_multi_tx(adapter
)) {
1571 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1572 tx_ring
= &adapter
->tx_ring
[ring
];
1573 qlcnic_disable_tx_int(adapter
, tx_ring
);
1574 napi_synchronize(&tx_ring
->napi
);
1575 napi_disable(&tx_ring
->napi
);
1580 #define QLC_83XX_NORMAL_LB_PKT (1ULL << 36)
1581 #define QLC_83XX_LRO_LB_PKT (1ULL << 46)
1583 static inline int qlcnic_83xx_is_lb_pkt(u64 sts_data
, int lro_pkt
)
1586 return (sts_data
& QLC_83XX_LRO_LB_PKT
) ? 1 : 0;
1588 return (sts_data
& QLC_83XX_NORMAL_LB_PKT
) ? 1 : 0;
1591 static struct qlcnic_rx_buffer
*
1592 qlcnic_83xx_process_rcv(struct qlcnic_adapter
*adapter
,
1593 struct qlcnic_host_sds_ring
*sds_ring
,
1594 u8 ring
, u64 sts_data
[])
1596 struct net_device
*netdev
= adapter
->netdev
;
1597 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1598 struct qlcnic_rx_buffer
*buffer
;
1599 struct sk_buff
*skb
;
1600 struct qlcnic_host_rds_ring
*rds_ring
;
1601 int index
, length
, cksum
, is_lb_pkt
;
1602 u16 vid
= 0xffff, t_vid
;
1604 if (unlikely(ring
>= adapter
->max_rds_rings
))
1607 rds_ring
= &recv_ctx
->rds_rings
[ring
];
1609 index
= qlcnic_83xx_hndl(sts_data
[0]);
1610 if (unlikely(index
>= rds_ring
->num_desc
))
1613 buffer
= &rds_ring
->rx_buf_arr
[index
];
1614 length
= qlcnic_83xx_pktln(sts_data
[0]);
1615 cksum
= qlcnic_83xx_csum_status(sts_data
[1]);
1616 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, cksum
);
1620 if (adapter
->drv_mac_learn
&&
1621 (adapter
->flags
& QLCNIC_ESWITCH_ENABLED
)) {
1623 is_lb_pkt
= qlcnic_83xx_is_lb_pkt(sts_data
[1], 0);
1624 qlcnic_add_lb_filter(adapter
, skb
, is_lb_pkt
, t_vid
);
1627 if (length
> rds_ring
->skb_size
)
1628 skb_put(skb
, rds_ring
->skb_size
);
1630 skb_put(skb
, length
);
1632 if (unlikely(qlcnic_check_rx_tagging(adapter
, skb
, &vid
))) {
1633 adapter
->stats
.rxdropped
++;
1638 skb
->protocol
= eth_type_trans(skb
, netdev
);
1641 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
), vid
);
1643 napi_gro_receive(&sds_ring
->napi
, skb
);
1645 adapter
->stats
.rx_pkts
++;
1646 adapter
->stats
.rxbytes
+= length
;
1651 static struct qlcnic_rx_buffer
*
1652 qlcnic_83xx_process_lro(struct qlcnic_adapter
*adapter
,
1653 u8 ring
, u64 sts_data
[])
1655 struct net_device
*netdev
= adapter
->netdev
;
1656 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1657 struct qlcnic_rx_buffer
*buffer
;
1658 struct sk_buff
*skb
;
1659 struct qlcnic_host_rds_ring
*rds_ring
;
1661 struct ipv6hdr
*ipv6h
;
1664 int l2_hdr_offset
, l4_hdr_offset
;
1665 int index
, is_lb_pkt
;
1666 u16 lro_length
, length
, data_offset
, gso_size
;
1667 u16 vid
= 0xffff, t_vid
;
1669 if (unlikely(ring
> adapter
->max_rds_rings
))
1672 rds_ring
= &recv_ctx
->rds_rings
[ring
];
1674 index
= qlcnic_83xx_hndl(sts_data
[0]);
1675 if (unlikely(index
> rds_ring
->num_desc
))
1678 buffer
= &rds_ring
->rx_buf_arr
[index
];
1680 lro_length
= qlcnic_83xx_lro_pktln(sts_data
[0]);
1681 l2_hdr_offset
= qlcnic_83xx_l2_hdr_off(sts_data
[1]);
1682 l4_hdr_offset
= qlcnic_83xx_l4_hdr_off(sts_data
[1]);
1683 push
= qlcnic_83xx_is_psh_bit(sts_data
[1]);
1685 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, STATUS_CKSUM_OK
);
1689 if (adapter
->drv_mac_learn
&&
1690 (adapter
->flags
& QLCNIC_ESWITCH_ENABLED
)) {
1692 is_lb_pkt
= qlcnic_83xx_is_lb_pkt(sts_data
[1], 1);
1693 qlcnic_add_lb_filter(adapter
, skb
, is_lb_pkt
, t_vid
);
1695 if (qlcnic_83xx_is_tstamp(sts_data
[1]))
1696 data_offset
= l4_hdr_offset
+ QLCNIC_TCP_TS_HDR_SIZE
;
1698 data_offset
= l4_hdr_offset
+ QLCNIC_TCP_HDR_SIZE
;
1700 skb_put(skb
, lro_length
+ data_offset
);
1701 skb_pull(skb
, l2_hdr_offset
);
1703 if (unlikely(qlcnic_check_rx_tagging(adapter
, skb
, &vid
))) {
1704 adapter
->stats
.rxdropped
++;
1709 skb
->protocol
= eth_type_trans(skb
, netdev
);
1710 if (ntohs(skb
->protocol
) == ETH_P_IPV6
) {
1711 ipv6h
= (struct ipv6hdr
*)skb
->data
;
1712 th
= (struct tcphdr
*)(skb
->data
+ sizeof(struct ipv6hdr
));
1714 length
= (th
->doff
<< 2) + lro_length
;
1715 ipv6h
->payload_len
= htons(length
);
1717 iph
= (struct iphdr
*)skb
->data
;
1718 th
= (struct tcphdr
*)(skb
->data
+ (iph
->ihl
<< 2));
1719 length
= (iph
->ihl
<< 2) + (th
->doff
<< 2) + lro_length
;
1720 csum_replace2(&iph
->check
, iph
->tot_len
, htons(length
));
1721 iph
->tot_len
= htons(length
);
1727 if (adapter
->flags
& QLCNIC_FW_LRO_MSS_CAP
) {
1728 gso_size
= qlcnic_83xx_get_lro_sts_mss(sts_data
[0]);
1729 skb_shinfo(skb
)->gso_size
= gso_size
;
1730 if (skb
->protocol
== htons(ETH_P_IPV6
))
1731 skb_shinfo(skb
)->gso_type
= SKB_GSO_TCPV6
;
1733 skb_shinfo(skb
)->gso_type
= SKB_GSO_TCPV4
;
1737 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
), vid
);
1739 netif_receive_skb(skb
);
1741 adapter
->stats
.lro_pkts
++;
1742 adapter
->stats
.lrobytes
+= length
;
1746 static int qlcnic_83xx_process_rcv_ring(struct qlcnic_host_sds_ring
*sds_ring
,
1749 struct qlcnic_host_rds_ring
*rds_ring
;
1750 struct qlcnic_adapter
*adapter
= sds_ring
->adapter
;
1751 struct list_head
*cur
;
1752 struct status_desc
*desc
;
1753 struct qlcnic_rx_buffer
*rxbuf
= NULL
;
1756 int count
= 0, opcode
;
1757 u32 consumer
= sds_ring
->consumer
;
1759 while (count
< max
) {
1760 desc
= &sds_ring
->desc_head
[consumer
];
1761 sts_data
[1] = le64_to_cpu(desc
->status_desc_data
[1]);
1762 opcode
= qlcnic_83xx_opcode(sts_data
[1]);
1765 sts_data
[0] = le64_to_cpu(desc
->status_desc_data
[0]);
1766 ring
= QLCNIC_FETCH_RING_ID(sts_data
[0]);
1769 case QLC_83XX_REG_DESC
:
1770 rxbuf
= qlcnic_83xx_process_rcv(adapter
, sds_ring
,
1773 case QLC_83XX_LRO_DESC
:
1774 rxbuf
= qlcnic_83xx_process_lro(adapter
, ring
,
1778 dev_info(&adapter
->pdev
->dev
,
1779 "Unknown opcode: 0x%x\n", opcode
);
1784 list_add_tail(&rxbuf
->list
, &sds_ring
->free_list
[ring
]);
1786 adapter
->stats
.null_rxbuf
++;
1788 desc
= &sds_ring
->desc_head
[consumer
];
1789 /* Reset the descriptor */
1790 desc
->status_desc_data
[1] = 0;
1791 consumer
= get_next_index(consumer
, sds_ring
->num_desc
);
1794 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
1795 rds_ring
= &adapter
->recv_ctx
->rds_rings
[ring
];
1796 if (!list_empty(&sds_ring
->free_list
[ring
])) {
1797 list_for_each(cur
, &sds_ring
->free_list
[ring
]) {
1798 rxbuf
= list_entry(cur
, struct qlcnic_rx_buffer
,
1800 qlcnic_alloc_rx_skb(adapter
, rds_ring
, rxbuf
);
1802 spin_lock(&rds_ring
->lock
);
1803 list_splice_tail_init(&sds_ring
->free_list
[ring
],
1804 &rds_ring
->free_list
);
1805 spin_unlock(&rds_ring
->lock
);
1807 qlcnic_post_rx_buffers_nodb(adapter
, rds_ring
, ring
);
1810 sds_ring
->consumer
= consumer
;
1811 writel(consumer
, sds_ring
->crb_sts_consumer
);
1816 static int qlcnic_83xx_msix_sriov_vf_poll(struct napi_struct
*napi
, int budget
)
1820 struct qlcnic_host_sds_ring
*sds_ring
;
1821 struct qlcnic_adapter
*adapter
;
1822 struct qlcnic_host_tx_ring
*tx_ring
;
1824 sds_ring
= container_of(napi
, struct qlcnic_host_sds_ring
, napi
);
1825 adapter
= sds_ring
->adapter
;
1826 /* tx ring count = 1 */
1827 tx_ring
= adapter
->tx_ring
;
1829 tx_complete
= qlcnic_process_cmd_ring(adapter
, tx_ring
, budget
);
1830 work_done
= qlcnic_83xx_process_rcv_ring(sds_ring
, budget
);
1831 if ((work_done
< budget
) && tx_complete
) {
1832 napi_complete(&sds_ring
->napi
);
1833 qlcnic_83xx_enable_intr(adapter
, sds_ring
);
1839 static int qlcnic_83xx_poll(struct napi_struct
*napi
, int budget
)
1843 struct qlcnic_host_sds_ring
*sds_ring
;
1844 struct qlcnic_adapter
*adapter
;
1845 struct qlcnic_host_tx_ring
*tx_ring
;
1847 sds_ring
= container_of(napi
, struct qlcnic_host_sds_ring
, napi
);
1848 adapter
= sds_ring
->adapter
;
1849 /* tx ring count = 1 */
1850 tx_ring
= adapter
->tx_ring
;
1852 tx_complete
= qlcnic_process_cmd_ring(adapter
, tx_ring
, budget
);
1853 work_done
= qlcnic_83xx_process_rcv_ring(sds_ring
, budget
);
1854 if ((work_done
< budget
) && tx_complete
) {
1855 napi_complete(&sds_ring
->napi
);
1856 qlcnic_83xx_enable_intr(adapter
, sds_ring
);
1862 static int qlcnic_83xx_msix_tx_poll(struct napi_struct
*napi
, int budget
)
1865 struct qlcnic_host_tx_ring
*tx_ring
;
1866 struct qlcnic_adapter
*adapter
;
1868 budget
= QLCNIC_TX_POLL_BUDGET
;
1869 tx_ring
= container_of(napi
, struct qlcnic_host_tx_ring
, napi
);
1870 adapter
= tx_ring
->adapter
;
1871 work_done
= qlcnic_process_cmd_ring(adapter
, tx_ring
, budget
);
1873 napi_complete(&tx_ring
->napi
);
1874 if (test_bit(__QLCNIC_DEV_UP
, &adapter
->state
))
1875 qlcnic_83xx_enable_tx_intr(adapter
, tx_ring
);
1881 static int qlcnic_83xx_rx_poll(struct napi_struct
*napi
, int budget
)
1884 struct qlcnic_host_sds_ring
*sds_ring
;
1885 struct qlcnic_adapter
*adapter
;
1887 sds_ring
= container_of(napi
, struct qlcnic_host_sds_ring
, napi
);
1888 adapter
= sds_ring
->adapter
;
1889 work_done
= qlcnic_83xx_process_rcv_ring(sds_ring
, budget
);
1890 if (work_done
< budget
) {
1891 napi_complete(&sds_ring
->napi
);
1892 if (test_bit(__QLCNIC_DEV_UP
, &adapter
->state
))
1893 qlcnic_83xx_enable_intr(adapter
, sds_ring
);
1899 void qlcnic_83xx_napi_enable(struct qlcnic_adapter
*adapter
)
1902 struct qlcnic_host_sds_ring
*sds_ring
;
1903 struct qlcnic_host_tx_ring
*tx_ring
;
1904 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1906 if (adapter
->is_up
!= QLCNIC_ADAPTER_UP_MAGIC
)
1909 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1910 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1911 napi_enable(&sds_ring
->napi
);
1912 if (adapter
->flags
& QLCNIC_MSIX_ENABLED
)
1913 qlcnic_83xx_enable_intr(adapter
, sds_ring
);
1916 if ((adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
1917 !(adapter
->flags
& QLCNIC_TX_INTR_SHARED
)) {
1918 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1919 tx_ring
= &adapter
->tx_ring
[ring
];
1920 napi_enable(&tx_ring
->napi
);
1921 qlcnic_83xx_enable_tx_intr(adapter
, tx_ring
);
1926 void qlcnic_83xx_napi_disable(struct qlcnic_adapter
*adapter
)
1929 struct qlcnic_host_sds_ring
*sds_ring
;
1930 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1931 struct qlcnic_host_tx_ring
*tx_ring
;
1933 if (adapter
->is_up
!= QLCNIC_ADAPTER_UP_MAGIC
)
1936 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1937 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1938 if (adapter
->flags
& QLCNIC_MSIX_ENABLED
)
1939 qlcnic_83xx_disable_intr(adapter
, sds_ring
);
1940 napi_synchronize(&sds_ring
->napi
);
1941 napi_disable(&sds_ring
->napi
);
1944 if ((adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
1945 !(adapter
->flags
& QLCNIC_TX_INTR_SHARED
)) {
1946 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1947 tx_ring
= &adapter
->tx_ring
[ring
];
1948 qlcnic_83xx_disable_tx_intr(adapter
, tx_ring
);
1949 napi_synchronize(&tx_ring
->napi
);
1950 napi_disable(&tx_ring
->napi
);
1955 int qlcnic_83xx_napi_add(struct qlcnic_adapter
*adapter
,
1956 struct net_device
*netdev
)
1959 struct qlcnic_host_sds_ring
*sds_ring
;
1960 struct qlcnic_host_tx_ring
*tx_ring
;
1961 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
1963 if (qlcnic_alloc_sds_rings(recv_ctx
, adapter
->drv_sds_rings
))
1966 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
1967 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1968 if (adapter
->flags
& QLCNIC_MSIX_ENABLED
) {
1969 if (!(adapter
->flags
& QLCNIC_TX_INTR_SHARED
))
1970 netif_napi_add(netdev
, &sds_ring
->napi
,
1971 qlcnic_83xx_rx_poll
,
1974 netif_napi_add(netdev
, &sds_ring
->napi
,
1975 qlcnic_83xx_msix_sriov_vf_poll
,
1979 netif_napi_add(netdev
, &sds_ring
->napi
,
1985 if (qlcnic_alloc_tx_rings(adapter
, netdev
)) {
1986 qlcnic_free_sds_rings(recv_ctx
);
1990 if ((adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
1991 !(adapter
->flags
& QLCNIC_TX_INTR_SHARED
)) {
1992 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
1993 tx_ring
= &adapter
->tx_ring
[ring
];
1994 netif_napi_add(netdev
, &tx_ring
->napi
,
1995 qlcnic_83xx_msix_tx_poll
,
2003 void qlcnic_83xx_napi_del(struct qlcnic_adapter
*adapter
)
2006 struct qlcnic_host_sds_ring
*sds_ring
;
2007 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
2008 struct qlcnic_host_tx_ring
*tx_ring
;
2010 for (ring
= 0; ring
< adapter
->drv_sds_rings
; ring
++) {
2011 sds_ring
= &recv_ctx
->sds_rings
[ring
];
2012 netif_napi_del(&sds_ring
->napi
);
2015 qlcnic_free_sds_rings(adapter
->recv_ctx
);
2017 if ((adapter
->flags
& QLCNIC_MSIX_ENABLED
) &&
2018 !(adapter
->flags
& QLCNIC_TX_INTR_SHARED
)) {
2019 for (ring
= 0; ring
< adapter
->drv_tx_rings
; ring
++) {
2020 tx_ring
= &adapter
->tx_ring
[ring
];
2021 netif_napi_del(&tx_ring
->napi
);
2025 qlcnic_free_tx_rings(adapter
);
2028 void qlcnic_83xx_process_rcv_diag(struct qlcnic_adapter
*adapter
,
2029 int ring
, u64 sts_data
[])
2031 struct qlcnic_recv_context
*recv_ctx
= adapter
->recv_ctx
;
2032 struct sk_buff
*skb
;
2033 struct qlcnic_host_rds_ring
*rds_ring
;
2036 if (unlikely(ring
>= adapter
->max_rds_rings
))
2039 rds_ring
= &recv_ctx
->rds_rings
[ring
];
2040 index
= qlcnic_83xx_hndl(sts_data
[0]);
2041 if (unlikely(index
>= rds_ring
->num_desc
))
2044 length
= qlcnic_83xx_pktln(sts_data
[0]);
2046 skb
= qlcnic_process_rxbuf(adapter
, rds_ring
, index
, STATUS_CKSUM_OK
);
2050 if (length
> rds_ring
->skb_size
)
2051 skb_put(skb
, rds_ring
->skb_size
);
2053 skb_put(skb
, length
);
2055 if (!qlcnic_check_loopback_buff(skb
->data
, adapter
->mac_addr
))
2056 adapter
->ahw
->diag_cnt
++;
2058 dump_skb(skb
, adapter
);
2060 dev_kfree_skb_any(skb
);
2064 void qlcnic_83xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring
*sds_ring
)
2066 struct qlcnic_adapter
*adapter
= sds_ring
->adapter
;
2067 struct status_desc
*desc
;
2070 u32 consumer
= sds_ring
->consumer
;
2072 desc
= &sds_ring
->desc_head
[consumer
];
2073 sts_data
[0] = le64_to_cpu(desc
->status_desc_data
[0]);
2074 sts_data
[1] = le64_to_cpu(desc
->status_desc_data
[1]);
2075 opcode
= qlcnic_83xx_opcode(sts_data
[1]);
2079 ring
= QLCNIC_FETCH_RING_ID(qlcnic_83xx_hndl(sts_data
[0]));
2080 qlcnic_83xx_process_rcv_diag(adapter
, ring
, sts_data
);
2081 desc
= &sds_ring
->desc_head
[consumer
];
2082 desc
->status_desc_data
[0] = cpu_to_le64(STATUS_OWNER_PHANTOM
);
2083 consumer
= get_next_index(consumer
, sds_ring
->num_desc
);
2084 sds_ring
->consumer
= consumer
;
2085 writel(consumer
, sds_ring
->crb_sts_consumer
);