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 QLCNIC_MAC_HASH(MAC)\
   9         ((((MAC) & 0x70000) >> 0x10) | (((MAC) & 0x70000000000ULL) >> 0x25))
  10
  11 #define TX_ETHER_PKT    0x01
  12 #define TX_TCP_PKT      0x02
  13 #define TX_UDP_PKT      0x03
  14 #define TX_IP_PKT       0x04
  15 #define TX_TCP_LSO      0x05
  16 #define TX_TCP_LSO6     0x06
  17 #define TX_TCPV6_PKT    0x0b
  18 #define TX_UDPV6_PKT    0x0c
  19 #define FLAGS_VLAN_TAGGED       0x10
  20 #define FLAGS_VLAN_OOB          0x40
  21
  22 #define qlcnic_set_tx_vlan_tci(cmd_desc, v)     \
  23         (cmd_desc)->vlan_TCI = cpu_to_le16(v);
  24 #define qlcnic_set_cmd_desc_port(cmd_desc, var) \
  25         ((cmd_desc)->port_ctxid |= ((var) & 0x0F))
  26 #define qlcnic_set_cmd_desc_ctxid(cmd_desc, var)        \
  27         ((cmd_desc)->port_ctxid |= ((var) << 4 & 0xF0))
  28
  29 #define qlcnic_set_tx_port(_desc, _port) \
  30         ((_desc)->port_ctxid = ((_port) & 0xf) | (((_port) << 4) & 0xf0))
  31
  32 #define qlcnic_set_tx_flags_opcode(_desc, _flags, _opcode) \
  33         ((_desc)->flags_opcode |= \
  34         cpu_to_le16(((_flags) & 0x7f) | (((_opcode) & 0x3f) << 7)))
  35
  36 #define qlcnic_set_tx_frags_len(_desc, _frags, _len) \
  37         ((_desc)->nfrags__length = \
  38         cpu_to_le32(((_frags) & 0xff) | (((_len) & 0xffffff) << 8)))
  39
  40 /* owner bits of status_desc */
  41 #define STATUS_OWNER_HOST       (0x1ULL << 56)
  42 #define STATUS_OWNER_PHANTOM    (0x2ULL << 56)
  43
  44 /* Status descriptor:
  45    0-3 port, 4-7 status, 8-11 type, 12-27 total_length
  46    28-43 reference_handle, 44-47 protocol, 48-52 pkt_offset
  47    53-55 desc_cnt, 56-57 owner, 58-63 opcode
  48  */
  49 #define qlcnic_get_sts_port(sts_data)   \
  50         ((sts_data) & 0x0F)
  51 #define qlcnic_get_sts_status(sts_data) \
  52         (((sts_data) >> 4) & 0x0F)
  53 #define qlcnic_get_sts_type(sts_data)   \
  54         (((sts_data) >> 8) & 0x0F)
  55 #define qlcnic_get_sts_totallength(sts_data)    \
  56         (((sts_data) >> 12) & 0xFFFF)
  57 #define qlcnic_get_sts_refhandle(sts_data)      \
  58         (((sts_data) >> 28) & 0xFFFF)
  59 #define qlcnic_get_sts_prot(sts_data)   \
  60         (((sts_data) >> 44) & 0x0F)
  61 #define qlcnic_get_sts_pkt_offset(sts_data)     \
  62         (((sts_data) >> 48) & 0x1F)
  63 #define qlcnic_get_sts_desc_cnt(sts_data)       \
  64         (((sts_data) >> 53) & 0x7)
  65 #define qlcnic_get_sts_opcode(sts_data) \
  66         (((sts_data) >> 58) & 0x03F)
  67
  68 #define qlcnic_get_lro_sts_refhandle(sts_data)  \
  69         ((sts_data) & 0x07FFF)
  70 #define qlcnic_get_lro_sts_length(sts_data)     \
  71         (((sts_data) >> 16) & 0x0FFFF)
  72 #define qlcnic_get_lro_sts_l2_hdr_offset(sts_data)      \
  73         (((sts_data) >> 32) & 0x0FF)
  74 #define qlcnic_get_lro_sts_l4_hdr_offset(sts_data)      \
  75         (((sts_data) >> 40) & 0x0FF)
  76 #define qlcnic_get_lro_sts_timestamp(sts_data)  \
  77         (((sts_data) >> 48) & 0x1)
  78 #define qlcnic_get_lro_sts_type(sts_data)       \
  79         (((sts_data) >> 49) & 0x7)
  80 #define qlcnic_get_lro_sts_push_flag(sts_data)          \
  81         (((sts_data) >> 52) & 0x1)
  82 #define qlcnic_get_lro_sts_seq_number(sts_data)         \
  83         ((sts_data) & 0x0FFFFFFFF)
  84 #define qlcnic_get_lro_sts_mss(sts_data1)               \
  85         ((sts_data1 >> 32) & 0x0FFFF)
  86
  87 /* opcode field in status_desc */
  88 #define QLCNIC_SYN_OFFLOAD      0x03
  89 #define QLCNIC_RXPKT_DESC       0x04
  90 #define QLCNIC_OLD_RXPKT_DESC   0x3f
  91 #define QLCNIC_RESPONSE_DESC    0x05
  92 #define QLCNIC_LRO_DESC         0x12
  93
  94 /* for status field in status_desc */
  95 #define STATUS_CKSUM_LOOP       0
  96 #define STATUS_CKSUM_OK         2
  97
  98 void qlcnic_82xx_change_filter(struct qlcnic_adapter *adapter, u64 *uaddr,
  99                                __le16 vlan_id)
 100 {
 101         struct cmd_desc_type0 *hwdesc;
 102         struct qlcnic_nic_req *req;
 103         struct qlcnic_mac_req *mac_req;
 104         struct qlcnic_vlan_req *vlan_req;
 105         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
 106         u32 producer;
 107         u64 word;
 108
 109         producer = tx_ring->producer;
 110         hwdesc = &tx_ring->desc_head[tx_ring->producer];
 111
 112         req = (struct qlcnic_nic_req *)hwdesc;
 113         memset(req, 0, sizeof(struct qlcnic_nic_req));
 114         req->qhdr = cpu_to_le64(QLCNIC_REQUEST << 23);
 115
 116         word = QLCNIC_MAC_EVENT | ((u64)(adapter->portnum) << 16);
 117         req->req_hdr = cpu_to_le64(word);
 118
 119         mac_req = (struct qlcnic_mac_req *)&(req->words[0]);
 120         mac_req->op = vlan_id ? QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_ADD;
 121         memcpy(mac_req->mac_addr, &uaddr, ETH_ALEN);
 122
 123         vlan_req = (struct qlcnic_vlan_req *)&req->words[1];
 124         vlan_req->vlan_id = vlan_id;
 125
 126         tx_ring->producer = get_next_index(producer, tx_ring->num_desc);
 127         smp_mb();
 128 }
 129
 130 static void qlcnic_send_filter(struct qlcnic_adapter *adapter,
 131                                struct qlcnic_host_tx_ring *tx_ring,
 132                                struct cmd_desc_type0 *first_desc,
 133                                struct sk_buff *skb)
 134 {
 135         struct qlcnic_filter *fil, *tmp_fil;
 136         struct hlist_node *tmp_hnode, *n;
 137         struct hlist_head *head;
 138         struct ethhdr *phdr = (struct ethhdr *)(skb->data);
 139         u64 src_addr = 0;
 140         __le16 vlan_id = 0;
 141         u8 hindex;
 142
 143         if (!compare_ether_addr(phdr->h_source, adapter->mac_addr))
 144                 return;
 145
 146         if (adapter->fhash.fnum >= adapter->fhash.fmax)
 147                 return;
 148
 149         /* Only NPAR capable devices support vlan based learning */
 150         if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
 151                 vlan_id = first_desc->vlan_TCI;
 152         memcpy(&src_addr, phdr->h_source, ETH_ALEN);
 153         hindex = QLCNIC_MAC_HASH(src_addr) & (QLCNIC_LB_MAX_FILTERS - 1);
 154         head = &(adapter->fhash.fhead[hindex]);
 155
 156         hlist_for_each_entry_safe(tmp_fil, tmp_hnode, n, head, fnode) {
 157                 if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
 158                     tmp_fil->vlan_id == vlan_id) {
 159                         if (jiffies > (QLCNIC_READD_AGE * HZ + tmp_fil->ftime))
 160                                 qlcnic_change_filter(adapter, &src_addr,
 161                                                      vlan_id);
 162                         tmp_fil->ftime = jiffies;
 163                         return;
 164                 }
 165         }
 166
 167         fil = kzalloc(sizeof(struct qlcnic_filter), GFP_ATOMIC);
 168         if (!fil)
 169                 return;
 170
 171         qlcnic_change_filter(adapter, &src_addr, vlan_id);
 172         fil->ftime = jiffies;
 173         fil->vlan_id = vlan_id;
 174         memcpy(fil->faddr, &src_addr, ETH_ALEN);
 175         spin_lock(&adapter->mac_learn_lock);
 176         hlist_add_head(&(fil->fnode), head);
 177         adapter->fhash.fnum++;
 178         spin_unlock(&adapter->mac_learn_lock);
 179 }
 180
 181 static int qlcnic_tx_pkt(struct qlcnic_adapter *adapter,
 182                          struct cmd_desc_type0 *first_desc, struct sk_buff *skb)
 183 {
 184         u8 l4proto, opcode = 0, hdr_len = 0;
 185         u16 flags = 0, vlan_tci = 0;
 186         int copied, offset, copy_len, size;
 187         struct cmd_desc_type0 *hwdesc;
 188         struct vlan_ethhdr *vh;
 189         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
 190         u16 protocol = ntohs(skb->protocol);
 191         u32 producer = tx_ring->producer;
 192
 193         if (protocol == ETH_P_8021Q) {
 194                 vh = (struct vlan_ethhdr *)skb->data;
 195                 flags = FLAGS_VLAN_TAGGED;
 196                 vlan_tci = ntohs(vh->h_vlan_TCI);
 197                 protocol = ntohs(vh->h_vlan_encapsulated_proto);
 198         } else if (vlan_tx_tag_present(skb)) {
 199                 flags = FLAGS_VLAN_OOB;
 200                 vlan_tci = vlan_tx_tag_get(skb);
 201         }
 202         if (unlikely(adapter->pvid)) {
 203                 if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
 204                         return -EIO;
 205                 if (vlan_tci && (adapter->flags & QLCNIC_TAGGING_ENABLED))
 206                         goto set_flags;
 207
 208                 flags = FLAGS_VLAN_OOB;
 209                 vlan_tci = adapter->pvid;
 210         }
 211 set_flags:
 212         qlcnic_set_tx_vlan_tci(first_desc, vlan_tci);
 213         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
 214
 215         if (*(skb->data) & BIT_0) {
 216                 flags |= BIT_0;
 217                 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
 218         }
 219         opcode = TX_ETHER_PKT;
 220         if ((adapter->netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
 221             skb_shinfo(skb)->gso_size > 0) {
 222                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
 223                 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
 224                 first_desc->total_hdr_length = hdr_len;
 225                 opcode = (protocol == ETH_P_IPV6) ? TX_TCP_LSO6 : TX_TCP_LSO;
 226
 227                 /* For LSO, we need to copy the MAC/IP/TCP headers into
 228                 * the descriptor ring */
 229                 copied = 0;
 230                 offset = 2;
 231
 232                 if (flags & FLAGS_VLAN_OOB) {
 233                         first_desc->total_hdr_length += VLAN_HLEN;
 234                         first_desc->tcp_hdr_offset = VLAN_HLEN;
 235                         first_desc->ip_hdr_offset = VLAN_HLEN;
 236
 237                         /* Only in case of TSO on vlan device */
 238                         flags |= FLAGS_VLAN_TAGGED;
 239
 240                         /* Create a TSO vlan header template for firmware */
 241                         hwdesc = &tx_ring->desc_head[producer];
 242                         tx_ring->cmd_buf_arr[producer].skb = NULL;
 243
 244                         copy_len = min((int)sizeof(struct cmd_desc_type0) -
 245                                        offset, hdr_len + VLAN_HLEN);
 246
 247                         vh = (struct vlan_ethhdr *)((char *) hwdesc + 2);
 248                         skb_copy_from_linear_data(skb, vh, 12);
 249                         vh->h_vlan_proto = htons(ETH_P_8021Q);
 250                         vh->h_vlan_TCI = htons(vlan_tci);
 251
 252                         skb_copy_from_linear_data_offset(skb, 12,
 253                                                          (char *)vh + 16,
 254                                                          copy_len - 16);
 255                         copied = copy_len - VLAN_HLEN;
 256                         offset = 0;
 257                         producer = get_next_index(producer, tx_ring->num_desc);
 258                 }
 259
 260                 while (copied < hdr_len) {
 261                         size = (int)sizeof(struct cmd_desc_type0) - offset;
 262                         copy_len = min(size, (hdr_len - copied));
 263                         hwdesc = &tx_ring->desc_head[producer];
 264                         tx_ring->cmd_buf_arr[producer].skb = NULL;
 265                         skb_copy_from_linear_data_offset(skb, copied,
 266                                                          (char *)hwdesc +
 267                                                          offset, copy_len);
 268                         copied += copy_len;
 269                         offset = 0;
 270                         producer = get_next_index(producer, tx_ring->num_desc);
 271                 }
 272
 273                 tx_ring->producer = producer;
 274                 smp_mb();
 275                 adapter->stats.lso_frames++;
 276
 277         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 278                 if (protocol == ETH_P_IP) {
 279                         l4proto = ip_hdr(skb)->protocol;
 280
 281                         if (l4proto == IPPROTO_TCP)
 282                                 opcode = TX_TCP_PKT;
 283                         else if (l4proto == IPPROTO_UDP)
 284                                 opcode = TX_UDP_PKT;
 285                 } else if (protocol == ETH_P_IPV6) {
 286                         l4proto = ipv6_hdr(skb)->nexthdr;
 287
 288                         if (l4proto == IPPROTO_TCP)
 289                                 opcode = TX_TCPV6_PKT;
 290                         else if (l4proto == IPPROTO_UDP)
 291                                 opcode = TX_UDPV6_PKT;
 292                 }
 293         }
 294         first_desc->tcp_hdr_offset += skb_transport_offset(skb);
 295         first_desc->ip_hdr_offset += skb_network_offset(skb);
 296         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
 297
 298         return 0;
 299 }
 300
 301 static int qlcnic_map_tx_skb(struct pci_dev *pdev, struct sk_buff *skb,
 302                              struct qlcnic_cmd_buffer *pbuf)
 303 {
 304         struct qlcnic_skb_frag *nf;
 305         struct skb_frag_struct *frag;
 306         int i, nr_frags;
 307         dma_addr_t map;
 308
 309         nr_frags = skb_shinfo(skb)->nr_frags;
 310         nf = &pbuf->frag_array[0];
 311
 312         map = pci_map_single(pdev, skb->data, skb_headlen(skb),
 313                              PCI_DMA_TODEVICE);
 314         if (pci_dma_mapping_error(pdev, map))
 315                 goto out_err;
 316
 317         nf->dma = map;
 318         nf->length = skb_headlen(skb);
 319
 320         for (i = 0; i < nr_frags; i++) {
 321                 frag = &skb_shinfo(skb)->frags[i];
 322                 nf = &pbuf->frag_array[i+1];
 323                 map = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
 324                                        DMA_TO_DEVICE);
 325                 if (dma_mapping_error(&pdev->dev, map))
 326                         goto unwind;
 327
 328                 nf->dma = map;
 329                 nf->length = skb_frag_size(frag);
 330         }
 331
 332         return 0;
 333
 334 unwind:
 335         while (--i >= 0) {
 336                 nf = &pbuf->frag_array[i+1];
 337                 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
 338         }
 339
 340         nf = &pbuf->frag_array[0];
 341         pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
 342
 343 out_err:
 344         return -ENOMEM;
 345 }
 346
 347 static void qlcnic_unmap_buffers(struct pci_dev *pdev, struct sk_buff *skb,
 348                                  struct qlcnic_cmd_buffer *pbuf)
 349 {
 350         struct qlcnic_skb_frag *nf = &pbuf->frag_array[0];
 351         int i, nr_frags = skb_shinfo(skb)->nr_frags;
 352
 353         for (i = 0; i < nr_frags; i++) {
 354                 nf = &pbuf->frag_array[i+1];
 355                 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
 356         }
 357
 358         nf = &pbuf->frag_array[0];
 359         pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
 360         pbuf->skb = NULL;
 361 }
 362
 363 static inline void qlcnic_clear_cmddesc(u64 *desc)
 364 {
 365         desc[0] = 0ULL;
 366         desc[2] = 0ULL;
 367         desc[7] = 0ULL;
 368 }
 369
 370 netdev_tx_t qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 371 {
 372         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 373         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
 374         struct qlcnic_cmd_buffer *pbuf;
 375         struct qlcnic_skb_frag *buffrag;
 376         struct cmd_desc_type0 *hwdesc, *first_desc;
 377         struct pci_dev *pdev;
 378         struct ethhdr *phdr;
 379         int i, k, frag_count, delta = 0;
 380         u32 producer, num_txd;
 381
 382         num_txd = tx_ring->num_desc;
 383
 384         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
 385                 netif_stop_queue(netdev);
 386                 return NETDEV_TX_BUSY;
 387         }
 388
 389         if (adapter->flags & QLCNIC_MACSPOOF) {
 390                 phdr = (struct ethhdr *)skb->data;
 391                 if (!ether_addr_equal(phdr->h_source, adapter->mac_addr))
 392                         goto drop_packet;
 393         }
 394
 395         frag_count = skb_shinfo(skb)->nr_frags + 1;
 396         /* 14 frags supported for normal packet and
 397          * 32 frags supported for TSO packet
 398          */
 399         if (!skb_is_gso(skb) && frag_count > QLCNIC_MAX_FRAGS_PER_TX) {
 400                 for (i = 0; i < (frag_count - QLCNIC_MAX_FRAGS_PER_TX); i++)
 401                         delta += skb_frag_size(&skb_shinfo(skb)->frags[i]);
 402
 403                 if (!__pskb_pull_tail(skb, delta))
 404                         goto drop_packet;
 405
 406                 frag_count = 1 + skb_shinfo(skb)->nr_frags;
 407         }
 408
 409         if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
 410                 netif_stop_queue(netdev);
 411                 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
 412                         netif_start_queue(netdev);
 413                 } else {
 414                         adapter->stats.xmit_off++;
 415                         return NETDEV_TX_BUSY;
 416                 }
 417         }
 418
 419         producer = tx_ring->producer;
 420         pbuf = &tx_ring->cmd_buf_arr[producer];
 421         pdev = adapter->pdev;
 422         first_desc = &tx_ring->desc_head[producer];
 423         hwdesc = &tx_ring->desc_head[producer];
 424         qlcnic_clear_cmddesc((u64 *)hwdesc);
 425
 426         if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
 427                 adapter->stats.tx_dma_map_error++;
 428                 goto drop_packet;
 429         }
 430
 431         pbuf->skb = skb;
 432         pbuf->frag_count = frag_count;
 433
 434         qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
 435         qlcnic_set_tx_port(first_desc, adapter->portnum);
 436
 437         for (i = 0; i < frag_count; i++) {
 438                 k = i % 4;
 439
 440                 if ((k == 0) && (i > 0)) {
 441                         /* move to next desc.*/
 442                         producer = get_next_index(producer, num_txd);
 443                         hwdesc = &tx_ring->desc_head[producer];
 444                         qlcnic_clear_cmddesc((u64 *)hwdesc);
 445                         tx_ring->cmd_buf_arr[producer].skb = NULL;
 446                 }
 447
 448                 buffrag = &pbuf->frag_array[i];
 449                 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
 450                 switch (k) {
 451                 case 0:
 452                         hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
 453                         break;
 454                 case 1:
 455                         hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
 456                         break;
 457                 case 2:
 458                         hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
 459                         break;
 460                 case 3:
 461                         hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
 462                         break;
 463                 }
 464         }
 465
 466         tx_ring->producer = get_next_index(producer, num_txd);
 467         smp_mb();
 468
 469         if (unlikely(qlcnic_tx_pkt(adapter, first_desc, skb)))
 470                 goto unwind_buff;
 471
 472         if (adapter->mac_learn)
 473                 qlcnic_send_filter(adapter, tx_ring, first_desc, skb);
 474
 475         adapter->stats.txbytes += skb->len;
 476         adapter->stats.xmitcalled++;
 477
 478         qlcnic_update_cmd_producer(tx_ring);
 479
 480         return NETDEV_TX_OK;
 481
 482 unwind_buff:
 483         qlcnic_unmap_buffers(pdev, skb, pbuf);
 484 drop_packet:
 485         adapter->stats.txdropped++;
 486         dev_kfree_skb_any(skb);
 487         return NETDEV_TX_OK;
 488 }
 489
 490 void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
 491 {
 492         struct net_device *netdev = adapter->netdev;
 493
 494         if (adapter->ahw->linkup && !linkup) {
 495                 netdev_info(netdev, "NIC Link is down\n");
 496                 adapter->ahw->linkup = 0;
 497                 if (netif_running(netdev)) {
 498                         netif_carrier_off(netdev);
 499                         netif_stop_queue(netdev);
 500                 }
 501         } else if (!adapter->ahw->linkup && linkup) {
 502                 netdev_info(netdev, "NIC Link is up\n");
 503                 adapter->ahw->linkup = 1;
 504                 if (netif_running(netdev)) {
 505                         netif_carrier_on(netdev);
 506                         netif_wake_queue(netdev);
 507                 }
 508         }
 509 }
 510
 511 static int qlcnic_alloc_rx_skb(struct qlcnic_adapter *adapter,
 512                                struct qlcnic_host_rds_ring *rds_ring,
 513                                struct qlcnic_rx_buffer *buffer)
 514 {
 515         struct sk_buff *skb;
 516         dma_addr_t dma;
 517         struct pci_dev *pdev = adapter->pdev;
 518
 519         skb = netdev_alloc_skb(adapter->netdev, rds_ring->skb_size);
 520         if (!skb) {
 521                 adapter->stats.skb_alloc_failure++;
 522                 return -ENOMEM;
 523         }
 524
 525         skb_reserve(skb, NET_IP_ALIGN);
 526         dma = pci_map_single(pdev, skb->data, rds_ring->dma_size,
 527                              PCI_DMA_FROMDEVICE);
 528
 529         if (pci_dma_mapping_error(pdev, dma)) {
 530                 adapter->stats.rx_dma_map_error++;
 531                 dev_kfree_skb_any(skb);
 532                 return -ENOMEM;
 533         }
 534
 535         buffer->skb = skb;
 536         buffer->dma = dma;
 537
 538         return 0;
 539 }
 540
 541 static void qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter *adapter,
 542                                          struct qlcnic_host_rds_ring *rds_ring)
 543 {
 544         struct rcv_desc *pdesc;
 545         struct qlcnic_rx_buffer *buffer;
 546         int  count = 0;
 547         uint32_t producer;
 548         struct list_head *head;
 549
 550         if (!spin_trylock(&rds_ring->lock))
 551                 return;
 552
 553         producer = rds_ring->producer;
 554         head = &rds_ring->free_list;
 555
 556         while (!list_empty(head)) {
 557                 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
 558
 559                 if (!buffer->skb) {
 560                         if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
 561                                 break;
 562                 }
 563
 564                 count++;
 565                 list_del(&buffer->list);
 566
 567                 /* make a rcv descriptor  */
 568                 pdesc = &rds_ring->desc_head[producer];
 569                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
 570                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
 571                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
 572                 producer = get_next_index(producer, rds_ring->num_desc);
 573         }
 574
 575         if (count) {
 576                 rds_ring->producer = producer;
 577                 writel((producer - 1) & (rds_ring->num_desc - 1),
 578                        rds_ring->crb_rcv_producer);
 579         }
 580
 581         spin_unlock(&rds_ring->lock);
 582 }
 583
 584 static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
 585 {
 586         u32 sw_consumer, hw_consumer;
 587         int i, done, count = 0;
 588         struct qlcnic_cmd_buffer *buffer;
 589         struct pci_dev *pdev = adapter->pdev;
 590         struct net_device *netdev = adapter->netdev;
 591         struct qlcnic_skb_frag *frag;
 592         struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
 593
 594         if (!spin_trylock(&adapter->tx_clean_lock))
 595                 return 1;
 596
 597         sw_consumer = tx_ring->sw_consumer;
 598         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
 599
 600         while (sw_consumer != hw_consumer) {
 601                 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
 602                 if (buffer->skb) {
 603                         frag = &buffer->frag_array[0];
 604                         pci_unmap_single(pdev, frag->dma, frag->length,
 605                                          PCI_DMA_TODEVICE);
 606                         frag->dma = 0ULL;
 607                         for (i = 1; i < buffer->frag_count; i++) {
 608                                 frag++;
 609                                 pci_unmap_page(pdev, frag->dma, frag->length,
 610                                                PCI_DMA_TODEVICE);
 611                                 frag->dma = 0ULL;
 612                         }
 613
 614                         adapter->stats.xmitfinished++;
 615                         dev_kfree_skb_any(buffer->skb);
 616                         buffer->skb = NULL;
 617                 }
 618
 619                 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
 620                 if (++count >= MAX_STATUS_HANDLE)
 621                         break;
 622         }
 623
 624         if (count && netif_running(netdev)) {
 625                 tx_ring->sw_consumer = sw_consumer;
 626
 627                 smp_mb();
 628
 629                 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
 630                         if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
 631                                 netif_wake_queue(netdev);
 632                                 adapter->stats.xmit_on++;
 633                         }
 634                 }
 635                 adapter->tx_timeo_cnt = 0;
 636         }
 637         /*
 638          * If everything is freed up to consumer then check if the ring is full
 639          * If the ring is full then check if more needs to be freed and
 640          * schedule the call back again.
 641          *
 642          * This happens when there are 2 CPUs. One could be freeing and the
 643          * other filling it. If the ring is full when we get out of here and
 644          * the card has already interrupted the host then the host can miss the
 645          * interrupt.
 646          *
 647          * There is still a possible race condition and the host could miss an
 648          * interrupt. The card has to take care of this.
 649          */
 650         hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
 651         done = (sw_consumer == hw_consumer);
 652
 653         spin_unlock(&adapter->tx_clean_lock);
 654
 655         return done;
 656 }
 657
 658 static int qlcnic_poll(struct napi_struct *napi, int budget)
 659 {
 660         struct qlcnic_host_sds_ring *sds_ring;
 661         struct qlcnic_adapter *adapter;
 662         int tx_complete, work_done;
 663
 664         sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
 665         adapter = sds_ring->adapter;
 666
 667         tx_complete = qlcnic_process_cmd_ring(adapter);
 668         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
 669
 670         if ((work_done < budget) && tx_complete) {
 671                 napi_complete(&sds_ring->napi);
 672                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
 673                         qlcnic_enable_int(sds_ring);
 674         }
 675
 676         return work_done;
 677 }
 678
 679 static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
 680 {
 681         struct qlcnic_host_sds_ring *sds_ring;
 682         struct qlcnic_adapter *adapter;
 683         int work_done;
 684
 685         sds_ring = container_of(napi, struct qlcnic_host_sds_ring, napi);
 686         adapter = sds_ring->adapter;
 687
 688         work_done = qlcnic_process_rcv_ring(sds_ring, budget);
 689
 690         if (work_done < budget) {
 691                 napi_complete(&sds_ring->napi);
 692                 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
 693                         qlcnic_enable_int(sds_ring);
 694         }
 695
 696         return work_done;
 697 }
 698
 699 static void qlcnic_handle_linkevent(struct qlcnic_adapter *adapter,
 700                                     struct qlcnic_fw_msg *msg)
 701 {
 702         u32 cable_OUI;
 703         u16 cable_len, link_speed;
 704         u8  link_status, module, duplex, autoneg, lb_status = 0;
 705         struct net_device *netdev = adapter->netdev;
 706
 707         adapter->ahw->has_link_events = 1;
 708
 709         cable_OUI = msg->body[1] & 0xffffffff;
 710         cable_len = (msg->body[1] >> 32) & 0xffff;
 711         link_speed = (msg->body[1] >> 48) & 0xffff;
 712
 713         link_status = msg->body[2] & 0xff;
 714         duplex = (msg->body[2] >> 16) & 0xff;
 715         autoneg = (msg->body[2] >> 24) & 0xff;
 716         lb_status = (msg->body[2] >> 32) & 0x3;
 717
 718         module = (msg->body[2] >> 8) & 0xff;
 719         if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE)
 720                 dev_info(&netdev->dev,
 721                          "unsupported cable: OUI 0x%x, length %d\n",
 722                          cable_OUI, cable_len);
 723         else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN)
 724                 dev_info(&netdev->dev, "unsupported cable length %d\n",
 725                          cable_len);
 726
 727         if (!link_status && (lb_status == QLCNIC_ILB_MODE ||
 728             lb_status == QLCNIC_ELB_MODE))
 729                 adapter->ahw->loopback_state |= QLCNIC_LINKEVENT;
 730
 731         qlcnic_advert_link_change(adapter, link_status);
 732
 733         if (duplex == LINKEVENT_FULL_DUPLEX)
 734                 adapter->ahw->link_duplex = DUPLEX_FULL;
 735         else
 736                 adapter->ahw->link_duplex = DUPLEX_HALF;
 737
 738         adapter->ahw->module_type = module;
 739         adapter->ahw->link_autoneg = autoneg;
 740
 741         if (link_status) {
 742                 adapter->ahw->link_speed = link_speed;
 743         } else {
 744                 adapter->ahw->link_speed = SPEED_UNKNOWN;
 745                 adapter->ahw->link_duplex = DUPLEX_UNKNOWN;
 746         }
 747 }
 748
 749 static void qlcnic_handle_fw_message(int desc_cnt, int index,
 750                                      struct qlcnic_host_sds_ring *sds_ring)
 751 {
 752         struct qlcnic_fw_msg msg;
 753         struct status_desc *desc;
 754         struct qlcnic_adapter *adapter;
 755         struct device *dev;
 756         int i = 0, opcode, ret;
 757
 758         while (desc_cnt > 0 && i < 8) {
 759                 desc = &sds_ring->desc_head[index];
 760                 msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
 761                 msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
 762
 763                 index = get_next_index(index, sds_ring->num_desc);
 764                 desc_cnt--;
 765         }
 766
 767         adapter = sds_ring->adapter;
 768         dev = &adapter->pdev->dev;
 769         opcode = qlcnic_get_nic_msg_opcode(msg.body[0]);
 770
 771         switch (opcode) {
 772         case QLCNIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
 773                 qlcnic_handle_linkevent(adapter, &msg);
 774                 break;
 775         case QLCNIC_C2H_OPCODE_CONFIG_LOOPBACK:
 776                 ret = (u32)(msg.body[1]);
 777                 switch (ret) {
 778                 case 0:
 779                         adapter->ahw->loopback_state |= QLCNIC_LB_RESPONSE;
 780                         break;
 781                 case 1:
 782                         dev_info(dev, "loopback already in progress\n");
 783                         adapter->ahw->diag_cnt = -QLCNIC_TEST_IN_PROGRESS;
 784                         break;
 785                 case 2:
 786                         dev_info(dev, "loopback cable is not connected\n");
 787                         adapter->ahw->diag_cnt = -QLCNIC_LB_CABLE_NOT_CONN;
 788                         break;
 789                 default:
 790                         dev_info(dev,
 791                                  "loopback configure request failed, err %x\n",
 792                                  ret);
 793                         adapter->ahw->diag_cnt = -QLCNIC_UNDEFINED_ERROR;
 794                         break;
 795                 }
 796                 break;
 797         default:
 798                 break;
 799         }
 800 }
 801
 802 static struct sk_buff *
 803 qlcnic_process_rxbuf(struct qlcnic_adapter *adapter,
 804                      struct qlcnic_host_rds_ring *rds_ring, u16 index,
 805                      u16 cksum)
 806 {
 807         struct qlcnic_rx_buffer *buffer;
 808         struct sk_buff *skb;
 809
 810         buffer = &rds_ring->rx_buf_arr[index];
 811
 812         if (unlikely(buffer->skb == NULL)) {
 813                 WARN_ON(1);
 814                 return NULL;
 815         }
 816
 817         pci_unmap_single(adapter->pdev, buffer->dma, rds_ring->dma_size,
 818                          PCI_DMA_FROMDEVICE);
 819
 820         skb = buffer->skb;
 821
 822         if (likely((adapter->netdev->features & NETIF_F_RXCSUM) &&
 823                    (cksum == STATUS_CKSUM_OK || cksum == STATUS_CKSUM_LOOP))) {
 824                 adapter->stats.csummed++;
 825                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 826         } else {
 827                 skb_checksum_none_assert(skb);
 828         }
 829
 830         buffer->skb = NULL;
 831
 832         return skb;
 833 }
 834
 835 static inline int qlcnic_check_rx_tagging(struct qlcnic_adapter *adapter,
 836                                           struct sk_buff *skb, u16 *vlan_tag)
 837 {
 838         struct ethhdr *eth_hdr;
 839
 840         if (!__vlan_get_tag(skb, vlan_tag)) {
 841                 eth_hdr = (struct ethhdr *)skb->data;
 842                 memmove(skb->data + VLAN_HLEN, eth_hdr, ETH_ALEN * 2);
 843                 skb_pull(skb, VLAN_HLEN);
 844         }
 845         if (!adapter->pvid)
 846                 return 0;
 847
 848         if (*vlan_tag == adapter->pvid) {
 849                 /* Outer vlan tag. Packet should follow non-vlan path */
 850                 *vlan_tag = 0xffff;
 851                 return 0;
 852         }
 853         if (adapter->flags & QLCNIC_TAGGING_ENABLED)
 854                 return 0;
 855
 856         return -EINVAL;
 857 }
 858
 859 static struct qlcnic_rx_buffer *
 860 qlcnic_process_rcv(struct qlcnic_adapter *adapter,
 861                    struct qlcnic_host_sds_ring *sds_ring, int ring,
 862                    u64 sts_data0)
 863 {
 864         struct net_device *netdev = adapter->netdev;
 865         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 866         struct qlcnic_rx_buffer *buffer;
 867         struct sk_buff *skb;
 868         struct qlcnic_host_rds_ring *rds_ring;
 869         int index, length, cksum, pkt_offset;
 870         u16 vid = 0xffff;
 871
 872         if (unlikely(ring >= adapter->max_rds_rings))
 873                 return NULL;
 874
 875         rds_ring = &recv_ctx->rds_rings[ring];
 876
 877         index = qlcnic_get_sts_refhandle(sts_data0);
 878         if (unlikely(index >= rds_ring->num_desc))
 879                 return NULL;
 880
 881         buffer = &rds_ring->rx_buf_arr[index];
 882         length = qlcnic_get_sts_totallength(sts_data0);
 883         cksum  = qlcnic_get_sts_status(sts_data0);
 884         pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
 885
 886         skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
 887         if (!skb)
 888                 return buffer;
 889
 890         if (length > rds_ring->skb_size)
 891                 skb_put(skb, rds_ring->skb_size);
 892         else
 893                 skb_put(skb, length);
 894
 895         if (pkt_offset)
 896                 skb_pull(skb, pkt_offset);
 897
 898         if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
 899                 adapter->stats.rxdropped++;
 900                 dev_kfree_skb(skb);
 901                 return buffer;
 902         }
 903
 904         skb->protocol = eth_type_trans(skb, netdev);
 905
 906         if (vid != 0xffff)
 907                 __vlan_hwaccel_put_tag(skb, vid);
 908
 909         napi_gro_receive(&sds_ring->napi, skb);
 910
 911         adapter->stats.rx_pkts++;
 912         adapter->stats.rxbytes += length;
 913
 914         return buffer;
 915 }
 916
 917 #define QLC_TCP_HDR_SIZE            20
 918 #define QLC_TCP_TS_OPTION_SIZE      12
 919 #define QLC_TCP_TS_HDR_SIZE         (QLC_TCP_HDR_SIZE + QLC_TCP_TS_OPTION_SIZE)
 920
 921 static struct qlcnic_rx_buffer *
 922 qlcnic_process_lro(struct qlcnic_adapter *adapter,
 923                    int ring, u64 sts_data0, u64 sts_data1)
 924 {
 925         struct net_device *netdev = adapter->netdev;
 926         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 927         struct qlcnic_rx_buffer *buffer;
 928         struct sk_buff *skb;
 929         struct qlcnic_host_rds_ring *rds_ring;
 930         struct iphdr *iph;
 931         struct tcphdr *th;
 932         bool push, timestamp;
 933         int index, l2_hdr_offset, l4_hdr_offset;
 934         u16 lro_length, length, data_offset, vid = 0xffff;
 935         u32 seq_number;
 936
 937         if (unlikely(ring > adapter->max_rds_rings))
 938                 return NULL;
 939
 940         rds_ring = &recv_ctx->rds_rings[ring];
 941
 942         index = qlcnic_get_lro_sts_refhandle(sts_data0);
 943         if (unlikely(index > rds_ring->num_desc))
 944                 return NULL;
 945
 946         buffer = &rds_ring->rx_buf_arr[index];
 947
 948         timestamp = qlcnic_get_lro_sts_timestamp(sts_data0);
 949         lro_length = qlcnic_get_lro_sts_length(sts_data0);
 950         l2_hdr_offset = qlcnic_get_lro_sts_l2_hdr_offset(sts_data0);
 951         l4_hdr_offset = qlcnic_get_lro_sts_l4_hdr_offset(sts_data0);
 952         push = qlcnic_get_lro_sts_push_flag(sts_data0);
 953         seq_number = qlcnic_get_lro_sts_seq_number(sts_data1);
 954
 955         skb = qlcnic_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
 956         if (!skb)
 957                 return buffer;
 958
 959         if (timestamp)
 960                 data_offset = l4_hdr_offset + QLC_TCP_TS_HDR_SIZE;
 961         else
 962                 data_offset = l4_hdr_offset + QLC_TCP_HDR_SIZE;
 963
 964         skb_put(skb, lro_length + data_offset);
 965         skb_pull(skb, l2_hdr_offset);
 966
 967         if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
 968                 adapter->stats.rxdropped++;
 969                 dev_kfree_skb(skb);
 970                 return buffer;
 971         }
 972
 973         skb->protocol = eth_type_trans(skb, netdev);
 974         iph = (struct iphdr *)skb->data;
 975         th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
 976         length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
 977         iph->tot_len = htons(length);
 978         iph->check = 0;
 979         iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
 980         th->psh = push;
 981         th->seq = htonl(seq_number);
 982         length = skb->len;
 983
 984         if (adapter->flags & QLCNIC_FW_LRO_MSS_CAP)
 985                 skb_shinfo(skb)->gso_size = qlcnic_get_lro_sts_mss(sts_data1);
 986
 987         if (vid != 0xffff)
 988                 __vlan_hwaccel_put_tag(skb, vid);
 989         netif_receive_skb(skb);
 990
 991         adapter->stats.lro_pkts++;
 992         adapter->stats.lrobytes += length;
 993
 994         return buffer;
 995 }
 996
 997 int qlcnic_process_rcv_ring(struct qlcnic_host_sds_ring *sds_ring, int max)
 998 {
 999         struct qlcnic_host_rds_ring *rds_ring;
1000         struct qlcnic_adapter *adapter = sds_ring->adapter;
1001         struct list_head *cur;
1002         struct status_desc *desc;
1003         struct qlcnic_rx_buffer *rxbuf;
1004         u64 sts_data0, sts_data1;
1005         __le64 owner_phantom = cpu_to_le64(STATUS_OWNER_PHANTOM);
1006         int opcode, ring, desc_cnt, count = 0;
1007         u32 consumer = sds_ring->consumer;
1008
1009         while (count < max) {
1010                 desc = &sds_ring->desc_head[consumer];
1011                 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1012
1013                 if (!(sts_data0 & STATUS_OWNER_HOST))
1014                         break;
1015
1016                 desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1017                 opcode = qlcnic_get_sts_opcode(sts_data0);
1018
1019                 switch (opcode) {
1020                 case QLCNIC_RXPKT_DESC:
1021                 case QLCNIC_OLD_RXPKT_DESC:
1022                 case QLCNIC_SYN_OFFLOAD:
1023                         ring = qlcnic_get_sts_type(sts_data0);
1024                         rxbuf = qlcnic_process_rcv(adapter, sds_ring, ring,
1025                                                    sts_data0);
1026                         break;
1027                 case QLCNIC_LRO_DESC:
1028                         ring = qlcnic_get_lro_sts_type(sts_data0);
1029                         sts_data1 = le64_to_cpu(desc->status_desc_data[1]);
1030                         rxbuf = qlcnic_process_lro(adapter, ring, sts_data0,
1031                                                    sts_data1);
1032                         break;
1033                 case QLCNIC_RESPONSE_DESC:
1034                         qlcnic_handle_fw_message(desc_cnt, consumer, sds_ring);
1035                 default:
1036                         goto skip;
1037                 }
1038
1039                 WARN_ON(desc_cnt > 1);
1040
1041                 if (likely(rxbuf))
1042                         list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
1043                 else
1044                         adapter->stats.null_rxbuf++;
1045
1046 skip:
1047                 for (; desc_cnt > 0; desc_cnt--) {
1048                         desc = &sds_ring->desc_head[consumer];
1049                         desc->status_desc_data[0] = owner_phantom;
1050                         consumer = get_next_index(consumer, sds_ring->num_desc);
1051                 }
1052                 count++;
1053         }
1054
1055         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1056                 rds_ring = &adapter->recv_ctx->rds_rings[ring];
1057
1058                 if (!list_empty(&sds_ring->free_list[ring])) {
1059                         list_for_each(cur, &sds_ring->free_list[ring]) {
1060                                 rxbuf = list_entry(cur, struct qlcnic_rx_buffer,
1061                                                    list);
1062                                 qlcnic_alloc_rx_skb(adapter, rds_ring, rxbuf);
1063                         }
1064                         spin_lock(&rds_ring->lock);
1065                         list_splice_tail_init(&sds_ring->free_list[ring],
1066                                               &rds_ring->free_list);
1067                         spin_unlock(&rds_ring->lock);
1068                 }
1069
1070                 qlcnic_post_rx_buffers_nodb(adapter, rds_ring);
1071         }
1072
1073         if (count) {
1074                 sds_ring->consumer = consumer;
1075                 writel(consumer, sds_ring->crb_sts_consumer);
1076         }
1077
1078         return count;
1079 }
1080
1081 void qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter,
1082                             struct qlcnic_host_rds_ring *rds_ring)
1083 {
1084         struct rcv_desc *pdesc;
1085         struct qlcnic_rx_buffer *buffer;
1086         int count = 0;
1087         u32 producer;
1088         struct list_head *head;
1089
1090         producer = rds_ring->producer;
1091         head = &rds_ring->free_list;
1092
1093         while (!list_empty(head)) {
1094
1095                 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
1096
1097                 if (!buffer->skb) {
1098                         if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
1099                                 break;
1100                 }
1101
1102                 count++;
1103                 list_del(&buffer->list);
1104
1105                 /* make a rcv descriptor  */
1106                 pdesc = &rds_ring->desc_head[producer];
1107                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1108                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1109                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1110                 producer = get_next_index(producer, rds_ring->num_desc);
1111         }
1112
1113         if (count) {
1114                 rds_ring->producer = producer;
1115                 writel((producer-1) & (rds_ring->num_desc-1),
1116                        rds_ring->crb_rcv_producer);
1117         }
1118 }
1119
1120 static void dump_skb(struct sk_buff *skb, struct qlcnic_adapter *adapter)
1121 {
1122         int i;
1123         unsigned char *data = skb->data;
1124
1125         pr_info(KERN_INFO "\n");
1126         for (i = 0; i < skb->len; i++) {
1127                 QLCDB(adapter, DRV, "%02x ", data[i]);
1128                 if ((i & 0x0f) == 8)
1129                         pr_info(KERN_INFO "\n");
1130         }
1131 }
1132
1133 static void qlcnic_process_rcv_diag(struct qlcnic_adapter *adapter, int ring,
1134                                     u64 sts_data0)
1135 {
1136         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1137         struct sk_buff *skb;
1138         struct qlcnic_host_rds_ring *rds_ring;
1139         int index, length, cksum, pkt_offset;
1140
1141         if (unlikely(ring >= adapter->max_rds_rings))
1142                 return;
1143
1144         rds_ring = &recv_ctx->rds_rings[ring];
1145
1146         index = qlcnic_get_sts_refhandle(sts_data0);
1147         length = qlcnic_get_sts_totallength(sts_data0);
1148         if (unlikely(index >= rds_ring->num_desc))
1149                 return;
1150
1151         cksum  = qlcnic_get_sts_status(sts_data0);
1152         pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
1153
1154         skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1155         if (!skb)
1156                 return;
1157
1158         if (length > rds_ring->skb_size)
1159                 skb_put(skb, rds_ring->skb_size);
1160         else
1161                 skb_put(skb, length);
1162
1163         if (pkt_offset)
1164                 skb_pull(skb, pkt_offset);
1165
1166         if (!qlcnic_check_loopback_buff(skb->data, adapter->mac_addr))
1167                 adapter->ahw->diag_cnt++;
1168         else
1169                 dump_skb(skb, adapter);
1170
1171         dev_kfree_skb_any(skb);
1172         adapter->stats.rx_pkts++;
1173         adapter->stats.rxbytes += length;
1174
1175         return;
1176 }
1177
1178 void qlcnic_82xx_process_rcv_ring_diag(struct qlcnic_host_sds_ring *sds_ring)
1179 {
1180         struct qlcnic_adapter *adapter = sds_ring->adapter;
1181         struct status_desc *desc;
1182         u64 sts_data0;
1183         int ring, opcode, desc_cnt;
1184
1185         u32 consumer = sds_ring->consumer;
1186
1187         desc = &sds_ring->desc_head[consumer];
1188         sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1189
1190         if (!(sts_data0 & STATUS_OWNER_HOST))
1191                 return;
1192
1193         desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1194         opcode = qlcnic_get_sts_opcode(sts_data0);
1195         switch (opcode) {
1196         case QLCNIC_RESPONSE_DESC:
1197                 qlcnic_handle_fw_message(desc_cnt, consumer, sds_ring);
1198                 break;
1199         default:
1200                 ring = qlcnic_get_sts_type(sts_data0);
1201                 qlcnic_process_rcv_diag(adapter, ring, sts_data0);
1202                 break;
1203         }
1204
1205         for (; desc_cnt > 0; desc_cnt--) {
1206                 desc = &sds_ring->desc_head[consumer];
1207                 desc->status_desc_data[0] = cpu_to_le64(STATUS_OWNER_PHANTOM);
1208                 consumer = get_next_index(consumer, sds_ring->num_desc);
1209         }
1210
1211         sds_ring->consumer = consumer;
1212         writel(consumer, sds_ring->crb_sts_consumer);
1213 }
1214
1215 int qlcnic_82xx_napi_add(struct qlcnic_adapter *adapter,
1216                          struct net_device *netdev)
1217 {
1218         int ring, max_sds_rings;
1219         struct qlcnic_host_sds_ring *sds_ring;
1220         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1221
1222         if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
1223                 return -ENOMEM;
1224
1225         max_sds_rings = adapter->max_sds_rings;
1226
1227         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1228                 sds_ring = &recv_ctx->sds_rings[ring];
1229
1230                 if (ring == max_sds_rings - 1)
1231                         netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
1232                                        QLCNIC_NETDEV_WEIGHT / max_sds_rings);
1233                 else
1234                         netif_napi_add(netdev, &sds_ring->napi, qlcnic_rx_poll,
1235                                        QLCNIC_NETDEV_WEIGHT*2);
1236         }
1237
1238         return 0;
1239 }
1240
1241 void qlcnic_napi_del(struct qlcnic_adapter *adapter)
1242 {
1243         int ring;
1244         struct qlcnic_host_sds_ring *sds_ring;
1245         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1246
1247         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1248                 sds_ring = &recv_ctx->sds_rings[ring];
1249                 netif_napi_del(&sds_ring->napi);
1250         }
1251
1252         qlcnic_free_sds_rings(adapter->recv_ctx);
1253 }
1254
1255 void qlcnic_82xx_napi_enable(struct qlcnic_adapter *adapter)
1256 {
1257         int ring;
1258         struct qlcnic_host_sds_ring *sds_ring;
1259         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1260
1261         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1262                 return;
1263
1264         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1265                 sds_ring = &recv_ctx->sds_rings[ring];
1266                 napi_enable(&sds_ring->napi);
1267                 qlcnic_enable_int(sds_ring);
1268         }
1269 }
1270
1271 void qlcnic_82xx_napi_disable(struct qlcnic_adapter *adapter)
1272 {
1273         int ring;
1274         struct qlcnic_host_sds_ring *sds_ring;
1275         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1276
1277         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1278                 return;
1279
1280         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1281                 sds_ring = &recv_ctx->sds_rings[ring];
1282                 qlcnic_disable_int(sds_ring);
1283                 napi_synchronize(&sds_ring->napi);
1284                 napi_disable(&sds_ring->napi);
1285         }
1286 }