drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c

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