Pileus Git - ~andy/linux/blob - drivers/net/ethernet/qlogic/qlcnic/qlcnic_io.c

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