]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: vlan: add protocol argument to packet tagging functions
[mirror_ubuntu-jammy-kernel.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_io.c
CommitLineData
577ae39d
JK		 1/*
2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2013 QLogic Corporation
4 *
5 * See LICENSE.qlcnic for copyright and licensing details.
6 */
7
c70001a9
SC		 8#include <linux/netdevice.h>
9#include <linux/if_vlan.h>
10#include <net/ip.h>
11#include <linux/ipv6.h>
1bcac3b0 12#include <net/checksum.h>
c70001a9
SC		 13
14#include "qlcnic.h"
15
c70001a9
SC		 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
26
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))
33
34#define qlcnic_set_tx_port(_desc, _port) \
35 ((_desc)->port_ctxid = ((_port) & 0xf) | (((_port) << 4) & 0xf0))
36
37#define qlcnic_set_tx_flags_opcode(_desc, _flags, _opcode) \
38 ((_desc)->flags_opcode |= \
39 cpu_to_le16(((_flags) & 0x7f) | (((_opcode) & 0x3f) << 7)))
40
41#define qlcnic_set_tx_frags_len(_desc, _frags, _len) \
42 ((_desc)->nfrags__length = \
43 cpu_to_le32(((_frags) & 0xff) | (((_len) & 0xffffff) << 8)))
44
45/* owner bits of status_desc */
46#define STATUS_OWNER_HOST (0x1ULL << 56)
47#define STATUS_OWNER_PHANTOM (0x2ULL << 56)
48
49/* Status descriptor:
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
53 */
54#define qlcnic_get_sts_port(sts_data) \
55 ((sts_data) & 0x0F)
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)
72
73#define qlcnic_get_lro_sts_refhandle(sts_data) \
5796bd04 74 ((sts_data) & 0x07FFF)
c70001a9
SC		 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)
91
99e85879
SS		 92#define qlcnic_83xx_get_lro_sts_mss(sts) ((sts) & 0xffff)
93
c70001a9
SC		 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
100
4be41e92
SC		 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)
106
107#define QLCNIC_TCP_TS_HDR_SIZE (QLCNIC_TCP_HDR_SIZE + QLCNIC_TCP_TS_OPTION_SIZE)
108
c70001a9
SC		 109/* for status field in status_desc */
110#define STATUS_CKSUM_LOOP 0
111#define STATUS_CKSUM_OK 2
d17dd0d9 112
4be41e92
SC		 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)
126
127struct sk_buff *qlcnic_process_rxbuf(struct qlcnic_adapter *,
128 struct qlcnic_host_rds_ring *, u16, u16);
129
130inline void qlcnic_83xx_enable_tx_intr(struct qlcnic_adapter *adapter,
131 struct qlcnic_host_tx_ring *tx_ring)
132{
133 writel(0, tx_ring->crb_intr_mask);
134}
135
136inline void qlcnic_83xx_disable_tx_intr(struct qlcnic_adapter *adapter,
137 struct qlcnic_host_tx_ring *tx_ring)
138{
139 writel(1, tx_ring->crb_intr_mask);
140}
141
142static inline u8 qlcnic_mac_hash(u64 mac)
143{
144 return (u8)((mac & 0xff) ^ ((mac >> 40) & 0xff));
145}
146
147static inline u32 qlcnic_get_ref_handle(struct qlcnic_adapter *adapter,
148 u16 handle, u8 ring_id)
149{
7cb03b23
RB		 150 unsigned short device = adapter->pdev->device;
151
152 if ((device == PCI_DEVICE_ID_QLOGIC_QLE834X) ||
153 (device == PCI_DEVICE_ID_QLOGIC_VF_QLE834X))
4be41e92
SC		 154 return handle | (ring_id << 15);
155 else
156 return handle;
157}
158
53643a75
SS		 159static inline int qlcnic_82xx_is_lb_pkt(u64 sts_data)
160{
161 return (qlcnic_get_sts_status(sts_data) == STATUS_CKSUM_LOOP) ? 1 : 0;
162}
163
164void qlcnic_add_lb_filter(struct qlcnic_adapter *adapter, struct sk_buff *skb,
165 int loopback_pkt, __le16 vlan_id)
166{
167 struct ethhdr *phdr = (struct ethhdr *)(skb->data);
168 struct qlcnic_filter *fil, *tmp_fil;
b67bfe0d 169 struct hlist_node *n;
53643a75
SS		 170 struct hlist_head *head;
171 unsigned long time;
172 u64 src_addr = 0;
173 u8 hindex, found = 0, op;
174 int ret;
175
176 memcpy(&src_addr, phdr->h_source, ETH_ALEN);
177
178 if (loopback_pkt) {
179 if (adapter->rx_fhash.fnum >= adapter->rx_fhash.fmax)
180 return;
181
182 hindex = qlcnic_mac_hash(src_addr) &
183 (adapter->fhash.fbucket_size - 1);
184 head = &(adapter->rx_fhash.fhead[hindex]);
185
b67bfe0d 186 hlist_for_each_entry_safe(tmp_fil, n, head, fnode) {
53643a75
SS		 187 if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
188 tmp_fil->vlan_id == vlan_id) {
189 time = tmp_fil->ftime;
190 if (jiffies > (QLCNIC_READD_AGE * HZ + time))
191 tmp_fil->ftime = jiffies;
192 return;
193 }
194 }
195
196 fil = kzalloc(sizeof(struct qlcnic_filter), GFP_ATOMIC);
197 if (!fil)
198 return;
199
200 fil->ftime = jiffies;
201 memcpy(fil->faddr, &src_addr, ETH_ALEN);
202 fil->vlan_id = vlan_id;
203 spin_lock(&adapter->rx_mac_learn_lock);
204 hlist_add_head(&(fil->fnode), head);
205 adapter->rx_fhash.fnum++;
206 spin_unlock(&adapter->rx_mac_learn_lock);
207 } else {
208 hindex = qlcnic_mac_hash(src_addr) &
209 (adapter->fhash.fbucket_size - 1);
210 head = &(adapter->rx_fhash.fhead[hindex]);
211 spin_lock(&adapter->rx_mac_learn_lock);
b67bfe0d 212 hlist_for_each_entry_safe(tmp_fil, n, head, fnode) {
53643a75
SS		 213 if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
214 tmp_fil->vlan_id == vlan_id) {
215 found = 1;
216 break;
217 }
218 }
219
220 if (!found) {
221 spin_unlock(&adapter->rx_mac_learn_lock);
222 return;
223 }
224
225 op = vlan_id ? QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_ADD;
226 ret = qlcnic_sre_macaddr_change(adapter, (u8 *)&src_addr,
227 vlan_id, op);
228 if (!ret) {
229 op = vlan_id ? QLCNIC_MAC_VLAN_DEL : QLCNIC_MAC_DEL;
230 ret = qlcnic_sre_macaddr_change(adapter,
231 (u8 *)&src_addr,
232 vlan_id, op);
233 if (!ret) {
234 hlist_del(&(tmp_fil->fnode));
235 adapter->rx_fhash.fnum--;
236 }
237 }
238 spin_unlock(&adapter->rx_mac_learn_lock);
239 }
240}
241
7e2cf4fe
SC		 242void qlcnic_82xx_change_filter(struct qlcnic_adapter *adapter, u64 *uaddr,
243 __le16 vlan_id)
c70001a9
SC		 244{
245 struct cmd_desc_type0 *hwdesc;
246 struct qlcnic_nic_req *req;
247 struct qlcnic_mac_req *mac_req;
248 struct qlcnic_vlan_req *vlan_req;
7e2cf4fe 249 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
c70001a9
SC		 250 u32 producer;
251 u64 word;
252
253 producer = tx_ring->producer;
254 hwdesc = &tx_ring->desc_head[tx_ring->producer];
255
256 req = (struct qlcnic_nic_req *)hwdesc;
257 memset(req, 0, sizeof(struct qlcnic_nic_req));
258 req->qhdr = cpu_to_le64(QLCNIC_REQUEST << 23);
259
260 word = QLCNIC_MAC_EVENT | ((u64)(adapter->portnum) << 16);
261 req->req_hdr = cpu_to_le64(word);
262
263 mac_req = (struct qlcnic_mac_req *)&(req->words[0]);
264 mac_req->op = vlan_id ? QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_ADD;
265 memcpy(mac_req->mac_addr, &uaddr, ETH_ALEN);
266
267 vlan_req = (struct qlcnic_vlan_req *)&req->words[1];
268 vlan_req->vlan_id = vlan_id;
269
270 tx_ring->producer = get_next_index(producer, tx_ring->num_desc);
271 smp_mb();
272}
273
d17dd0d9 274static void qlcnic_send_filter(struct qlcnic_adapter *adapter,
d17dd0d9
SC		 275 struct cmd_desc_type0 *first_desc,
276 struct sk_buff *skb)
c70001a9 277{
c70001a9 278 struct qlcnic_filter *fil, *tmp_fil;
b67bfe0d 279 struct hlist_node *n;
c70001a9 280 struct hlist_head *head;
4be41e92 281 struct net_device *netdev = adapter->netdev;
7e2cf4fe 282 struct ethhdr *phdr = (struct ethhdr *)(skb->data);
c70001a9
SC		 283 u64 src_addr = 0;
284 __le16 vlan_id = 0;
285 u8 hindex;
286
4be41e92 287 if (ether_addr_equal(phdr->h_source, adapter->mac_addr))
c70001a9
SC		 288 return;
289
4be41e92
SC		 290 if (adapter->fhash.fnum >= adapter->fhash.fmax) {
291 adapter->stats.mac_filter_limit_overrun++;
292 netdev_info(netdev, "Can not add more than %d mac addresses\n",
293 adapter->fhash.fmax);
c70001a9 294 return;
4be41e92 295 }
c70001a9 296
c70001a9 297 memcpy(&src_addr, phdr->h_source, ETH_ALEN);
4be41e92 298 hindex = qlcnic_mac_hash(src_addr) & (adapter->fhash.fbucket_size - 1);
c70001a9
SC		 299 head = &(adapter->fhash.fhead[hindex]);
300
b67bfe0d 301 hlist_for_each_entry_safe(tmp_fil, n, head, fnode) {
c70001a9 302 if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
7e2cf4fe 303 tmp_fil->vlan_id == vlan_id) {
d17dd0d9 304 if (jiffies > (QLCNIC_READD_AGE * HZ + tmp_fil->ftime))
7e2cf4fe
SC		 305 qlcnic_change_filter(adapter, &src_addr,
306 vlan_id);
c70001a9
SC		 307 tmp_fil->ftime = jiffies;
308 return;
309 }
310 }
311
312 fil = kzalloc(sizeof(struct qlcnic_filter), GFP_ATOMIC);
313 if (!fil)
314 return;
315
7e2cf4fe 316 qlcnic_change_filter(adapter, &src_addr, vlan_id);
c70001a9
SC		 317 fil->ftime = jiffies;
318 fil->vlan_id = vlan_id;
319 memcpy(fil->faddr, &src_addr, ETH_ALEN);
320 spin_lock(&adapter->mac_learn_lock);
321 hlist_add_head(&(fil->fnode), head);
322 adapter->fhash.fnum++;
323 spin_unlock(&adapter->mac_learn_lock);
324}
325
d17dd0d9
SC		 326static int qlcnic_tx_pkt(struct qlcnic_adapter *adapter,
327 struct cmd_desc_type0 *first_desc, struct sk_buff *skb)
c70001a9 328{
d17dd0d9 329 u8 l4proto, opcode = 0, hdr_len = 0;
c70001a9 330 u16 flags = 0, vlan_tci = 0;
d17dd0d9 331 int copied, offset, copy_len, size;
c70001a9
SC		 332 struct cmd_desc_type0 *hwdesc;
333 struct vlan_ethhdr *vh;
334 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
335 u16 protocol = ntohs(skb->protocol);
336 u32 producer = tx_ring->producer;
337
338 if (protocol == ETH_P_8021Q) {
339 vh = (struct vlan_ethhdr *)skb->data;
340 flags = FLAGS_VLAN_TAGGED;
341 vlan_tci = ntohs(vh->h_vlan_TCI);
342 protocol = ntohs(vh->h_vlan_encapsulated_proto);
343 } else if (vlan_tx_tag_present(skb)) {
344 flags = FLAGS_VLAN_OOB;
345 vlan_tci = vlan_tx_tag_get(skb);
346 }
347 if (unlikely(adapter->pvid)) {
348 if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
349 return -EIO;
350 if (vlan_tci && (adapter->flags & QLCNIC_TAGGING_ENABLED))
351 goto set_flags;
352
353 flags = FLAGS_VLAN_OOB;
354 vlan_tci = adapter->pvid;
355 }
356set_flags:
357 qlcnic_set_tx_vlan_tci(first_desc, vlan_tci);
358 qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
359
360 if (*(skb->data) & BIT_0) {
361 flags |= BIT_0;
362 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
363 }
364 opcode = TX_ETHER_PKT;
365 if ((adapter->netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
d17dd0d9 366 skb_shinfo(skb)->gso_size > 0) {
c70001a9 367 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
c70001a9
SC		 368 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
369 first_desc->total_hdr_length = hdr_len;
c70001a9
SC		 370 opcode = (protocol == ETH_P_IPV6) ? TX_TCP_LSO6 : TX_TCP_LSO;
371
372 /* For LSO, we need to copy the MAC/IP/TCP headers into
373 * the descriptor ring */
374 copied = 0;
375 offset = 2;
376
377 if (flags & FLAGS_VLAN_OOB) {
378 first_desc->total_hdr_length += VLAN_HLEN;
379 first_desc->tcp_hdr_offset = VLAN_HLEN;
380 first_desc->ip_hdr_offset = VLAN_HLEN;
d17dd0d9 381
c70001a9
SC		 382 /* Only in case of TSO on vlan device */
383 flags |= FLAGS_VLAN_TAGGED;
384
385 /* Create a TSO vlan header template for firmware */
c70001a9
SC		 386 hwdesc = &tx_ring->desc_head[producer];
387 tx_ring->cmd_buf_arr[producer].skb = NULL;
388
389 copy_len = min((int)sizeof(struct cmd_desc_type0) -
d17dd0d9 390 offset, hdr_len + VLAN_HLEN);
c70001a9
SC		 391
392 vh = (struct vlan_ethhdr *)((char *) hwdesc + 2);
393 skb_copy_from_linear_data(skb, vh, 12);
394 vh->h_vlan_proto = htons(ETH_P_8021Q);
395 vh->h_vlan_TCI = htons(vlan_tci);
396
397 skb_copy_from_linear_data_offset(skb, 12,
d17dd0d9
SC		 398 (char *)vh + 16,
399 copy_len - 16);
c70001a9
SC		 400 copied = copy_len - VLAN_HLEN;
401 offset = 0;
c70001a9
SC		 402 producer = get_next_index(producer, tx_ring->num_desc);
403 }
404
405 while (copied < hdr_len) {
d17dd0d9
SC		 406 size = (int)sizeof(struct cmd_desc_type0) - offset;
407 copy_len = min(size, (hdr_len - copied));
c70001a9
SC		 408 hwdesc = &tx_ring->desc_head[producer];
409 tx_ring->cmd_buf_arr[producer].skb = NULL;
c70001a9 410 skb_copy_from_linear_data_offset(skb, copied,
d17dd0d9
SC		 411 (char *)hwdesc +
412 offset, copy_len);
c70001a9
SC		 413 copied += copy_len;
414 offset = 0;
c70001a9
SC		 415 producer = get_next_index(producer, tx_ring->num_desc);
416 }
417
418 tx_ring->producer = producer;
419 smp_mb();
420 adapter->stats.lso_frames++;
421
422 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
c70001a9
SC		 423 if (protocol == ETH_P_IP) {
424 l4proto = ip_hdr(skb)->protocol;
425
426 if (l4proto == IPPROTO_TCP)
427 opcode = TX_TCP_PKT;
428 else if (l4proto == IPPROTO_UDP)
429 opcode = TX_UDP_PKT;
430 } else if (protocol == ETH_P_IPV6) {
431 l4proto = ipv6_hdr(skb)->nexthdr;
432
433 if (l4proto == IPPROTO_TCP)
434 opcode = TX_TCPV6_PKT;
435 else if (l4proto == IPPROTO_UDP)
436 opcode = TX_UDPV6_PKT;
437 }
438 }
439 first_desc->tcp_hdr_offset += skb_transport_offset(skb);
440 first_desc->ip_hdr_offset += skb_network_offset(skb);
441 qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
442
443 return 0;
444}
445
d17dd0d9
SC		 446static int qlcnic_map_tx_skb(struct pci_dev *pdev, struct sk_buff *skb,
447 struct qlcnic_cmd_buffer *pbuf)
c70001a9
SC		 448{
449 struct qlcnic_skb_frag *nf;
450 struct skb_frag_struct *frag;
451 int i, nr_frags;
452 dma_addr_t map;
453
454 nr_frags = skb_shinfo(skb)->nr_frags;
455 nf = &pbuf->frag_array[0];
456
d17dd0d9
SC		 457 map = pci_map_single(pdev, skb->data, skb_headlen(skb),
458 PCI_DMA_TODEVICE);
c70001a9
SC		 459 if (pci_dma_mapping_error(pdev, map))
460 goto out_err;
461
462 nf->dma = map;
463 nf->length = skb_headlen(skb);
464
465 for (i = 0; i < nr_frags; i++) {
466 frag = &skb_shinfo(skb)->frags[i];
467 nf = &pbuf->frag_array[i+1];
c70001a9
SC		 468 map = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
469 DMA_TO_DEVICE);
470 if (dma_mapping_error(&pdev->dev, map))
471 goto unwind;
472
473 nf->dma = map;
474 nf->length = skb_frag_size(frag);
475 }
476
477 return 0;
478
479unwind:
480 while (--i >= 0) {
481 nf = &pbuf->frag_array[i+1];
482 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
483 }
484
485 nf = &pbuf->frag_array[0];
486 pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
487
488out_err:
489 return -ENOMEM;
490}
491
d17dd0d9
SC		 492static void qlcnic_unmap_buffers(struct pci_dev *pdev, struct sk_buff *skb,
493 struct qlcnic_cmd_buffer *pbuf)
c70001a9
SC		 494{
495 struct qlcnic_skb_frag *nf = &pbuf->frag_array[0];
d17dd0d9 496 int i, nr_frags = skb_shinfo(skb)->nr_frags;
c70001a9
SC		 497
498 for (i = 0; i < nr_frags; i++) {
499 nf = &pbuf->frag_array[i+1];
500 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
501 }
502
503 nf = &pbuf->frag_array[0];
504 pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
505 pbuf->skb = NULL;
506}
507
d17dd0d9 508static inline void qlcnic_clear_cmddesc(u64 *desc)
c70001a9
SC		 509{
510 desc[0] = 0ULL;
511 desc[2] = 0ULL;
512 desc[7] = 0ULL;
513}
514
d17dd0d9 515netdev_tx_t qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
c70001a9
SC		 516{
517 struct qlcnic_adapter *adapter = netdev_priv(netdev);
518 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
519 struct qlcnic_cmd_buffer *pbuf;
520 struct qlcnic_skb_frag *buffrag;
521 struct cmd_desc_type0 *hwdesc, *first_desc;
522 struct pci_dev *pdev;
523 struct ethhdr *phdr;
d17dd0d9
SC		 524 int i, k, frag_count, delta = 0;
525 u32 producer, num_txd;
c70001a9 526
d17dd0d9 527 num_txd = tx_ring->num_desc;
c70001a9
SC		 528
529 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
530 netif_stop_queue(netdev);
531 return NETDEV_TX_BUSY;
532 }
533
534 if (adapter->flags & QLCNIC_MACSPOOF) {
535 phdr = (struct ethhdr *)skb->data;
536 if (!ether_addr_equal(phdr->h_source, adapter->mac_addr))
537 goto drop_packet;
538 }
539
540 frag_count = skb_shinfo(skb)->nr_frags + 1;
541 /* 14 frags supported for normal packet and
542 * 32 frags supported for TSO packet
543 */
544 if (!skb_is_gso(skb) && frag_count > QLCNIC_MAX_FRAGS_PER_TX) {
c70001a9
SC		 545 for (i = 0; i < (frag_count - QLCNIC_MAX_FRAGS_PER_TX); i++)
546 delta += skb_frag_size(&skb_shinfo(skb)->frags[i]);
547
548 if (!__pskb_pull_tail(skb, delta))
549 goto drop_packet;
550
551 frag_count = 1 + skb_shinfo(skb)->nr_frags;
552 }
553
554 if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
555 netif_stop_queue(netdev);
d17dd0d9 556 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
c70001a9 557 netif_start_queue(netdev);
d17dd0d9 558 } else {
c70001a9
SC		 559 adapter->stats.xmit_off++;
560 return NETDEV_TX_BUSY;
561 }
562 }
563
564 producer = tx_ring->producer;
565 pbuf = &tx_ring->cmd_buf_arr[producer];
c70001a9 566 pdev = adapter->pdev;
d17dd0d9
SC		 567 first_desc = &tx_ring->desc_head[producer];
568 hwdesc = &tx_ring->desc_head[producer];
c70001a9
SC		 569 qlcnic_clear_cmddesc((u64 *)hwdesc);
570
571 if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
572 adapter->stats.tx_dma_map_error++;
573 goto drop_packet;
574 }
575
576 pbuf->skb = skb;
577 pbuf->frag_count = frag_count;
578
579 qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
580 qlcnic_set_tx_port(first_desc, adapter->portnum);
581
582 for (i = 0; i < frag_count; i++) {
c70001a9
SC		 583 k = i % 4;
584
585 if ((k == 0) && (i > 0)) {
586 /* move to next desc.*/
587 producer = get_next_index(producer, num_txd);
588 hwdesc = &tx_ring->desc_head[producer];
589 qlcnic_clear_cmddesc((u64 *)hwdesc);
590 tx_ring->cmd_buf_arr[producer].skb = NULL;
591 }
592
593 buffrag = &pbuf->frag_array[i];
c70001a9
SC		 594 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
595 switch (k) {
596 case 0:
597 hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
598 break;
599 case 1:
600 hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
601 break;
602 case 2:
603 hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
604 break;
605 case 3:
606 hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
607 break;
608 }
609 }
610
611 tx_ring->producer = get_next_index(producer, num_txd);
612 smp_mb();
613
614 if (unlikely(qlcnic_tx_pkt(adapter, first_desc, skb)))
615 goto unwind_buff;
616
fe1adc6b 617 if (adapter->drv_mac_learn)
4be41e92 618 qlcnic_send_filter(adapter, first_desc, skb);
c70001a9
SC		 619
620 adapter->stats.txbytes += skb->len;
621 adapter->stats.xmitcalled++;
622
623 qlcnic_update_cmd_producer(tx_ring);
624
625 return NETDEV_TX_OK;
626
627unwind_buff:
628 qlcnic_unmap_buffers(pdev, skb, pbuf);
629drop_packet:
630 adapter->stats.txdropped++;
631 dev_kfree_skb_any(skb);
632 return NETDEV_TX_OK;
633}
634
7f966452 635void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
c70001a9
SC		 636{
637 struct net_device *netdev = adapter->netdev;
638
639 if (adapter->ahw->linkup && !linkup) {
640 netdev_info(netdev, "NIC Link is down\n");
641 adapter->ahw->linkup = 0;
642 if (netif_running(netdev)) {
643 netif_carrier_off(netdev);
644 netif_stop_queue(netdev);
645 }
646 } else if (!adapter->ahw->linkup && linkup) {
647 netdev_info(netdev, "NIC Link is up\n");
648 adapter->ahw->linkup = 1;
649 if (netif_running(netdev)) {
650 netif_carrier_on(netdev);
651 netif_wake_queue(netdev);
652 }
653 }
654}
655
d17dd0d9
SC		 656static int qlcnic_alloc_rx_skb(struct qlcnic_adapter *adapter,
657 struct qlcnic_host_rds_ring *rds_ring,
658 struct qlcnic_rx_buffer *buffer)
c70001a9
SC		 659{
660 struct sk_buff *skb;
661 dma_addr_t dma;
662 struct pci_dev *pdev = adapter->pdev;
663
664 skb = netdev_alloc_skb(adapter->netdev, rds_ring->skb_size);
665 if (!skb) {
666 adapter->stats.skb_alloc_failure++;
667 return -ENOMEM;
668 }
669
670 skb_reserve(skb, NET_IP_ALIGN);
4be41e92
SC		 671 dma = pci_map_single(pdev, skb->data,
672 rds_ring->dma_size, PCI_DMA_FROMDEVICE);
c70001a9
SC		 673
674 if (pci_dma_mapping_error(pdev, dma)) {
675 adapter->stats.rx_dma_map_error++;
676 dev_kfree_skb_any(skb);
677 return -ENOMEM;
678 }
679
680 buffer->skb = skb;
681 buffer->dma = dma;
682
683 return 0;
684}
685
686static void qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter *adapter,
4be41e92
SC		 687 struct qlcnic_host_rds_ring *rds_ring,
688 u8 ring_id)
c70001a9
SC		 689{
690 struct rcv_desc *pdesc;
691 struct qlcnic_rx_buffer *buffer;
692 int count = 0;
4be41e92 693 uint32_t producer, handle;
c70001a9
SC		 694 struct list_head *head;
695
696 if (!spin_trylock(&rds_ring->lock))
697 return;
698
699 producer = rds_ring->producer;
c70001a9 700 head = &rds_ring->free_list;
d17dd0d9 701 while (!list_empty(head)) {
c70001a9
SC		 702 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
703
704 if (!buffer->skb) {
705 if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
706 break;
707 }
c70001a9
SC		 708 count++;
709 list_del(&buffer->list);
710
711 /* make a rcv descriptor */
712 pdesc = &rds_ring->desc_head[producer];
4be41e92
SC		 713 handle = qlcnic_get_ref_handle(adapter,
714 buffer->ref_handle, ring_id);
715 pdesc->reference_handle = cpu_to_le16(handle);
c70001a9
SC		 716 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
717 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
c70001a9
SC		 718 producer = get_next_index(producer, rds_ring->num_desc);
719 }
c70001a9
SC		 720 if (count) {
721 rds_ring->producer = producer;
722 writel((producer - 1) & (rds_ring->num_desc - 1),
d17dd0d9 723 rds_ring->crb_rcv_producer);
c70001a9
SC		 724 }
725 spin_unlock(&rds_ring->lock);
726}
727
4be41e92
SC		 728static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter,
729 struct qlcnic_host_tx_ring *tx_ring,
730 int budget)
c70001a9
SC		 731{
732 u32 sw_consumer, hw_consumer;
d17dd0d9 733 int i, done, count = 0;
c70001a9
SC		 734 struct qlcnic_cmd_buffer *buffer;
735 struct pci_dev *pdev = adapter->pdev;
736 struct net_device *netdev = adapter->netdev;
737 struct qlcnic_skb_frag *frag;
c70001a9
SC		 738
739 if (!spin_trylock(&adapter->tx_clean_lock))
740 return 1;
741
742 sw_consumer = tx_ring->sw_consumer;
743 hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
744
745 while (sw_consumer != hw_consumer) {
746 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
747 if (buffer->skb) {
748 frag = &buffer->frag_array[0];
749 pci_unmap_single(pdev, frag->dma, frag->length,
750 PCI_DMA_TODEVICE);
751 frag->dma = 0ULL;
752 for (i = 1; i < buffer->frag_count; i++) {
753 frag++;
754 pci_unmap_page(pdev, frag->dma, frag->length,
755 PCI_DMA_TODEVICE);
756 frag->dma = 0ULL;
757 }
c70001a9
SC		 758 adapter->stats.xmitfinished++;
759 dev_kfree_skb_any(buffer->skb);
760 buffer->skb = NULL;
761 }
762
763 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
4be41e92 764 if (++count >= budget)
c70001a9
SC		 765 break;
766 }
767
768 if (count && netif_running(netdev)) {
769 tx_ring->sw_consumer = sw_consumer;
c70001a9 770 smp_mb();
c70001a9
SC		 771 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
772 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
773 netif_wake_queue(netdev);
774 adapter->stats.xmit_on++;
775 }
776 }
777 adapter->tx_timeo_cnt = 0;
778 }
779 /*
780 * If everything is freed up to consumer then check if the ring is full
781 * If the ring is full then check if more needs to be freed and
782 * schedule the call back again.
783 *
784 * This happens when there are 2 CPUs. One could be freeing and the
785 * other filling it. If the ring is full when we get out of here and
786 * the card has already interrupted the host then the host can miss the
787 * interrupt.
788 *
789 * There is still a possible race condition and the host could miss an
790 * interrupt. The card has to take care of this.
791 */
792 hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
793 done = (sw_consumer == hw_consumer);
794 spin_unlock(&adapter->tx_clean_lock);
795
796 return done;
797}
798
799static int qlcnic_poll(struct napi_struct *napi, int budget)
800{
4be41e92 801 int tx_complete, work_done;
d17dd0d9
SC		 802 struct qlcnic_host_sds_ring *sds_ring;
803 struct qlcnic_adapter *adapter;
c70001a9 804
d17dd0d9
SC		 805 sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
806 adapter = sds_ring->adapter;
4be41e92
SC		 807 tx_complete = qlcnic_process_cmd_ring(adapter, adapter->tx_ring,
808 budget);
c70001a9 809 work_done = qlcnic_process_rcv_ring(sds_ring, budget);
c70001a9
SC		 810 if ((work_done < budget) && tx_complete) {
811 napi_complete(&sds_ring->napi);
812 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
813 qlcnic_enable_int(sds_ring);
814 }
815
816 return work_done;
817}
818
819static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
820{
d17dd0d9
SC		 821 struct qlcnic_host_sds_ring *sds_ring;
822 struct qlcnic_adapter *adapter;
c70001a9
SC		 823 int work_done;
824
d17dd0d9
SC		 825 sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
826 adapter = sds_ring->adapter;
827
c70001a9
SC		 828 work_done = qlcnic_process_rcv_ring(sds_ring, budget);
829
830 if (work_done < budget) {
831 napi_complete(&sds_ring->napi);
832 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
833 qlcnic_enable_int(sds_ring);
834 }
835
836 return work_done;
837}
838
d17dd0d9
SC		 839static void qlcnic_handle_linkevent(struct qlcnic_adapter *adapter,
840 struct qlcnic_fw_msg *msg)
c70001a9
SC		 841{
842 u32 cable_OUI;
d17dd0d9
SC		 843 u16 cable_len, link_speed;
844 u8 link_status, module, duplex, autoneg, lb_status = 0;
c70001a9
SC		 845 struct net_device *netdev = adapter->netdev;
846
79788450 847 adapter->ahw->has_link_events = 1;
c70001a9
SC		 848
849 cable_OUI = msg->body[1] & 0xffffffff;
850 cable_len = (msg->body[1] >> 32) & 0xffff;
851 link_speed = (msg->body[1] >> 48) & 0xffff;
852
853 link_status = msg->body[2] & 0xff;
854 duplex = (msg->body[2] >> 16) & 0xff;
855 autoneg = (msg->body[2] >> 24) & 0xff;
856 lb_status = (msg->body[2] >> 32) & 0x3;
857
858 module = (msg->body[2] >> 8) & 0xff;
859 if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE)
d17dd0d9
SC		 860 dev_info(&netdev->dev,
861 "unsupported cable: OUI 0x%x, length %d\n",
862 cable_OUI, cable_len);
c70001a9
SC		 863 else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN)
864 dev_info(&netdev->dev, "unsupported cable length %d\n",
d17dd0d9 865 cable_len);
c70001a9
SC		 866
867 if (!link_status && (lb_status == QLCNIC_ILB_MODE ||
868 lb_status == QLCNIC_ELB_MODE))
869 adapter->ahw->loopback_state |= QLCNIC_LINKEVENT;
870
871 qlcnic_advert_link_change(adapter, link_status);
872
873 if (duplex == LINKEVENT_FULL_DUPLEX)
79788450 874 adapter->ahw->link_duplex = DUPLEX_FULL;
c70001a9 875 else
79788450 876 adapter->ahw->link_duplex = DUPLEX_HALF;
c70001a9 877
79788450
SC		 878 adapter->ahw->module_type = module;
879 adapter->ahw->link_autoneg = autoneg;
c70001a9
SC		 880
881 if (link_status) {
79788450 882 adapter->ahw->link_speed = link_speed;
c70001a9 883 } else {
79788450
SC		 884 adapter->ahw->link_speed = SPEED_UNKNOWN;
885 adapter->ahw->link_duplex = DUPLEX_UNKNOWN;
c70001a9
SC		 886 }
887}
888
d17dd0d9
SC		 889static void qlcnic_handle_fw_message(int desc_cnt, int index,
890 struct qlcnic_host_sds_ring *sds_ring)
c70001a9
SC		 891{
892 struct qlcnic_fw_msg msg;
893 struct status_desc *desc;
894 struct qlcnic_adapter *adapter;
895 struct device *dev;
896 int i = 0, opcode, ret;
897
898 while (desc_cnt > 0 && i < 8) {
899 desc = &sds_ring->desc_head[index];
900 msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
901 msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
902
903 index = get_next_index(index, sds_ring->num_desc);
904 desc_cnt--;
905 }
906
907 adapter = sds_ring->adapter;
908 dev = &adapter->pdev->dev;
909 opcode = qlcnic_get_nic_msg_opcode(msg.body[0]);
910
911 switch (opcode) {
912 case QLCNIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
913 qlcnic_handle_linkevent(adapter, &msg);
914 break;
915 case QLCNIC_C2H_OPCODE_CONFIG_LOOPBACK:
916 ret = (u32)(msg.body[1]);
917 switch (ret) {
918 case 0:
919 adapter->ahw->loopback_state |= QLCNIC_LB_RESPONSE;
920 break;
921 case 1:
922 dev_info(dev, "loopback already in progress\n");
79788450 923 adapter->ahw->diag_cnt = -QLCNIC_TEST_IN_PROGRESS;
c70001a9
SC		 924 break;
925 case 2:
926 dev_info(dev, "loopback cable is not connected\n");
79788450 927 adapter->ahw->diag_cnt = -QLCNIC_LB_CABLE_NOT_CONN;
c70001a9
SC		 928 break;
929 default:
d17dd0d9
SC		 930 dev_info(dev,
931 "loopback configure request failed, err %x\n",
932 ret);
79788450 933 adapter->ahw->diag_cnt = -QLCNIC_UNDEFINED_ERROR;
c70001a9
SC		 934 break;
935 }
936 break;
937 default:
938 break;
939 }
940}
941
4be41e92
SC		 942struct sk_buff *qlcnic_process_rxbuf(struct qlcnic_adapter *adapter,
943 struct qlcnic_host_rds_ring *ring,
944 u16 index, u16 cksum)
c70001a9
SC		 945{
946 struct qlcnic_rx_buffer *buffer;
947 struct sk_buff *skb;
948
4be41e92 949 buffer = &ring->rx_buf_arr[index];
c70001a9
SC		 950 if (unlikely(buffer->skb == NULL)) {
951 WARN_ON(1);
952 return NULL;
953 }
954
4be41e92 955 pci_unmap_single(adapter->pdev, buffer->dma, ring->dma_size,
d17dd0d9 956 PCI_DMA_FROMDEVICE);
c70001a9
SC		 957
958 skb = buffer->skb;
c70001a9 959 if (likely((adapter->netdev->features & NETIF_F_RXCSUM) &&
d17dd0d9 960 (cksum == STATUS_CKSUM_OK || cksum == STATUS_CKSUM_LOOP))) {
c70001a9
SC		 961 adapter->stats.csummed++;
962 skb->ip_summed = CHECKSUM_UNNECESSARY;
963 } else {
964 skb_checksum_none_assert(skb);
965 }
966
4be41e92 967
c70001a9
SC		 968 buffer->skb = NULL;
969
970 return skb;
971}
972
d17dd0d9
SC		 973static inline int qlcnic_check_rx_tagging(struct qlcnic_adapter *adapter,
974 struct sk_buff *skb, u16 *vlan_tag)
c70001a9
SC		 975{
976 struct ethhdr *eth_hdr;
977
978 if (!__vlan_get_tag(skb, vlan_tag)) {
d17dd0d9 979 eth_hdr = (struct ethhdr *)skb->data;
c70001a9
SC		 980 memmove(skb->data + VLAN_HLEN, eth_hdr, ETH_ALEN * 2);
981 skb_pull(skb, VLAN_HLEN);
982 }
983 if (!adapter->pvid)
984 return 0;
985
986 if (*vlan_tag == adapter->pvid) {
987 /* Outer vlan tag. Packet should follow non-vlan path */
988 *vlan_tag = 0xffff;
989 return 0;
990 }
991 if (adapter->flags & QLCNIC_TAGGING_ENABLED)
992 return 0;
993
994 return -EINVAL;
995}
996
997static struct qlcnic_rx_buffer *
998qlcnic_process_rcv(struct qlcnic_adapter *adapter,
d17dd0d9
SC		 999 struct qlcnic_host_sds_ring *sds_ring, int ring,
1000 u64 sts_data0)
c70001a9
SC		 1001{
1002 struct net_device *netdev = adapter->netdev;
1003 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1004 struct qlcnic_rx_buffer *buffer;
1005 struct sk_buff *skb;
1006 struct qlcnic_host_rds_ring *rds_ring;
53643a75
SS		 1007 int index, length, cksum, pkt_offset, is_lb_pkt;
1008 u16 vid = 0xffff, t_vid;
c70001a9
SC		 1009
1010 if (unlikely(ring >= adapter->max_rds_rings))
1011 return NULL;
1012
1013 rds_ring = &recv_ctx->rds_rings[ring];
1014
1015 index = qlcnic_get_sts_refhandle(sts_data0);
1016 if (unlikely(index >= rds_ring->num_desc))
1017 return NULL;
1018
1019 buffer = &rds_ring->rx_buf_arr[index];
c70001a9
SC		 1020 length = qlcnic_get_sts_totallength(sts_data0);
1021 cksum = qlcnic_get_sts_status(sts_data0);
1022 pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
1023
1024 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1025 if (!skb)
1026 return buffer;
1027
53643a75
SS		 1028 if (adapter->drv_mac_learn &&
1029 (adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
1030 t_vid = 0;
1031 is_lb_pkt = qlcnic_82xx_is_lb_pkt(sts_data0);
1032 qlcnic_add_lb_filter(adapter, skb, is_lb_pkt,
1033 cpu_to_le16(t_vid));
1034 }
1035
c70001a9
SC		 1036 if (length > rds_ring->skb_size)
1037 skb_put(skb, rds_ring->skb_size);
1038 else
1039 skb_put(skb, length);
1040
1041 if (pkt_offset)
1042 skb_pull(skb, pkt_offset);
1043
1044 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1045 adapter->stats.rxdropped++;
1046 dev_kfree_skb(skb);
1047 return buffer;
1048 }
1049
1050 skb->protocol = eth_type_trans(skb, netdev);
1051
1052 if (vid != 0xffff)
86a9bad3 1053 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
c70001a9
SC		 1054
1055 napi_gro_receive(&sds_ring->napi, skb);
1056
1057 adapter->stats.rx_pkts++;
1058 adapter->stats.rxbytes += length;
1059
1060 return buffer;
1061}
1062
1063#define QLC_TCP_HDR_SIZE 20
1064#define QLC_TCP_TS_OPTION_SIZE 12
1065#define QLC_TCP_TS_HDR_SIZE (QLC_TCP_HDR_SIZE + QLC_TCP_TS_OPTION_SIZE)
1066
1067static struct qlcnic_rx_buffer *
1068qlcnic_process_lro(struct qlcnic_adapter *adapter,
d17dd0d9 1069 int ring, u64 sts_data0, u64 sts_data1)
c70001a9
SC		 1070{
1071 struct net_device *netdev = adapter->netdev;
1072 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1073 struct qlcnic_rx_buffer *buffer;
1074 struct sk_buff *skb;
1075 struct qlcnic_host_rds_ring *rds_ring;
1076 struct iphdr *iph;
776e7bde 1077 struct ipv6hdr *ipv6h;
c70001a9
SC		 1078 struct tcphdr *th;
1079 bool push, timestamp;
53643a75
SS		 1080 int index, l2_hdr_offset, l4_hdr_offset, is_lb_pkt;
1081 u16 lro_length, length, data_offset, t_vid, vid = 0xffff;
c70001a9 1082 u32 seq_number;
c70001a9
SC		 1083
1084 if (unlikely(ring > adapter->max_rds_rings))
1085 return NULL;
1086
1087 rds_ring = &recv_ctx->rds_rings[ring];
1088
1089 index = qlcnic_get_lro_sts_refhandle(sts_data0);
1090 if (unlikely(index > rds_ring->num_desc))
1091 return NULL;
1092
1093 buffer = &rds_ring->rx_buf_arr[index];
1094
1095 timestamp = qlcnic_get_lro_sts_timestamp(sts_data0);
1096 lro_length = qlcnic_get_lro_sts_length(sts_data0);
1097 l2_hdr_offset = qlcnic_get_lro_sts_l2_hdr_offset(sts_data0);
1098 l4_hdr_offset = qlcnic_get_lro_sts_l4_hdr_offset(sts_data0);
1099 push = qlcnic_get_lro_sts_push_flag(sts_data0);
1100 seq_number = qlcnic_get_lro_sts_seq_number(sts_data1);
1101
1102 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
1103 if (!skb)
1104 return buffer;
1105
53643a75
SS		 1106 if (adapter->drv_mac_learn &&
1107 (adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
1108 t_vid = 0;
1109 is_lb_pkt = qlcnic_82xx_is_lb_pkt(sts_data0);
1110 qlcnic_add_lb_filter(adapter, skb, is_lb_pkt,
1111 cpu_to_le16(t_vid));
1112 }
1113
c70001a9
SC		 1114 if (timestamp)
1115 data_offset = l4_hdr_offset + QLC_TCP_TS_HDR_SIZE;
1116 else
1117 data_offset = l4_hdr_offset + QLC_TCP_HDR_SIZE;
1118
1119 skb_put(skb, lro_length + data_offset);
c70001a9
SC		 1120 skb_pull(skb, l2_hdr_offset);
1121
1122 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1123 adapter->stats.rxdropped++;
1124 dev_kfree_skb(skb);
1125 return buffer;
1126 }
1127
1128 skb->protocol = eth_type_trans(skb, netdev);
776e7bde 1129
069048f1 1130 if (ntohs(skb->protocol) == ETH_P_IPV6) {
776e7bde
SS		 1131 ipv6h = (struct ipv6hdr *)skb->data;
1132 th = (struct tcphdr *)(skb->data + sizeof(struct ipv6hdr));
1133 length = (th->doff << 2) + lro_length;
1134 ipv6h->payload_len = htons(length);
1135 } else {
1136 iph = (struct iphdr *)skb->data;
1137 th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
1138 length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
1bcac3b0 1139 csum_replace2(&iph->check, iph->tot_len, htons(length));
776e7bde 1140 iph->tot_len = htons(length);
776e7bde
SS		 1141 }
1142
c70001a9
SC		 1143 th->psh = push;
1144 th->seq = htonl(seq_number);
c70001a9
SC		 1145 length = skb->len;
1146
bd69ba79 1147 if (adapter->flags & QLCNIC_FW_LRO_MSS_CAP) {
c70001a9 1148 skb_shinfo(skb)->gso_size = qlcnic_get_lro_sts_mss(sts_data1);
bd69ba79
MT		 1149 if (skb->protocol == htons(ETH_P_IPV6))
1150 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
1151 else
1152 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
1153 }
c70001a9
SC		 1154
1155 if (vid != 0xffff)
86a9bad3 1156 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
c70001a9
SC		 1157 netif_receive_skb(skb);
1158
1159 adapter->stats.lro_pkts++;
1160 adapter->stats.lrobytes += length;
1161
1162 return buffer;
1163}
1164
d17dd0d9 1165int qlcnic_process_rcv_ring(struct qlcnic_host_sds_ring *sds_ring, int max)
c70001a9 1166{
d17dd0d9 1167 struct qlcnic_host_rds_ring *rds_ring;
c70001a9
SC		 1168 struct qlcnic_adapter *adapter = sds_ring->adapter;
1169 struct list_head *cur;
1170 struct status_desc *desc;
1171 struct qlcnic_rx_buffer *rxbuf;
4be41e92 1172 int opcode, desc_cnt, count = 0;
c70001a9 1173 u64 sts_data0, sts_data1;
4be41e92 1174 u8 ring;
c70001a9
SC		 1175 u32 consumer = sds_ring->consumer;
1176
1177 while (count < max) {
1178 desc = &sds_ring->desc_head[consumer];
1179 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1180
1181 if (!(sts_data0 & STATUS_OWNER_HOST))
1182 break;
1183
1184 desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1185 opcode = qlcnic_get_sts_opcode(sts_data0);
c70001a9
SC		 1186 switch (opcode) {
1187 case QLCNIC_RXPKT_DESC:
1188 case QLCNIC_OLD_RXPKT_DESC:
1189 case QLCNIC_SYN_OFFLOAD:
1190 ring = qlcnic_get_sts_type(sts_data0);
d17dd0d9
SC		 1191 rxbuf = qlcnic_process_rcv(adapter, sds_ring, ring,
1192 sts_data0);
c70001a9
SC		 1193 break;
1194 case QLCNIC_LRO_DESC:
1195 ring = qlcnic_get_lro_sts_type(sts_data0);
1196 sts_data1 = le64_to_cpu(desc->status_desc_data[1]);
1197 rxbuf = qlcnic_process_lro(adapter, ring, sts_data0,
1198 sts_data1);
1199 break;
1200 case QLCNIC_RESPONSE_DESC:
1201 qlcnic_handle_fw_message(desc_cnt, consumer, sds_ring);
1202 default:
1203 goto skip;
1204 }
c70001a9
SC		 1205 WARN_ON(desc_cnt > 1);
1206
1207 if (likely(rxbuf))
1208 list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
1209 else
1210 adapter->stats.null_rxbuf++;
c70001a9
SC		 1211skip:
1212 for (; desc_cnt > 0; desc_cnt--) {
1213 desc = &sds_ring->desc_head[consumer];
4be41e92 1214 desc->status_desc_data[0] = QLCNIC_DESC_OWNER_FW;
c70001a9
SC		 1215 consumer = get_next_index(consumer, sds_ring->num_desc);
1216 }
1217 count++;
1218 }
1219
1220 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
d17dd0d9 1221 rds_ring = &adapter->recv_ctx->rds_rings[ring];
c70001a9
SC		 1222 if (!list_empty(&sds_ring->free_list[ring])) {
1223 list_for_each(cur, &sds_ring->free_list[ring]) {
d17dd0d9
SC		 1224 rxbuf = list_entry(cur, struct qlcnic_rx_buffer,
1225 list);
c70001a9
SC		 1226 qlcnic_alloc_rx_skb(adapter, rds_ring, rxbuf);
1227 }
1228 spin_lock(&rds_ring->lock);
1229 list_splice_tail_init(&sds_ring->free_list[ring],
d17dd0d9 1230 &rds_ring->free_list);
c70001a9
SC		 1231 spin_unlock(&rds_ring->lock);
1232 }
1233
4be41e92 1234 qlcnic_post_rx_buffers_nodb(adapter, rds_ring, ring);
c70001a9
SC		 1235 }
1236
1237 if (count) {
1238 sds_ring->consumer = consumer;
1239 writel(consumer, sds_ring->crb_sts_consumer);
1240 }
1241
1242 return count;
1243}
1244
d17dd0d9 1245void qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter,
4be41e92 1246 struct qlcnic_host_rds_ring *rds_ring, u8 ring_id)
c70001a9
SC		 1247{
1248 struct rcv_desc *pdesc;
1249 struct qlcnic_rx_buffer *buffer;
1250 int count = 0;
4be41e92 1251 u32 producer, handle;
c70001a9
SC		 1252 struct list_head *head;
1253
1254 producer = rds_ring->producer;
c70001a9 1255 head = &rds_ring->free_list;
d17dd0d9 1256
c70001a9
SC		 1257 while (!list_empty(head)) {
1258
1259 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
1260
1261 if (!buffer->skb) {
1262 if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
1263 break;
1264 }
1265
1266 count++;
1267 list_del(&buffer->list);
1268
1269 /* make a rcv descriptor */
1270 pdesc = &rds_ring->desc_head[producer];
1271 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
4be41e92
SC		 1272 handle = qlcnic_get_ref_handle(adapter, buffer->ref_handle,
1273 ring_id);
1274 pdesc->reference_handle = cpu_to_le16(handle);
c70001a9 1275 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
c70001a9
SC		 1276 producer = get_next_index(producer, rds_ring->num_desc);
1277 }
1278
1279 if (count) {
1280 rds_ring->producer = producer;
1281 writel((producer-1) & (rds_ring->num_desc-1),
d17dd0d9 1282 rds_ring->crb_rcv_producer);
c70001a9
SC		 1283 }
1284}
1285
1286static void dump_skb(struct sk_buff *skb, struct qlcnic_adapter *adapter)
1287{
1288 int i;
1289 unsigned char *data = skb->data;
1290
d17dd0d9 1291 pr_info(KERN_INFO "\n");
c70001a9
SC		 1292 for (i = 0; i < skb->len; i++) {
1293 QLCDB(adapter, DRV, "%02x ", data[i]);
1294 if ((i & 0x0f) == 8)
d17dd0d9 1295 pr_info(KERN_INFO "\n");
c70001a9
SC		 1296 }
1297}
1298
1299static void qlcnic_process_rcv_diag(struct qlcnic_adapter *adapter, int ring,
1300 u64 sts_data0)
1301{
1302 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1303 struct sk_buff *skb;
1304 struct qlcnic_host_rds_ring *rds_ring;
1305 int index, length, cksum, pkt_offset;
1306
1307 if (unlikely(ring >= adapter->max_rds_rings))
1308 return;
1309
1310 rds_ring = &recv_ctx->rds_rings[ring];
1311
1312 index = qlcnic_get_sts_refhandle(sts_data0);
1313 length = qlcnic_get_sts_totallength(sts_data0);
1314 if (unlikely(index >= rds_ring->num_desc))
1315 return;
1316
1317 cksum = qlcnic_get_sts_status(sts_data0);
1318 pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
1319
1320 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1321 if (!skb)
1322 return;
1323
1324 if (length > rds_ring->skb_size)
1325 skb_put(skb, rds_ring->skb_size);
1326 else
1327 skb_put(skb, length);
1328
1329 if (pkt_offset)
1330 skb_pull(skb, pkt_offset);
1331
1332 if (!qlcnic_check_loopback_buff(skb->data, adapter->mac_addr))
79788450 1333 adapter->ahw->diag_cnt++;
c70001a9
SC		 1334 else
1335 dump_skb(skb, adapter);
1336
1337 dev_kfree_skb_any(skb);
1338 adapter->stats.rx_pkts++;
1339 adapter->stats.rxbytes += length;
1340
1341 return;
1342}
1343
7e2cf4fe 1344void qlcnic_82xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring *sds_ring)
c70001a9
SC		 1345{
1346 struct qlcnic_adapter *adapter = sds_ring->adapter;
1347 struct status_desc *desc;
1348 u64 sts_data0;
1349 int ring, opcode, desc_cnt;
1350
1351 u32 consumer = sds_ring->consumer;
1352
1353 desc = &sds_ring->desc_head[consumer];
1354 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1355
1356 if (!(sts_data0 & STATUS_OWNER_HOST))
1357 return;
1358
1359 desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1360 opcode = qlcnic_get_sts_opcode(sts_data0);
1361 switch (opcode) {
1362 case QLCNIC_RESPONSE_DESC:
1363 qlcnic_handle_fw_message(desc_cnt, consumer, sds_ring);
1364 break;
1365 default:
1366 ring = qlcnic_get_sts_type(sts_data0);
1367 qlcnic_process_rcv_diag(adapter, ring, sts_data0);
1368 break;
1369 }
1370
1371 for (; desc_cnt > 0; desc_cnt--) {
1372 desc = &sds_ring->desc_head[consumer];
1373 desc->status_desc_data[0] = cpu_to_le64(STATUS_OWNER_PHANTOM);
1374 consumer = get_next_index(consumer, sds_ring->num_desc);
1375 }
1376
1377 sds_ring->consumer = consumer;
1378 writel(consumer, sds_ring->crb_sts_consumer);
1379}
1380
7e2cf4fe
SC		 1381int qlcnic_82xx_napi_add(struct qlcnic_adapter *adapter,
1382 struct net_device *netdev)
c70001a9 1383{
d17dd0d9 1384 int ring, max_sds_rings;
c70001a9
SC		 1385 struct qlcnic_host_sds_ring *sds_ring;
1386 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1387
1388 if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
1389 return -ENOMEM;
1390
d17dd0d9
SC		 1391 max_sds_rings = adapter->max_sds_rings;
1392
c70001a9
SC		 1393 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1394 sds_ring = &recv_ctx->sds_rings[ring];
4be41e92 1395 if (ring == adapter->max_sds_rings - 1)
c70001a9 1396 netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
d17dd0d9 1397 QLCNIC_NETDEV_WEIGHT / max_sds_rings);
c70001a9 1398 else
d17dd0d9
SC		 1399 netif_napi_add(netdev, &sds_ring->napi, qlcnic_rx_poll,
1400 QLCNIC_NETDEV_WEIGHT*2);
c70001a9
SC		 1401 }
1402
4be41e92
SC		 1403 if (qlcnic_alloc_tx_rings(adapter, netdev)) {
1404 qlcnic_free_sds_rings(recv_ctx);
1405 return -ENOMEM;
1406 }
1407
c70001a9
SC		 1408 return 0;
1409}
1410
4be41e92 1411void qlcnic_82xx_napi_del(struct qlcnic_adapter *adapter)
c70001a9
SC		 1412{
1413 int ring;
1414 struct qlcnic_host_sds_ring *sds_ring;
1415 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1416
1417 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1418 sds_ring = &recv_ctx->sds_rings[ring];
1419 netif_napi_del(&sds_ring->napi);
1420 }
1421
1422 qlcnic_free_sds_rings(adapter->recv_ctx);
4be41e92 1423 qlcnic_free_tx_rings(adapter);
c70001a9
SC		 1424}
1425
7e2cf4fe 1426void qlcnic_82xx_napi_enable(struct qlcnic_adapter *adapter)
c70001a9
SC		 1427{
1428 int ring;
1429 struct qlcnic_host_sds_ring *sds_ring;
1430 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1431
1432 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1433 return;
1434
1435 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1436 sds_ring = &recv_ctx->sds_rings[ring];
1437 napi_enable(&sds_ring->napi);
1438 qlcnic_enable_int(sds_ring);
1439 }
1440}
1441
7e2cf4fe 1442void qlcnic_82xx_napi_disable(struct qlcnic_adapter *adapter)
c70001a9
SC		 1443{
1444 int ring;
1445 struct qlcnic_host_sds_ring *sds_ring;
1446 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1447
1448 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1449 return;
1450
1451 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1452 sds_ring = &recv_ctx->sds_rings[ring];
1453 qlcnic_disable_int(sds_ring);
1454 napi_synchronize(&sds_ring->napi);
1455 napi_disable(&sds_ring->napi);
1456 }
1457}
4be41e92 1458
53643a75
SS		 1459#define QLC_83XX_NORMAL_LB_PKT (1ULL << 36)
1460#define QLC_83XX_LRO_LB_PKT (1ULL << 46)
1461
1462static inline int qlcnic_83xx_is_lb_pkt(u64 sts_data, int lro_pkt)
1463{
1464 if (lro_pkt)
1465 return (sts_data & QLC_83XX_LRO_LB_PKT) ? 1 : 0;
1466 else
1467 return (sts_data & QLC_83XX_NORMAL_LB_PKT) ? 1 : 0;
1468}
1469
4be41e92
SC		 1470static struct qlcnic_rx_buffer *
1471qlcnic_83xx_process_rcv(struct qlcnic_adapter *adapter,
1472 struct qlcnic_host_sds_ring *sds_ring,
1473 u8 ring, u64 sts_data[])
1474{
1475 struct net_device *netdev = adapter->netdev;
1476 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1477 struct qlcnic_rx_buffer *buffer;
1478 struct sk_buff *skb;
1479 struct qlcnic_host_rds_ring *rds_ring;
53643a75
SS		 1480 int index, length, cksum, is_lb_pkt;
1481 u16 vid = 0xffff, t_vid;
4be41e92
SC		 1482
1483 if (unlikely(ring >= adapter->max_rds_rings))
1484 return NULL;
1485
1486 rds_ring = &recv_ctx->rds_rings[ring];
1487
1488 index = qlcnic_83xx_hndl(sts_data[0]);
1489 if (unlikely(index >= rds_ring->num_desc))
1490 return NULL;
1491
1492 buffer = &rds_ring->rx_buf_arr[index];
1493 length = qlcnic_83xx_pktln(sts_data[0]);
1494 cksum = qlcnic_83xx_csum_status(sts_data[1]);
1495 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1496 if (!skb)
1497 return buffer;
1498
53643a75
SS		 1499 if (adapter->drv_mac_learn &&
1500 (adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
1501 t_vid = 0;
1502 is_lb_pkt = qlcnic_83xx_is_lb_pkt(sts_data[1], 0);
1503 qlcnic_add_lb_filter(adapter, skb, is_lb_pkt,
1504 cpu_to_le16(t_vid));
1505 }
1506
4be41e92
SC		 1507 if (length > rds_ring->skb_size)
1508 skb_put(skb, rds_ring->skb_size);
1509 else
1510 skb_put(skb, length);
1511
1512 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1513 adapter->stats.rxdropped++;
1514 dev_kfree_skb(skb);
1515 return buffer;
1516 }
1517
1518 skb->protocol = eth_type_trans(skb, netdev);
1519
1520 if (vid != 0xffff)
86a9bad3 1521 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
4be41e92
SC		 1522
1523 napi_gro_receive(&sds_ring->napi, skb);
1524
1525 adapter->stats.rx_pkts++;
1526 adapter->stats.rxbytes += length;
1527
1528 return buffer;
1529}
1530
1531static struct qlcnic_rx_buffer *
1532qlcnic_83xx_process_lro(struct qlcnic_adapter *adapter,
1533 u8 ring, u64 sts_data[])
1534{
1535 struct net_device *netdev = adapter->netdev;
1536 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1537 struct qlcnic_rx_buffer *buffer;
1538 struct sk_buff *skb;
1539 struct qlcnic_host_rds_ring *rds_ring;
1540 struct iphdr *iph;
1541 struct ipv6hdr *ipv6h;
1542 struct tcphdr *th;
1543 bool push;
1544 int l2_hdr_offset, l4_hdr_offset;
53643a75 1545 int index, is_lb_pkt;
99e85879 1546 u16 lro_length, length, data_offset, gso_size;
53643a75 1547 u16 vid = 0xffff, t_vid;
4be41e92
SC		 1548
1549 if (unlikely(ring > adapter->max_rds_rings))
1550 return NULL;
1551
1552 rds_ring = &recv_ctx->rds_rings[ring];
1553
1554 index = qlcnic_83xx_hndl(sts_data[0]);
1555 if (unlikely(index > rds_ring->num_desc))
1556 return NULL;
1557
1558 buffer = &rds_ring->rx_buf_arr[index];
1559
1560 lro_length = qlcnic_83xx_lro_pktln(sts_data[0]);
1561 l2_hdr_offset = qlcnic_83xx_l2_hdr_off(sts_data[1]);
1562 l4_hdr_offset = qlcnic_83xx_l4_hdr_off(sts_data[1]);
1563 push = qlcnic_83xx_is_psh_bit(sts_data[1]);
1564
1565 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
1566 if (!skb)
1567 return buffer;
53643a75
SS		 1568
1569 if (adapter->drv_mac_learn &&
1570 (adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
1571 t_vid = 0;
1572 is_lb_pkt = qlcnic_83xx_is_lb_pkt(sts_data[1], 1);
1573 qlcnic_add_lb_filter(adapter, skb, is_lb_pkt,
1574 cpu_to_le16(t_vid));
1575 }
4be41e92
SC		 1576 if (qlcnic_83xx_is_tstamp(sts_data[1]))
1577 data_offset = l4_hdr_offset + QLCNIC_TCP_TS_HDR_SIZE;
1578 else
1579 data_offset = l4_hdr_offset + QLCNIC_TCP_HDR_SIZE;
1580
1581 skb_put(skb, lro_length + data_offset);
1582 skb_pull(skb, l2_hdr_offset);
1583
1584 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1585 adapter->stats.rxdropped++;
1586 dev_kfree_skb(skb);
1587 return buffer;
1588 }
1589
1590 skb->protocol = eth_type_trans(skb, netdev);
1591 if (ntohs(skb->protocol) == ETH_P_IPV6) {
1592 ipv6h = (struct ipv6hdr *)skb->data;
1593 th = (struct tcphdr *)(skb->data + sizeof(struct ipv6hdr));
1594
1595 length = (th->doff << 2) + lro_length;
1596 ipv6h->payload_len = htons(length);
1597 } else {
1598 iph = (struct iphdr *)skb->data;
1599 th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
1600 length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
1bcac3b0 1601 csum_replace2(&iph->check, iph->tot_len, htons(length));
4be41e92 1602 iph->tot_len = htons(length);
4be41e92
SC		 1603 }
1604
1605 th->psh = push;
1606 length = skb->len;
1607
99e85879
SS		 1608 if (adapter->flags & QLCNIC_FW_LRO_MSS_CAP) {
1609 gso_size = qlcnic_83xx_get_lro_sts_mss(sts_data[0]);
1610 skb_shinfo(skb)->gso_size = gso_size;
1611 if (skb->protocol == htons(ETH_P_IPV6))
1612 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
1613 else
1614 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
1615 }
1616
4be41e92 1617 if (vid != 0xffff)
86a9bad3 1618 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
4be41e92
SC		 1619
1620 netif_receive_skb(skb);
1621
1622 adapter->stats.lro_pkts++;
1623 adapter->stats.lrobytes += length;
1624 return buffer;
1625}
1626
1627static int qlcnic_83xx_process_rcv_ring(struct qlcnic_host_sds_ring *sds_ring,
1628 int max)
1629{
1630 struct qlcnic_host_rds_ring *rds_ring;
1631 struct qlcnic_adapter *adapter = sds_ring->adapter;
1632 struct list_head *cur;
1633 struct status_desc *desc;
1634 struct qlcnic_rx_buffer *rxbuf = NULL;
1635 u8 ring;
1636 u64 sts_data[2];
1637 int count = 0, opcode;
1638 u32 consumer = sds_ring->consumer;
1639
1640 while (count < max) {
1641 desc = &sds_ring->desc_head[consumer];
1642 sts_data[1] = le64_to_cpu(desc->status_desc_data[1]);
1643 opcode = qlcnic_83xx_opcode(sts_data[1]);
1644 if (!opcode)
1645 break;
1646 sts_data[0] = le64_to_cpu(desc->status_desc_data[0]);
1647 ring = QLCNIC_FETCH_RING_ID(sts_data[0]);
1648
1649 switch (opcode) {
1650 case QLC_83XX_REG_DESC:
1651 rxbuf = qlcnic_83xx_process_rcv(adapter, sds_ring,
1652 ring, sts_data);
1653 break;
1654 case QLC_83XX_LRO_DESC:
1655 rxbuf = qlcnic_83xx_process_lro(adapter, ring,
1656 sts_data);
1657 break;
1658 default:
1659 dev_info(&adapter->pdev->dev,
1660 "Unkonwn opcode: 0x%x\n", opcode);
1661 goto skip;
1662 }
1663
1664 if (likely(rxbuf))
1665 list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
1666 else
1667 adapter->stats.null_rxbuf++;
1668skip:
1669 desc = &sds_ring->desc_head[consumer];
1670 /* Reset the descriptor */
1671 desc->status_desc_data[1] = 0;
1672 consumer = get_next_index(consumer, sds_ring->num_desc);
1673 count++;
1674 }
1675 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1676 rds_ring = &adapter->recv_ctx->rds_rings[ring];
1677 if (!list_empty(&sds_ring->free_list[ring])) {
1678 list_for_each(cur, &sds_ring->free_list[ring]) {
1679 rxbuf = list_entry(cur, struct qlcnic_rx_buffer,
1680 list);
1681 qlcnic_alloc_rx_skb(adapter, rds_ring, rxbuf);
1682 }
1683 spin_lock(&rds_ring->lock);
1684 list_splice_tail_init(&sds_ring->free_list[ring],
1685 &rds_ring->free_list);
1686 spin_unlock(&rds_ring->lock);
1687 }
1688 qlcnic_post_rx_buffers_nodb(adapter, rds_ring, ring);
1689 }
1690 if (count) {
1691 sds_ring->consumer = consumer;
1692 writel(consumer, sds_ring->crb_sts_consumer);
1693 }
1694 return count;
1695}
1696
da6c8063
RB		 1697static int qlcnic_83xx_msix_sriov_vf_poll(struct napi_struct *napi, int budget)
1698{
1699 int tx_complete;
1700 int work_done;
1701 struct qlcnic_host_sds_ring *sds_ring;
1702 struct qlcnic_adapter *adapter;
1703 struct qlcnic_host_tx_ring *tx_ring;
1704
1705 sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
1706 adapter = sds_ring->adapter;
1707 /* tx ring count = 1 */
1708 tx_ring = adapter->tx_ring;
1709
1710 tx_complete = qlcnic_process_cmd_ring(adapter, tx_ring, budget);
1711 work_done = qlcnic_83xx_process_rcv_ring(sds_ring, budget);
1712 if ((work_done < budget) && tx_complete) {
1713 napi_complete(&sds_ring->napi);
1714 qlcnic_83xx_enable_intr(adapter, sds_ring);
1715 }
1716
1717 return work_done;
1718}
1719
4be41e92
SC		 1720static int qlcnic_83xx_poll(struct napi_struct *napi, int budget)
1721{
1722 int tx_complete;
1723 int work_done;
1724 struct qlcnic_host_sds_ring *sds_ring;
1725 struct qlcnic_adapter *adapter;
1726 struct qlcnic_host_tx_ring *tx_ring;
1727
1728 sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
1729 adapter = sds_ring->adapter;
1730 /* tx ring count = 1 */
1731 tx_ring = adapter->tx_ring;
1732
4be41e92
SC		 1733 tx_complete = qlcnic_process_cmd_ring(adapter, tx_ring, budget);
1734 work_done = qlcnic_83xx_process_rcv_ring(sds_ring, budget);
1735 if ((work_done < budget) && tx_complete) {
1736 napi_complete(&sds_ring->napi);
ac166700 1737 qlcnic_83xx_enable_intr(adapter, sds_ring);
4be41e92
SC		 1738 }
1739
1740 return work_done;
1741}
1742
1743static int qlcnic_83xx_msix_tx_poll(struct napi_struct *napi, int budget)
1744{
1745 int work_done;
1746 struct qlcnic_host_tx_ring *tx_ring;
1747 struct qlcnic_adapter *adapter;
1748
1749 budget = QLCNIC_TX_POLL_BUDGET;
1750 tx_ring = container_of(napi, struct qlcnic_host_tx_ring, napi);
1751 adapter = tx_ring->adapter;
1752 work_done = qlcnic_process_cmd_ring(adapter, tx_ring, budget);
1753 if (work_done) {
1754 napi_complete(&tx_ring->napi);
1755 if (test_bit(__QLCNIC_DEV_UP , &adapter->state))
1756 qlcnic_83xx_enable_tx_intr(adapter, tx_ring);
1757 }
1758
1759 return work_done;
1760}
1761
1762static int qlcnic_83xx_rx_poll(struct napi_struct *napi, int budget)
1763{
1764 int work_done;
1765 struct qlcnic_host_sds_ring *sds_ring;
1766 struct qlcnic_adapter *adapter;
1767
1768 sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
1769 adapter = sds_ring->adapter;
1770 work_done = qlcnic_83xx_process_rcv_ring(sds_ring, budget);
1771 if (work_done < budget) {
1772 napi_complete(&sds_ring->napi);
1773 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1774 qlcnic_83xx_enable_intr(adapter, sds_ring);
1775 }
1776
1777 return work_done;
1778}
1779
1780void qlcnic_83xx_napi_enable(struct qlcnic_adapter *adapter)
1781{
1782 int ring;
1783 struct qlcnic_host_sds_ring *sds_ring;
1784 struct qlcnic_host_tx_ring *tx_ring;
1785 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1786
1787 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1788 return;
1789
1790 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1791 sds_ring = &recv_ctx->sds_rings[ring];
1792 napi_enable(&sds_ring->napi);
ac166700
HM		 1793 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1794 qlcnic_83xx_enable_intr(adapter, sds_ring);
4be41e92
SC		 1795 }
1796
da6c8063
RB		 1797 if ((adapter->flags & QLCNIC_MSIX_ENABLED) &&
1798 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
4be41e92
SC		 1799 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1800 tx_ring = &adapter->tx_ring[ring];
1801 napi_enable(&tx_ring->napi);
1802 qlcnic_83xx_enable_tx_intr(adapter, tx_ring);
1803 }
1804 }
1805}
1806
1807void qlcnic_83xx_napi_disable(struct qlcnic_adapter *adapter)
1808{
1809 int ring;
1810 struct qlcnic_host_sds_ring *sds_ring;
1811 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1812 struct qlcnic_host_tx_ring *tx_ring;
1813
1814 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1815 return;
1816
1817 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1818 sds_ring = &recv_ctx->sds_rings[ring];
ac166700
HM		 1819 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1820 qlcnic_83xx_disable_intr(adapter, sds_ring);
4be41e92
SC		 1821 napi_synchronize(&sds_ring->napi);
1822 napi_disable(&sds_ring->napi);
1823 }
1824
da6c8063
RB		 1825 if ((adapter->flags & QLCNIC_MSIX_ENABLED) &&
1826 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
4be41e92
SC		 1827 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1828 tx_ring = &adapter->tx_ring[ring];
1829 qlcnic_83xx_disable_tx_intr(adapter, tx_ring);
1830 napi_synchronize(&tx_ring->napi);
1831 napi_disable(&tx_ring->napi);
1832 }
1833 }
1834}
1835
1836int qlcnic_83xx_napi_add(struct qlcnic_adapter *adapter,
1837 struct net_device *netdev)
1838{
da6c8063 1839 int ring, max_sds_rings, temp;
4be41e92
SC		 1840 struct qlcnic_host_sds_ring *sds_ring;
1841 struct qlcnic_host_tx_ring *tx_ring;
1842 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1843
1844 if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
1845 return -ENOMEM;
1846
1847 max_sds_rings = adapter->max_sds_rings;
1848 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1849 sds_ring = &recv_ctx->sds_rings[ring];
da6c8063
RB		 1850 if (adapter->flags & QLCNIC_MSIX_ENABLED) {
1851 if (!(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
1852 netif_napi_add(netdev, &sds_ring->napi,
1853 qlcnic_83xx_rx_poll,
1854 QLCNIC_NETDEV_WEIGHT * 2);
1855 } else {
1856 temp = QLCNIC_NETDEV_WEIGHT / max_sds_rings;
1857 netif_napi_add(netdev, &sds_ring->napi,
1858 qlcnic_83xx_msix_sriov_vf_poll,
1859 temp);
1860 }
1861
1862 } else {
4be41e92
SC		 1863 netif_napi_add(netdev, &sds_ring->napi,
1864 qlcnic_83xx_poll,
1865 QLCNIC_NETDEV_WEIGHT / max_sds_rings);
da6c8063 1866 }
4be41e92
SC		 1867 }
1868
1869 if (qlcnic_alloc_tx_rings(adapter, netdev)) {
1870 qlcnic_free_sds_rings(recv_ctx);
1871 return -ENOMEM;
1872 }
1873
da6c8063
RB		 1874 if ((adapter->flags & QLCNIC_MSIX_ENABLED) &&
1875 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
4be41e92
SC		 1876 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1877 tx_ring = &adapter->tx_ring[ring];
1878 netif_napi_add(netdev, &tx_ring->napi,
1879 qlcnic_83xx_msix_tx_poll,
1880 QLCNIC_NETDEV_WEIGHT);
1881 }
1882 }
1883
1884 return 0;
1885}
1886
1887void qlcnic_83xx_napi_del(struct qlcnic_adapter *adapter)
1888{
1889 int ring;
1890 struct qlcnic_host_sds_ring *sds_ring;
1891 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1892 struct qlcnic_host_tx_ring *tx_ring;
1893
1894 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1895 sds_ring = &recv_ctx->sds_rings[ring];
1896 netif_napi_del(&sds_ring->napi);
1897 }
1898
1899 qlcnic_free_sds_rings(adapter->recv_ctx);
1900
da6c8063
RB		 1901 if ((adapter->flags & QLCNIC_MSIX_ENABLED) &&
1902 !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
4be41e92
SC		 1903 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1904 tx_ring = &adapter->tx_ring[ring];
1905 netif_napi_del(&tx_ring->napi);
1906 }
1907 }
1908
1909 qlcnic_free_tx_rings(adapter);
1910}
1911
1912void qlcnic_83xx_process_rcv_diag(struct qlcnic_adapter *adapter,
1913 int ring, u64 sts_data[])
1914{
1915 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1916 struct sk_buff *skb;
1917 struct qlcnic_host_rds_ring *rds_ring;
1918 int index, length;
1919
1920 if (unlikely(ring >= adapter->max_rds_rings))
1921 return;
1922
1923 rds_ring = &recv_ctx->rds_rings[ring];
1924 index = qlcnic_83xx_hndl(sts_data[0]);
1925 if (unlikely(index >= rds_ring->num_desc))
1926 return;
1927
1928 length = qlcnic_83xx_pktln(sts_data[0]);
1929
1930 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
1931 if (!skb)
1932 return;
1933
1934 if (length > rds_ring->skb_size)
1935 skb_put(skb, rds_ring->skb_size);
1936 else
1937 skb_put(skb, length);
1938
1939 if (!qlcnic_check_loopback_buff(skb->data, adapter->mac_addr))
1940 adapter->ahw->diag_cnt++;
1941 else
1942 dump_skb(skb, adapter);
1943
1944 dev_kfree_skb_any(skb);
1945 return;
1946}
1947
1948void qlcnic_83xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring *sds_ring)
1949{
1950 struct qlcnic_adapter *adapter = sds_ring->adapter;
1951 struct status_desc *desc;
1952 u64 sts_data[2];
1953 int ring, opcode;
1954 u32 consumer = sds_ring->consumer;
1955
1956 desc = &sds_ring->desc_head[consumer];
1957 sts_data[0] = le64_to_cpu(desc->status_desc_data[0]);
1958 sts_data[1] = le64_to_cpu(desc->status_desc_data[1]);
1959 opcode = qlcnic_83xx_opcode(sts_data[1]);
1960 if (!opcode)
1961 return;
1962
1963 ring = QLCNIC_FETCH_RING_ID(qlcnic_83xx_hndl(sts_data[0]));
1964 qlcnic_83xx_process_rcv_diag(adapter, ring, sts_data);
1965 desc = &sds_ring->desc_head[consumer];
1966 desc->status_desc_data[0] = cpu_to_le64(STATUS_OWNER_PHANTOM);
1967 consumer = get_next_index(consumer, sds_ring->num_desc);
1968 sds_ring->consumer = consumer;
1969 writel(consumer, sds_ring->crb_sts_consumer);
1970}
Ubuntu Jammy Linux kernel mirror