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