drivers/net/benet/be_main.c

   1 /*
   2  * Copyright (C) 2005 - 2010 ServerEngines
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation.  The full GNU General
   8  * Public License is included in this distribution in the file called COPYING.
   9  *
  10  * Contact Information:
  11  * linux-drivers@serverengines.com
  12  *
  13  * ServerEngines
  14  * 209 N. Fair Oaks Ave
  15  * Sunnyvale, CA 94085
  16  */
  17
  18 #include "be.h"
  19 #include "be_cmds.h"
  20 #include <asm/div64.h>
  21
  22 MODULE_VERSION(DRV_VER);
  23 MODULE_DEVICE_TABLE(pci, be_dev_ids);
  24 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
  25 MODULE_AUTHOR("ServerEngines Corporation");
  26 MODULE_LICENSE("GPL");
  27
  28 static unsigned int rx_frag_size = 2048;
  29 static unsigned int num_vfs;
  30 module_param(rx_frag_size, uint, S_IRUGO);
  31 module_param(num_vfs, uint, S_IRUGO);
  32 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
  33 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
  34
  35 static bool multi_rxq = true;
  36 module_param(multi_rxq, bool, S_IRUGO | S_IWUSR);
  37 MODULE_PARM_DESC(multi_rxq, "Multi Rx Queue support. Enabled by default");
  38
  39 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
  40         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
  41         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
  42         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
  43         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
  44         { 0 }
  45 };
  46 MODULE_DEVICE_TABLE(pci, be_dev_ids);
  47 /* UE Status Low CSR */
  48 static char *ue_status_low_desc[] = {
  49         "CEV",
  50         "CTX",
  51         "DBUF",
  52         "ERX",
  53         "Host",
  54         "MPU",
  55         "NDMA",
  56         "PTC ",
  57         "RDMA ",
  58         "RXF ",
  59         "RXIPS ",
  60         "RXULP0 ",
  61         "RXULP1 ",
  62         "RXULP2 ",
  63         "TIM ",
  64         "TPOST ",
  65         "TPRE ",
  66         "TXIPS ",
  67         "TXULP0 ",
  68         "TXULP1 ",
  69         "UC ",
  70         "WDMA ",
  71         "TXULP2 ",
  72         "HOST1 ",
  73         "P0_OB_LINK ",
  74         "P1_OB_LINK ",
  75         "HOST_GPIO ",
  76         "MBOX ",
  77         "AXGMAC0",
  78         "AXGMAC1",
  79         "JTAG",
  80         "MPU_INTPEND"
  81 };
  82 /* UE Status High CSR */
  83 static char *ue_status_hi_desc[] = {
  84         "LPCMEMHOST",
  85         "MGMT_MAC",
  86         "PCS0ONLINE",
  87         "MPU_IRAM",
  88         "PCS1ONLINE",
  89         "PCTL0",
  90         "PCTL1",
  91         "PMEM",
  92         "RR",
  93         "TXPB",
  94         "RXPP",
  95         "XAUI",
  96         "TXP",
  97         "ARM",
  98         "IPC",
  99         "HOST2",
 100         "HOST3",
 101         "HOST4",
 102         "HOST5",
 103         "HOST6",
 104         "HOST7",
 105         "HOST8",
 106         "HOST9",
 107         "NETC"
 108         "Unknown",
 109         "Unknown",
 110         "Unknown",
 111         "Unknown",
 112         "Unknown",
 113         "Unknown",
 114         "Unknown",
 115         "Unknown"
 116 };
 117
 118 static inline bool be_multi_rxq(struct be_adapter *adapter)
 119 {
 120         return (adapter->num_rx_qs > 1);
 121 }
 122
 123 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
 124 {
 125         struct be_dma_mem *mem = &q->dma_mem;
 126         if (mem->va)
 127                 pci_free_consistent(adapter->pdev, mem->size,
 128                         mem->va, mem->dma);
 129 }
 130
 131 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
 132                 u16 len, u16 entry_size)
 133 {
 134         struct be_dma_mem *mem = &q->dma_mem;
 135
 136         memset(q, 0, sizeof(*q));
 137         q->len = len;
 138         q->entry_size = entry_size;
 139         mem->size = len * entry_size;
 140         mem->va = pci_alloc_consistent(adapter->pdev, mem->size, &mem->dma);
 141         if (!mem->va)
 142                 return -1;
 143         memset(mem->va, 0, mem->size);
 144         return 0;
 145 }
 146
 147 static void be_intr_set(struct be_adapter *adapter, bool enable)
 148 {
 149         u8 __iomem *addr = adapter->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET;
 150         u32 reg = ioread32(addr);
 151         u32 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 152
 153         if (adapter->eeh_err)
 154                 return;
 155
 156         if (!enabled && enable)
 157                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 158         else if (enabled && !enable)
 159                 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 160         else
 161                 return;
 162
 163         iowrite32(reg, addr);
 164 }
 165
 166 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
 167 {
 168         u32 val = 0;
 169         val |= qid & DB_RQ_RING_ID_MASK;
 170         val |= posted << DB_RQ_NUM_POSTED_SHIFT;
 171
 172         wmb();
 173         iowrite32(val, adapter->db + DB_RQ_OFFSET);
 174 }
 175
 176 static void be_txq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
 177 {
 178         u32 val = 0;
 179         val |= qid & DB_TXULP_RING_ID_MASK;
 180         val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
 181
 182         wmb();
 183         iowrite32(val, adapter->db + DB_TXULP1_OFFSET);
 184 }
 185
 186 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
 187                 bool arm, bool clear_int, u16 num_popped)
 188 {
 189         u32 val = 0;
 190         val |= qid & DB_EQ_RING_ID_MASK;
 191
 192         if (adapter->eeh_err)
 193                 return;
 194
 195         if (arm)
 196                 val |= 1 << DB_EQ_REARM_SHIFT;
 197         if (clear_int)
 198                 val |= 1 << DB_EQ_CLR_SHIFT;
 199         val |= 1 << DB_EQ_EVNT_SHIFT;
 200         val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
 201         iowrite32(val, adapter->db + DB_EQ_OFFSET);
 202 }
 203
 204 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
 205 {
 206         u32 val = 0;
 207         val |= qid & DB_CQ_RING_ID_MASK;
 208
 209         if (adapter->eeh_err)
 210                 return;
 211
 212         if (arm)
 213                 val |= 1 << DB_CQ_REARM_SHIFT;
 214         val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
 215         iowrite32(val, adapter->db + DB_CQ_OFFSET);
 216 }
 217
 218 static int be_mac_addr_set(struct net_device *netdev, void *p)
 219 {
 220         struct be_adapter *adapter = netdev_priv(netdev);
 221         struct sockaddr *addr = p;
 222         int status = 0;
 223
 224         if (!is_valid_ether_addr(addr->sa_data))
 225                 return -EADDRNOTAVAIL;
 226
 227         /* MAC addr configuration will be done in hardware for VFs
 228          * by their corresponding PFs. Just copy to netdev addr here
 229          */
 230         if (!be_physfn(adapter))
 231                 goto netdev_addr;
 232
 233         status = be_cmd_pmac_del(adapter, adapter->if_handle, adapter->pmac_id);
 234         if (status)
 235                 return status;
 236
 237         status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
 238                         adapter->if_handle, &adapter->pmac_id);
 239 netdev_addr:
 240         if (!status)
 241                 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 242
 243         return status;
 244 }
 245
 246 void netdev_stats_update(struct be_adapter *adapter)
 247 {
 248         struct be_hw_stats *hw_stats = hw_stats_from_cmd(adapter->stats_cmd.va);
 249         struct be_rxf_stats *rxf_stats = &hw_stats->rxf;
 250         struct be_port_rxf_stats *port_stats =
 251                         &rxf_stats->port[adapter->port_num];
 252         struct net_device_stats *dev_stats = &adapter->netdev->stats;
 253         struct be_erx_stats *erx_stats = &hw_stats->erx;
 254         struct be_rx_obj *rxo;
 255         int i;
 256
 257         memset(dev_stats, 0, sizeof(*dev_stats));
 258         for_all_rx_queues(adapter, rxo, i) {
 259                 dev_stats->rx_packets += rx_stats(rxo)->rx_pkts;
 260                 dev_stats->rx_bytes += rx_stats(rxo)->rx_bytes;
 261                 dev_stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
 262                 /*  no space in linux buffers: best possible approximation */
 263                 dev_stats->rx_dropped +=
 264                         erx_stats->rx_drops_no_fragments[rxo->q.id];
 265         }
 266
 267         dev_stats->tx_packets = tx_stats(adapter)->be_tx_pkts;
 268         dev_stats->tx_bytes = tx_stats(adapter)->be_tx_bytes;
 269
 270         /* bad pkts received */
 271         dev_stats->rx_errors = port_stats->rx_crc_errors +
 272                 port_stats->rx_alignment_symbol_errors +
 273                 port_stats->rx_in_range_errors +
 274                 port_stats->rx_out_range_errors +
 275                 port_stats->rx_frame_too_long +
 276                 port_stats->rx_dropped_too_small +
 277                 port_stats->rx_dropped_too_short +
 278                 port_stats->rx_dropped_header_too_small +
 279                 port_stats->rx_dropped_tcp_length +
 280                 port_stats->rx_dropped_runt +
 281                 port_stats->rx_tcp_checksum_errs +
 282                 port_stats->rx_ip_checksum_errs +
 283                 port_stats->rx_udp_checksum_errs;
 284
 285         /* detailed rx errors */
 286         dev_stats->rx_length_errors = port_stats->rx_in_range_errors +
 287                 port_stats->rx_out_range_errors +
 288                 port_stats->rx_frame_too_long;
 289
 290         dev_stats->rx_crc_errors = port_stats->rx_crc_errors;
 291
 292         /* frame alignment errors */
 293         dev_stats->rx_frame_errors = port_stats->rx_alignment_symbol_errors;
 294
 295         /* receiver fifo overrun */
 296         /* drops_no_pbuf is no per i/f, it's per BE card */
 297         dev_stats->rx_fifo_errors = port_stats->rx_fifo_overflow +
 298                                         port_stats->rx_input_fifo_overflow +
 299                                         rxf_stats->rx_drops_no_pbuf;
 300 }
 301
 302 void be_link_status_update(struct be_adapter *adapter, bool link_up)
 303 {
 304         struct net_device *netdev = adapter->netdev;
 305
 306         /* If link came up or went down */
 307         if (adapter->link_up != link_up) {
 308                 adapter->link_speed = -1;
 309                 if (link_up) {
 310                         netif_start_queue(netdev);
 311                         netif_carrier_on(netdev);
 312                         printk(KERN_INFO "%s: Link up\n", netdev->name);
 313                 } else {
 314                         netif_stop_queue(netdev);
 315                         netif_carrier_off(netdev);
 316                         printk(KERN_INFO "%s: Link down\n", netdev->name);
 317                 }
 318                 adapter->link_up = link_up;
 319         }
 320 }
 321
 322 /* Update the EQ delay n BE based on the RX frags consumed / sec */
 323 static void be_rx_eqd_update(struct be_adapter *adapter, struct be_rx_obj *rxo)
 324 {
 325         struct be_eq_obj *rx_eq = &rxo->rx_eq;
 326         struct be_rx_stats *stats = &rxo->stats;
 327         ulong now = jiffies;
 328         u32 eqd;
 329
 330         if (!rx_eq->enable_aic)
 331                 return;
 332
 333         /* Wrapped around */
 334         if (time_before(now, stats->rx_fps_jiffies)) {
 335                 stats->rx_fps_jiffies = now;
 336                 return;
 337         }
 338
 339         /* Update once a second */
 340         if ((now - stats->rx_fps_jiffies) < HZ)
 341                 return;
 342
 343         stats->rx_fps = (stats->rx_frags - stats->prev_rx_frags) /
 344                         ((now - stats->rx_fps_jiffies) / HZ);
 345
 346         stats->rx_fps_jiffies = now;
 347         stats->prev_rx_frags = stats->rx_frags;
 348         eqd = stats->rx_fps / 110000;
 349         eqd = eqd << 3;
 350         if (eqd > rx_eq->max_eqd)
 351                 eqd = rx_eq->max_eqd;
 352         if (eqd < rx_eq->min_eqd)
 353                 eqd = rx_eq->min_eqd;
 354         if (eqd < 10)
 355                 eqd = 0;
 356         if (eqd != rx_eq->cur_eqd)
 357                 be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);
 358
 359         rx_eq->cur_eqd = eqd;
 360 }
 361
 362 static u32 be_calc_rate(u64 bytes, unsigned long ticks)
 363 {
 364         u64 rate = bytes;
 365
 366         do_div(rate, ticks / HZ);
 367         rate <<= 3;                     /* bytes/sec -> bits/sec */
 368         do_div(rate, 1000000ul);        /* MB/Sec */
 369
 370         return rate;
 371 }
 372
 373 static void be_tx_rate_update(struct be_adapter *adapter)
 374 {
 375         struct be_tx_stats *stats = tx_stats(adapter);
 376         ulong now = jiffies;
 377
 378         /* Wrapped around? */
 379         if (time_before(now, stats->be_tx_jiffies)) {
 380                 stats->be_tx_jiffies = now;
 381                 return;
 382         }
 383
 384         /* Update tx rate once in two seconds */
 385         if ((now - stats->be_tx_jiffies) > 2 * HZ) {
 386                 stats->be_tx_rate = be_calc_rate(stats->be_tx_bytes
 387                                                   - stats->be_tx_bytes_prev,
 388                                                  now - stats->be_tx_jiffies);
 389                 stats->be_tx_jiffies = now;
 390                 stats->be_tx_bytes_prev = stats->be_tx_bytes;
 391         }
 392 }
 393
 394 static void be_tx_stats_update(struct be_adapter *adapter,
 395                         u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
 396 {
 397         struct be_tx_stats *stats = tx_stats(adapter);
 398         stats->be_tx_reqs++;
 399         stats->be_tx_wrbs += wrb_cnt;
 400         stats->be_tx_bytes += copied;
 401         stats->be_tx_pkts += (gso_segs ? gso_segs : 1);
 402         if (stopped)
 403                 stats->be_tx_stops++;
 404 }
 405
 406 /* Determine number of WRB entries needed to xmit data in an skb */
 407 static u32 wrb_cnt_for_skb(struct sk_buff *skb, bool *dummy)
 408 {
 409         int cnt = (skb->len > skb->data_len);
 410
 411         cnt += skb_shinfo(skb)->nr_frags;
 412
 413         /* to account for hdr wrb */
 414         cnt++;
 415         if (cnt & 1) {
 416                 /* add a dummy to make it an even num */
 417                 cnt++;
 418                 *dummy = true;
 419         } else
 420                 *dummy = false;
 421         BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
 422         return cnt;
 423 }
 424
 425 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
 426 {
 427         wrb->frag_pa_hi = upper_32_bits(addr);
 428         wrb->frag_pa_lo = addr & 0xFFFFFFFF;
 429         wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
 430 }
 431
 432 static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
 433                 struct sk_buff *skb, u32 wrb_cnt, u32 len)
 434 {
 435         u8 vlan_prio = 0;
 436         u16 vlan_tag = 0;
 437
 438         memset(hdr, 0, sizeof(*hdr));
 439
 440         AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
 441
 442         if (skb_is_gso(skb)) {
 443                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
 444                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
 445                         hdr, skb_shinfo(skb)->gso_size);
 446                 if (skb_is_gso_v6(skb))
 447                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
 448         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 449                 if (is_tcp_pkt(skb))
 450                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
 451                 else if (is_udp_pkt(skb))
 452                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
 453         }
 454
 455         if (adapter->vlan_grp && vlan_tx_tag_present(skb)) {
 456                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
 457                 vlan_tag = vlan_tx_tag_get(skb);
 458                 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
 459                 /* If vlan priority provided by OS is NOT in available bmap */
 460                 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
 461                         vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
 462                                         adapter->recommended_prio;
 463                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
 464         }
 465
 466         AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
 467         AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, 1);
 468         AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
 469         AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
 470 }
 471
 472 static void unmap_tx_frag(struct pci_dev *pdev, struct be_eth_wrb *wrb,
 473                 bool unmap_single)
 474 {
 475         dma_addr_t dma;
 476
 477         be_dws_le_to_cpu(wrb, sizeof(*wrb));
 478
 479         dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
 480         if (wrb->frag_len) {
 481                 if (unmap_single)
 482                         pci_unmap_single(pdev, dma, wrb->frag_len,
 483                                 PCI_DMA_TODEVICE);
 484                 else
 485                         pci_unmap_page(pdev, dma, wrb->frag_len,
 486                                 PCI_DMA_TODEVICE);
 487         }
 488 }
 489
 490 static int make_tx_wrbs(struct be_adapter *adapter,
 491                 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
 492 {
 493         dma_addr_t busaddr;
 494         int i, copied = 0;
 495         struct pci_dev *pdev = adapter->pdev;
 496         struct sk_buff *first_skb = skb;
 497         struct be_queue_info *txq = &adapter->tx_obj.q;
 498         struct be_eth_wrb *wrb;
 499         struct be_eth_hdr_wrb *hdr;
 500         bool map_single = false;
 501         u16 map_head;
 502
 503         hdr = queue_head_node(txq);
 504         queue_head_inc(txq);
 505         map_head = txq->head;
 506
 507         if (skb->len > skb->data_len) {
 508                 int len = skb_headlen(skb);
 509                 busaddr = pci_map_single(pdev, skb->data, len,
 510                                          PCI_DMA_TODEVICE);
 511                 if (pci_dma_mapping_error(pdev, busaddr))
 512                         goto dma_err;
 513                 map_single = true;
 514                 wrb = queue_head_node(txq);
 515                 wrb_fill(wrb, busaddr, len);
 516                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 517                 queue_head_inc(txq);
 518                 copied += len;
 519         }
 520
 521         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 522                 struct skb_frag_struct *frag =
 523                         &skb_shinfo(skb)->frags[i];
 524                 busaddr = pci_map_page(pdev, frag->page,
 525                                        frag->page_offset,
 526                                        frag->size, PCI_DMA_TODEVICE);
 527                 if (pci_dma_mapping_error(pdev, busaddr))
 528                         goto dma_err;
 529                 wrb = queue_head_node(txq);
 530                 wrb_fill(wrb, busaddr, frag->size);
 531                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 532                 queue_head_inc(txq);
 533                 copied += frag->size;
 534         }
 535
 536         if (dummy_wrb) {
 537                 wrb = queue_head_node(txq);
 538                 wrb_fill(wrb, 0, 0);
 539                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 540                 queue_head_inc(txq);
 541         }
 542
 543         wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied);
 544         be_dws_cpu_to_le(hdr, sizeof(*hdr));
 545
 546         return copied;
 547 dma_err:
 548         txq->head = map_head;
 549         while (copied) {
 550                 wrb = queue_head_node(txq);
 551                 unmap_tx_frag(pdev, wrb, map_single);
 552                 map_single = false;
 553                 copied -= wrb->frag_len;
 554                 queue_head_inc(txq);
 555         }
 556         return 0;
 557 }
 558
 559 static netdev_tx_t be_xmit(struct sk_buff *skb,
 560                         struct net_device *netdev)
 561 {
 562         struct be_adapter *adapter = netdev_priv(netdev);
 563         struct be_tx_obj *tx_obj = &adapter->tx_obj;
 564         struct be_queue_info *txq = &tx_obj->q;
 565         u32 wrb_cnt = 0, copied = 0;
 566         u32 start = txq->head;
 567         bool dummy_wrb, stopped = false;
 568
 569         wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb);
 570
 571         copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
 572         if (copied) {
 573                 /* record the sent skb in the sent_skb table */
 574                 BUG_ON(tx_obj->sent_skb_list[start]);
 575                 tx_obj->sent_skb_list[start] = skb;
 576
 577                 /* Ensure txq has space for the next skb; Else stop the queue
 578                  * *BEFORE* ringing the tx doorbell, so that we serialze the
 579                  * tx compls of the current transmit which'll wake up the queue
 580                  */
 581                 atomic_add(wrb_cnt, &txq->used);
 582                 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
 583                                                                 txq->len) {
 584                         netif_stop_queue(netdev);
 585                         stopped = true;
 586                 }
 587
 588                 be_txq_notify(adapter, txq->id, wrb_cnt);
 589
 590                 be_tx_stats_update(adapter, wrb_cnt, copied,
 591                                 skb_shinfo(skb)->gso_segs, stopped);
 592         } else {
 593                 txq->head = start;
 594                 dev_kfree_skb_any(skb);
 595         }
 596         return NETDEV_TX_OK;
 597 }
 598
 599 static int be_change_mtu(struct net_device *netdev, int new_mtu)
 600 {
 601         struct be_adapter *adapter = netdev_priv(netdev);
 602         if (new_mtu < BE_MIN_MTU ||
 603                         new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
 604                                         (ETH_HLEN + ETH_FCS_LEN))) {
 605                 dev_info(&adapter->pdev->dev,
 606                         "MTU must be between %d and %d bytes\n",
 607                         BE_MIN_MTU,
 608                         (BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
 609                 return -EINVAL;
 610         }
 611         dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
 612                         netdev->mtu, new_mtu);
 613         netdev->mtu = new_mtu;
 614         return 0;
 615 }
 616
 617 /*
 618  * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
 619  * If the user configures more, place BE in vlan promiscuous mode.
 620  */
 621 static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
 622 {
 623         u16 vtag[BE_NUM_VLANS_SUPPORTED];
 624         u16 ntags = 0, i;
 625         int status = 0;
 626         u32 if_handle;
 627
 628         if (vf) {
 629                 if_handle = adapter->vf_cfg[vf_num].vf_if_handle;
 630                 vtag[0] = cpu_to_le16(adapter->vf_cfg[vf_num].vf_vlan_tag);
 631                 status = be_cmd_vlan_config(adapter, if_handle, vtag, 1, 1, 0);
 632         }
 633
 634         if (adapter->vlans_added <= adapter->max_vlans)  {
 635                 /* Construct VLAN Table to give to HW */
 636                 for (i = 0; i < VLAN_N_VID; i++) {
 637                         if (adapter->vlan_tag[i]) {
 638                                 vtag[ntags] = cpu_to_le16(i);
 639                                 ntags++;
 640                         }
 641                 }
 642                 status = be_cmd_vlan_config(adapter, adapter->if_handle,
 643                                         vtag, ntags, 1, 0);
 644         } else {
 645                 status = be_cmd_vlan_config(adapter, adapter->if_handle,
 646                                         NULL, 0, 1, 1);
 647         }
 648
 649         return status;
 650 }
 651
 652 static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp)
 653 {
 654         struct be_adapter *adapter = netdev_priv(netdev);
 655
 656         adapter->vlan_grp = grp;
 657 }
 658
 659 static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
 660 {
 661         struct be_adapter *adapter = netdev_priv(netdev);
 662
 663         adapter->vlans_added++;
 664         if (!be_physfn(adapter))
 665                 return;
 666
 667         adapter->vlan_tag[vid] = 1;
 668         if (adapter->vlans_added <= (adapter->max_vlans + 1))
 669                 be_vid_config(adapter, false, 0);
 670 }
 671
 672 static void be_vlan_rem_vid(struct net_device *netdev, u16 vid)
 673 {
 674         struct be_adapter *adapter = netdev_priv(netdev);
 675
 676         adapter->vlans_added--;
 677         vlan_group_set_device(adapter->vlan_grp, vid, NULL);
 678
 679         if (!be_physfn(adapter))
 680                 return;
 681
 682         adapter->vlan_tag[vid] = 0;
 683         if (adapter->vlans_added <= adapter->max_vlans)
 684                 be_vid_config(adapter, false, 0);
 685 }
 686
 687 static void be_set_multicast_list(struct net_device *netdev)
 688 {
 689         struct be_adapter *adapter = netdev_priv(netdev);
 690
 691         if (netdev->flags & IFF_PROMISC) {
 692                 be_cmd_promiscuous_config(adapter, adapter->port_num, 1);
 693                 adapter->promiscuous = true;
 694                 goto done;
 695         }
 696
 697         /* BE was previously in promiscous mode; disable it */
 698         if (adapter->promiscuous) {
 699                 adapter->promiscuous = false;
 700                 be_cmd_promiscuous_config(adapter, adapter->port_num, 0);
 701         }
 702
 703         /* Enable multicast promisc if num configured exceeds what we support */
 704         if (netdev->flags & IFF_ALLMULTI ||
 705             netdev_mc_count(netdev) > BE_MAX_MC) {
 706                 be_cmd_multicast_set(adapter, adapter->if_handle, NULL,
 707                                 &adapter->mc_cmd_mem);
 708                 goto done;
 709         }
 710
 711         be_cmd_multicast_set(adapter, adapter->if_handle, netdev,
 712                 &adapter->mc_cmd_mem);
 713 done:
 714         return;
 715 }
 716
 717 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
 718 {
 719         struct be_adapter *adapter = netdev_priv(netdev);
 720         int status;
 721
 722         if (!adapter->sriov_enabled)
 723                 return -EPERM;
 724
 725         if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
 726                 return -EINVAL;
 727
 728         if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
 729                 status = be_cmd_pmac_del(adapter,
 730                                         adapter->vf_cfg[vf].vf_if_handle,
 731                                         adapter->vf_cfg[vf].vf_pmac_id);
 732
 733         status = be_cmd_pmac_add(adapter, mac,
 734                                 adapter->vf_cfg[vf].vf_if_handle,
 735                                 &adapter->vf_cfg[vf].vf_pmac_id);
 736
 737         if (status)
 738                 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
 739                                 mac, vf);
 740         else
 741                 memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
 742
 743         return status;
 744 }
 745
 746 static int be_get_vf_config(struct net_device *netdev, int vf,
 747                         struct ifla_vf_info *vi)
 748 {
 749         struct be_adapter *adapter = netdev_priv(netdev);
 750
 751         if (!adapter->sriov_enabled)
 752                 return -EPERM;
 753
 754         if (vf >= num_vfs)
 755                 return -EINVAL;
 756
 757         vi->vf = vf;
 758         vi->tx_rate = adapter->vf_cfg[vf].vf_tx_rate;
 759         vi->vlan = adapter->vf_cfg[vf].vf_vlan_tag;
 760         vi->qos = 0;
 761         memcpy(&vi->mac, adapter->vf_cfg[vf].vf_mac_addr, ETH_ALEN);
 762
 763         return 0;
 764 }
 765
 766 static int be_set_vf_vlan(struct net_device *netdev,
 767                         int vf, u16 vlan, u8 qos)
 768 {
 769         struct be_adapter *adapter = netdev_priv(netdev);
 770         int status = 0;
 771
 772         if (!adapter->sriov_enabled)
 773                 return -EPERM;
 774
 775         if ((vf >= num_vfs) || (vlan > 4095))
 776                 return -EINVAL;
 777
 778         if (vlan) {
 779                 adapter->vf_cfg[vf].vf_vlan_tag = vlan;
 780                 adapter->vlans_added++;
 781         } else {
 782                 adapter->vf_cfg[vf].vf_vlan_tag = 0;
 783                 adapter->vlans_added--;
 784         }
 785
 786         status = be_vid_config(adapter, true, vf);
 787
 788         if (status)
 789                 dev_info(&adapter->pdev->dev,
 790                                 "VLAN %d config on VF %d failed\n", vlan, vf);
 791         return status;
 792 }
 793
 794 static int be_set_vf_tx_rate(struct net_device *netdev,
 795                         int vf, int rate)
 796 {
 797         struct be_adapter *adapter = netdev_priv(netdev);
 798         int status = 0;
 799
 800         if (!adapter->sriov_enabled)
 801                 return -EPERM;
 802
 803         if ((vf >= num_vfs) || (rate < 0))
 804                 return -EINVAL;
 805
 806         if (rate > 10000)
 807                 rate = 10000;
 808
 809         adapter->vf_cfg[vf].vf_tx_rate = rate;
 810         status = be_cmd_set_qos(adapter, rate / 10, vf);
 811
 812         if (status)
 813                 dev_info(&adapter->pdev->dev,
 814                                 "tx rate %d on VF %d failed\n", rate, vf);
 815         return status;
 816 }
 817
 818 static void be_rx_rate_update(struct be_rx_obj *rxo)
 819 {
 820         struct be_rx_stats *stats = &rxo->stats;
 821         ulong now = jiffies;
 822
 823         /* Wrapped around */
 824         if (time_before(now, stats->rx_jiffies)) {
 825                 stats->rx_jiffies = now;
 826                 return;
 827         }
 828
 829         /* Update the rate once in two seconds */
 830         if ((now - stats->rx_jiffies) < 2 * HZ)
 831                 return;
 832
 833         stats->rx_rate = be_calc_rate(stats->rx_bytes - stats->rx_bytes_prev,
 834                                 now - stats->rx_jiffies);
 835         stats->rx_jiffies = now;
 836         stats->rx_bytes_prev = stats->rx_bytes;
 837 }
 838
 839 static void be_rx_stats_update(struct be_rx_obj *rxo,
 840                 u32 pktsize, u16 numfrags, u8 pkt_type)
 841 {
 842         struct be_rx_stats *stats = &rxo->stats;
 843
 844         stats->rx_compl++;
 845         stats->rx_frags += numfrags;
 846         stats->rx_bytes += pktsize;
 847         stats->rx_pkts++;
 848         if (pkt_type == BE_MULTICAST_PACKET)
 849                 stats->rx_mcast_pkts++;
 850 }
 851
 852 static inline bool csum_passed(struct be_eth_rx_compl *rxcp)
 853 {
 854         u8 l4_cksm, ipv6, ipcksm;
 855
 856         l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp);
 857         ipcksm = AMAP_GET_BITS(struct amap_eth_rx_compl, ipcksm, rxcp);
 858         ipv6 = AMAP_GET_BITS(struct amap_eth_rx_compl, ip_version, rxcp);
 859
 860         /* Ignore ipcksm for ipv6 pkts */
 861         return l4_cksm && (ipcksm || ipv6);
 862 }
 863
 864 static struct be_rx_page_info *
 865 get_rx_page_info(struct be_adapter *adapter,
 866                 struct be_rx_obj *rxo,
 867                 u16 frag_idx)
 868 {
 869         struct be_rx_page_info *rx_page_info;
 870         struct be_queue_info *rxq = &rxo->q;
 871
 872         rx_page_info = &rxo->page_info_tbl[frag_idx];
 873         BUG_ON(!rx_page_info->page);
 874
 875         if (rx_page_info->last_page_user) {
 876                 pci_unmap_page(adapter->pdev, dma_unmap_addr(rx_page_info, bus),
 877                         adapter->big_page_size, PCI_DMA_FROMDEVICE);
 878                 rx_page_info->last_page_user = false;
 879         }
 880
 881         atomic_dec(&rxq->used);
 882         return rx_page_info;
 883 }
 884
 885 /* Throwaway the data in the Rx completion */
 886 static void be_rx_compl_discard(struct be_adapter *adapter,
 887                 struct be_rx_obj *rxo,
 888                 struct be_eth_rx_compl *rxcp)
 889 {
 890         struct be_queue_info *rxq = &rxo->q;
 891         struct be_rx_page_info *page_info;
 892         u16 rxq_idx, i, num_rcvd;
 893
 894         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
 895         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
 896
 897         for (i = 0; i < num_rcvd; i++) {
 898                 page_info = get_rx_page_info(adapter, rxo, rxq_idx);
 899                 put_page(page_info->page);
 900                 memset(page_info, 0, sizeof(*page_info));
 901                 index_inc(&rxq_idx, rxq->len);
 902         }
 903 }
 904
 905 /*
 906  * skb_fill_rx_data forms a complete skb for an ether frame
 907  * indicated by rxcp.
 908  */
 909 static void skb_fill_rx_data(struct be_adapter *adapter, struct be_rx_obj *rxo,
 910                         struct sk_buff *skb, struct be_eth_rx_compl *rxcp,
 911                         u16 num_rcvd)
 912 {
 913         struct be_queue_info *rxq = &rxo->q;
 914         struct be_rx_page_info *page_info;
 915         u16 rxq_idx, i, j;
 916         u32 pktsize, hdr_len, curr_frag_len, size;
 917         u8 *start;
 918         u8 pkt_type;
 919
 920         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
 921         pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
 922         pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
 923
 924         page_info = get_rx_page_info(adapter, rxo, rxq_idx);
 925
 926         start = page_address(page_info->page) + page_info->page_offset;
 927         prefetch(start);
 928
 929         /* Copy data in the first descriptor of this completion */
 930         curr_frag_len = min(pktsize, rx_frag_size);
 931
 932         /* Copy the header portion into skb_data */
 933         hdr_len = min((u32)BE_HDR_LEN, curr_frag_len);
 934         memcpy(skb->data, start, hdr_len);
 935         skb->len = curr_frag_len;
 936         if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
 937                 /* Complete packet has now been moved to data */
 938                 put_page(page_info->page);
 939                 skb->data_len = 0;
 940                 skb->tail += curr_frag_len;
 941         } else {
 942                 skb_shinfo(skb)->nr_frags = 1;
 943                 skb_shinfo(skb)->frags[0].page = page_info->page;
 944                 skb_shinfo(skb)->frags[0].page_offset =
 945                                         page_info->page_offset + hdr_len;
 946                 skb_shinfo(skb)->frags[0].size = curr_frag_len - hdr_len;
 947                 skb->data_len = curr_frag_len - hdr_len;
 948                 skb->tail += hdr_len;
 949         }
 950         page_info->page = NULL;
 951
 952         if (pktsize <= rx_frag_size) {
 953                 BUG_ON(num_rcvd != 1);
 954                 goto done;
 955         }
 956
 957         /* More frags present for this completion */
 958         size = pktsize;
 959         for (i = 1, j = 0; i < num_rcvd; i++) {
 960                 size -= curr_frag_len;
 961                 index_inc(&rxq_idx, rxq->len);
 962                 page_info = get_rx_page_info(adapter, rxo, rxq_idx);
 963
 964                 curr_frag_len = min(size, rx_frag_size);
 965
 966                 /* Coalesce all frags from the same physical page in one slot */
 967                 if (page_info->page_offset == 0) {
 968                         /* Fresh page */
 969                         j++;
 970                         skb_shinfo(skb)->frags[j].page = page_info->page;
 971                         skb_shinfo(skb)->frags[j].page_offset =
 972                                                         page_info->page_offset;
 973                         skb_shinfo(skb)->frags[j].size = 0;
 974                         skb_shinfo(skb)->nr_frags++;
 975                 } else {
 976                         put_page(page_info->page);
 977                 }
 978
 979                 skb_shinfo(skb)->frags[j].size += curr_frag_len;
 980                 skb->len += curr_frag_len;
 981                 skb->data_len += curr_frag_len;
 982
 983                 page_info->page = NULL;
 984         }
 985         BUG_ON(j > MAX_SKB_FRAGS);
 986
 987 done:
 988         be_rx_stats_update(rxo, pktsize, num_rcvd, pkt_type);
 989 }
 990
 991 /* Process the RX completion indicated by rxcp when GRO is disabled */
 992 static void be_rx_compl_process(struct be_adapter *adapter,
 993                         struct be_rx_obj *rxo,
 994                         struct be_eth_rx_compl *rxcp)
 995 {
 996         struct sk_buff *skb;
 997         u32 vlanf, vid;
 998         u16 num_rcvd;
 999         u8 vtm;
1000
1001         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
1002         /* Is it a flush compl that has no data */
1003         if (unlikely(num_rcvd == 0))
1004                 return;
1005
1006         skb = netdev_alloc_skb_ip_align(adapter->netdev, BE_HDR_LEN);
1007         if (unlikely(!skb)) {
1008                 if (net_ratelimit())
1009                         dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
1010                 be_rx_compl_discard(adapter, rxo, rxcp);
1011                 return;
1012         }
1013
1014         skb_fill_rx_data(adapter, rxo, skb, rxcp, num_rcvd);
1015
1016         if (likely(adapter->rx_csum && csum_passed(rxcp)))
1017                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1018         else
1019                 skb_checksum_none_assert(skb);
1020
1021         skb->truesize = skb->len + sizeof(struct sk_buff);
1022         skb->protocol = eth_type_trans(skb, adapter->netdev);
1023
1024         vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1025         vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1026
1027         /* vlanf could be wrongly set in some cards.
1028          * ignore if vtm is not set */
1029         if ((adapter->function_mode & 0x400) && !vtm)
1030                 vlanf = 0;
1031
1032         if (unlikely(vlanf)) {
1033                 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
1034                         kfree_skb(skb);
1035                         return;
1036                 }
1037                 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
1038                 vid = swab16(vid);
1039                 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp, vid);
1040         } else {
1041                 netif_receive_skb(skb);
1042         }
1043 }
1044
1045 /* Process the RX completion indicated by rxcp when GRO is enabled */
1046 static void be_rx_compl_process_gro(struct be_adapter *adapter,
1047                 struct be_rx_obj *rxo,
1048                 struct be_eth_rx_compl *rxcp)
1049 {
1050         struct be_rx_page_info *page_info;
1051         struct sk_buff *skb = NULL;
1052         struct be_queue_info *rxq = &rxo->q;
1053         struct be_eq_obj *eq_obj =  &rxo->rx_eq;
1054         u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
1055         u16 i, rxq_idx = 0, vid, j;
1056         u8 vtm;
1057         u8 pkt_type;
1058
1059         num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
1060         /* Is it a flush compl that has no data */
1061         if (unlikely(num_rcvd == 0))
1062                 return;
1063
1064         pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
1065         vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1066         rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
1067         vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1068         pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
1069
1070         /* vlanf could be wrongly set in some cards.
1071          * ignore if vtm is not set */
1072         if ((adapter->function_mode & 0x400) && !vtm)
1073                 vlanf = 0;
1074
1075         skb = napi_get_frags(&eq_obj->napi);
1076         if (!skb) {
1077                 be_rx_compl_discard(adapter, rxo, rxcp);
1078                 return;
1079         }
1080
1081         remaining = pkt_size;
1082         for (i = 0, j = -1; i < num_rcvd; i++) {
1083                 page_info = get_rx_page_info(adapter, rxo, rxq_idx);
1084
1085                 curr_frag_len = min(remaining, rx_frag_size);
1086
1087                 /* Coalesce all frags from the same physical page in one slot */
1088                 if (i == 0 || page_info->page_offset == 0) {
1089                         /* First frag or Fresh page */
1090                         j++;
1091                         skb_shinfo(skb)->frags[j].page = page_info->page;
1092                         skb_shinfo(skb)->frags[j].page_offset =
1093                                                         page_info->page_offset;
1094                         skb_shinfo(skb)->frags[j].size = 0;
1095                 } else {
1096                         put_page(page_info->page);
1097                 }
1098                 skb_shinfo(skb)->frags[j].size += curr_frag_len;
1099
1100                 remaining -= curr_frag_len;
1101                 index_inc(&rxq_idx, rxq->len);
1102                 memset(page_info, 0, sizeof(*page_info));
1103         }
1104         BUG_ON(j > MAX_SKB_FRAGS);
1105
1106         skb_shinfo(skb)->nr_frags = j + 1;
1107         skb->len = pkt_size;
1108         skb->data_len = pkt_size;
1109         skb->truesize += pkt_size;
1110         skb->ip_summed = CHECKSUM_UNNECESSARY;
1111
1112         if (likely(!vlanf)) {
1113                 napi_gro_frags(&eq_obj->napi);
1114         } else {
1115                 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
1116                 vid = swab16(vid);
1117
1118                 if (!adapter->vlan_grp || adapter->vlans_added == 0)
1119                         return;
1120
1121                 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, vid);
1122         }
1123
1124         be_rx_stats_update(rxo, pkt_size, num_rcvd, pkt_type);
1125 }
1126
1127 static struct be_eth_rx_compl *be_rx_compl_get(struct be_rx_obj *rxo)
1128 {
1129         struct be_eth_rx_compl *rxcp = queue_tail_node(&rxo->cq);
1130
1131         if (rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] == 0)
1132                 return NULL;
1133
1134         rmb();
1135         be_dws_le_to_cpu(rxcp, sizeof(*rxcp));
1136
1137         queue_tail_inc(&rxo->cq);
1138         return rxcp;
1139 }
1140
1141 /* To reset the valid bit, we need to reset the whole word as
1142  * when walking the queue the valid entries are little-endian
1143  * and invalid entries are host endian
1144  */
1145 static inline void be_rx_compl_reset(struct be_eth_rx_compl *rxcp)
1146 {
1147         rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] = 0;
1148 }
1149
1150 static inline struct page *be_alloc_pages(u32 size)
1151 {
1152         gfp_t alloc_flags = GFP_ATOMIC;
1153         u32 order = get_order(size);
1154         if (order > 0)
1155                 alloc_flags |= __GFP_COMP;
1156         return  alloc_pages(alloc_flags, order);
1157 }
1158
1159 /*
1160  * Allocate a page, split it to fragments of size rx_frag_size and post as
1161  * receive buffers to BE
1162  */
1163 static void be_post_rx_frags(struct be_rx_obj *rxo)
1164 {
1165         struct be_adapter *adapter = rxo->adapter;
1166         struct be_rx_page_info *page_info_tbl = rxo->page_info_tbl;
1167         struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1168         struct be_queue_info *rxq = &rxo->q;
1169         struct page *pagep = NULL;
1170         struct be_eth_rx_d *rxd;
1171         u64 page_dmaaddr = 0, frag_dmaaddr;
1172         u32 posted, page_offset = 0;
1173
1174         page_info = &rxo->page_info_tbl[rxq->head];
1175         for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1176                 if (!pagep) {
1177                         pagep = be_alloc_pages(adapter->big_page_size);
1178                         if (unlikely(!pagep)) {
1179                                 rxo->stats.rx_post_fail++;
1180                                 break;
1181                         }
1182                         page_dmaaddr = pci_map_page(adapter->pdev, pagep, 0,
1183                                                 adapter->big_page_size,
1184                                                 PCI_DMA_FROMDEVICE);
1185                         page_info->page_offset = 0;
1186                 } else {
1187                         get_page(pagep);
1188                         page_info->page_offset = page_offset + rx_frag_size;
1189                 }
1190                 page_offset = page_info->page_offset;
1191                 page_info->page = pagep;
1192                 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
1193                 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
1194
1195                 rxd = queue_head_node(rxq);
1196                 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
1197                 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
1198
1199                 /* Any space left in the current big page for another frag? */
1200                 if ((page_offset + rx_frag_size + rx_frag_size) >
1201                                         adapter->big_page_size) {
1202                         pagep = NULL;
1203                         page_info->last_page_user = true;
1204                 }
1205
1206                 prev_page_info = page_info;
1207                 queue_head_inc(rxq);
1208                 page_info = &page_info_tbl[rxq->head];
1209         }
1210         if (pagep)
1211                 prev_page_info->last_page_user = true;
1212
1213         if (posted) {
1214                 atomic_add(posted, &rxq->used);
1215                 be_rxq_notify(adapter, rxq->id, posted);
1216         } else if (atomic_read(&rxq->used) == 0) {
1217                 /* Let be_worker replenish when memory is available */
1218                 rxo->rx_post_starved = true;
1219         }
1220 }
1221
1222 static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
1223 {
1224         struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
1225
1226         if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
1227                 return NULL;
1228
1229         rmb();
1230         be_dws_le_to_cpu(txcp, sizeof(*txcp));
1231
1232         txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
1233
1234         queue_tail_inc(tx_cq);
1235         return txcp;
1236 }
1237
1238 static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
1239 {
1240         struct be_queue_info *txq = &adapter->tx_obj.q;
1241         struct be_eth_wrb *wrb;
1242         struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1243         struct sk_buff *sent_skb;
1244         u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
1245         bool unmap_skb_hdr = true;
1246
1247         sent_skb = sent_skbs[txq->tail];
1248         BUG_ON(!sent_skb);
1249         sent_skbs[txq->tail] = NULL;
1250
1251         /* skip header wrb */
1252         queue_tail_inc(txq);
1253
1254         do {
1255                 cur_index = txq->tail;
1256                 wrb = queue_tail_node(txq);
1257                 unmap_tx_frag(adapter->pdev, wrb, (unmap_skb_hdr &&
1258                                         skb_headlen(sent_skb)));
1259                 unmap_skb_hdr = false;
1260
1261                 num_wrbs++;
1262                 queue_tail_inc(txq);
1263         } while (cur_index != last_index);
1264
1265         atomic_sub(num_wrbs, &txq->used);
1266
1267         kfree_skb(sent_skb);
1268 }
1269
1270 static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj)
1271 {
1272         struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
1273
1274         if (!eqe->evt)
1275                 return NULL;
1276
1277         rmb();
1278         eqe->evt = le32_to_cpu(eqe->evt);
1279         queue_tail_inc(&eq_obj->q);
1280         return eqe;
1281 }
1282
1283 static int event_handle(struct be_adapter *adapter,
1284                         struct be_eq_obj *eq_obj)
1285 {
1286         struct be_eq_entry *eqe;
1287         u16 num = 0;
1288
1289         while ((eqe = event_get(eq_obj)) != NULL) {
1290                 eqe->evt = 0;
1291                 num++;
1292         }
1293
1294         /* Deal with any spurious interrupts that come
1295          * without events
1296          */
1297         be_eq_notify(adapter, eq_obj->q.id, true, true, num);
1298         if (num)
1299                 napi_schedule(&eq_obj->napi);
1300
1301         return num;
1302 }
1303
1304 /* Just read and notify events without processing them.
1305  * Used at the time of destroying event queues */
1306 static void be_eq_clean(struct be_adapter *adapter,
1307                         struct be_eq_obj *eq_obj)
1308 {
1309         struct be_eq_entry *eqe;
1310         u16 num = 0;
1311
1312         while ((eqe = event_get(eq_obj)) != NULL) {
1313                 eqe->evt = 0;
1314                 num++;
1315         }
1316
1317         if (num)
1318                 be_eq_notify(adapter, eq_obj->q.id, false, true, num);
1319 }
1320
1321 static void be_rx_q_clean(struct be_adapter *adapter, struct be_rx_obj *rxo)
1322 {
1323         struct be_rx_page_info *page_info;
1324         struct be_queue_info *rxq = &rxo->q;
1325         struct be_queue_info *rx_cq = &rxo->cq;
1326         struct be_eth_rx_compl *rxcp;
1327         u16 tail;
1328
1329         /* First cleanup pending rx completions */
1330         while ((rxcp = be_rx_compl_get(rxo)) != NULL) {
1331                 be_rx_compl_discard(adapter, rxo, rxcp);
1332                 be_rx_compl_reset(rxcp);
1333                 be_cq_notify(adapter, rx_cq->id, true, 1);
1334         }
1335
1336         /* Then free posted rx buffer that were not used */
1337         tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1338         for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1339                 page_info = get_rx_page_info(adapter, rxo, tail);
1340                 put_page(page_info->page);
1341                 memset(page_info, 0, sizeof(*page_info));
1342         }
1343         BUG_ON(atomic_read(&rxq->used));
1344 }
1345
1346 static void be_tx_compl_clean(struct be_adapter *adapter)
1347 {
1348         struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1349         struct be_queue_info *txq = &adapter->tx_obj.q;
1350         struct be_eth_tx_compl *txcp;
1351         u16 end_idx, cmpl = 0, timeo = 0;
1352         struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1353         struct sk_buff *sent_skb;
1354         bool dummy_wrb;
1355
1356         /* Wait for a max of 200ms for all the tx-completions to arrive. */
1357         do {
1358                 while ((txcp = be_tx_compl_get(tx_cq))) {
1359                         end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1360                                         wrb_index, txcp);
1361                         be_tx_compl_process(adapter, end_idx);
1362                         cmpl++;
1363                 }
1364                 if (cmpl) {
1365                         be_cq_notify(adapter, tx_cq->id, false, cmpl);
1366                         cmpl = 0;
1367                 }
1368
1369                 if (atomic_read(&txq->used) == 0 || ++timeo > 200)
1370                         break;
1371
1372                 mdelay(1);
1373         } while (true);
1374
1375         if (atomic_read(&txq->used))
1376                 dev_err(&adapter->pdev->dev, "%d pending tx-completions\n",
1377                         atomic_read(&txq->used));
1378
1379         /* free posted tx for which compls will never arrive */
1380         while (atomic_read(&txq->used)) {
1381                 sent_skb = sent_skbs[txq->tail];
1382                 end_idx = txq->tail;
1383                 index_adv(&end_idx,
1384                         wrb_cnt_for_skb(sent_skb, &dummy_wrb) - 1, txq->len);
1385                 be_tx_compl_process(adapter, end_idx);
1386         }
1387 }
1388
1389 static void be_mcc_queues_destroy(struct be_adapter *adapter)
1390 {
1391         struct be_queue_info *q;
1392
1393         q = &adapter->mcc_obj.q;
1394         if (q->created)
1395                 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1396         be_queue_free(adapter, q);
1397
1398         q = &adapter->mcc_obj.cq;
1399         if (q->created)
1400                 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1401         be_queue_free(adapter, q);
1402 }
1403
1404 /* Must be called only after TX qs are created as MCC shares TX EQ */
1405 static int be_mcc_queues_create(struct be_adapter *adapter)
1406 {
1407         struct be_queue_info *q, *cq;
1408
1409         /* Alloc MCC compl queue */
1410         cq = &adapter->mcc_obj.cq;
1411         if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1412                         sizeof(struct be_mcc_compl)))
1413                 goto err;
1414
1415         /* Ask BE to create MCC compl queue; share TX's eq */
1416         if (be_cmd_cq_create(adapter, cq, &adapter->tx_eq.q, false, true, 0))
1417                 goto mcc_cq_free;
1418
1419         /* Alloc MCC queue */
1420         q = &adapter->mcc_obj.q;
1421         if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1422                 goto mcc_cq_destroy;
1423
1424         /* Ask BE to create MCC queue */
1425         if (be_cmd_mccq_create(adapter, q, cq))
1426                 goto mcc_q_free;
1427
1428         return 0;
1429
1430 mcc_q_free:
1431         be_queue_free(adapter, q);
1432 mcc_cq_destroy:
1433         be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1434 mcc_cq_free:
1435         be_queue_free(adapter, cq);
1436 err:
1437         return -1;
1438 }
1439
1440 static void be_tx_queues_destroy(struct be_adapter *adapter)
1441 {
1442         struct be_queue_info *q;
1443
1444         q = &adapter->tx_obj.q;
1445         if (q->created)
1446                 be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
1447         be_queue_free(adapter, q);
1448
1449         q = &adapter->tx_obj.cq;
1450         if (q->created)
1451                 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1452         be_queue_free(adapter, q);
1453
1454         /* Clear any residual events */
1455         be_eq_clean(adapter, &adapter->tx_eq);
1456
1457         q = &adapter->tx_eq.q;
1458         if (q->created)
1459                 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
1460         be_queue_free(adapter, q);
1461 }
1462
1463 static int be_tx_queues_create(struct be_adapter *adapter)
1464 {
1465         struct be_queue_info *eq, *q, *cq;
1466
1467         adapter->tx_eq.max_eqd = 0;
1468         adapter->tx_eq.min_eqd = 0;
1469         adapter->tx_eq.cur_eqd = 96;
1470         adapter->tx_eq.enable_aic = false;
1471         /* Alloc Tx Event queue */
1472         eq = &adapter->tx_eq.q;
1473         if (be_queue_alloc(adapter, eq, EVNT_Q_LEN, sizeof(struct be_eq_entry)))
1474                 return -1;
1475
1476         /* Ask BE to create Tx Event queue */
1477         if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd))
1478                 goto tx_eq_free;
1479         adapter->base_eq_id = adapter->tx_eq.q.id;
1480
1481         /* Alloc TX eth compl queue */
1482         cq = &adapter->tx_obj.cq;
1483         if (be_queue_alloc(adapter, cq, TX_CQ_LEN,
1484                         sizeof(struct be_eth_tx_compl)))
1485                 goto tx_eq_destroy;
1486
1487         /* Ask BE to create Tx eth compl queue */
1488         if (be_cmd_cq_create(adapter, cq, eq, false, false, 3))
1489                 goto tx_cq_free;
1490
1491         /* Alloc TX eth queue */
1492         q = &adapter->tx_obj.q;
1493         if (be_queue_alloc(adapter, q, TX_Q_LEN, sizeof(struct be_eth_wrb)))
1494                 goto tx_cq_destroy;
1495
1496         /* Ask BE to create Tx eth queue */
1497         if (be_cmd_txq_create(adapter, q, cq))
1498                 goto tx_q_free;
1499         return 0;
1500
1501 tx_q_free:
1502         be_queue_free(adapter, q);
1503 tx_cq_destroy:
1504         be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1505 tx_cq_free:
1506         be_queue_free(adapter, cq);
1507 tx_eq_destroy:
1508         be_cmd_q_destroy(adapter, eq, QTYPE_EQ);
1509 tx_eq_free:
1510         be_queue_free(adapter, eq);
1511         return -1;
1512 }
1513
1514 static void be_rx_queues_destroy(struct be_adapter *adapter)
1515 {
1516         struct be_queue_info *q;
1517         struct be_rx_obj *rxo;
1518         int i;
1519
1520         for_all_rx_queues(adapter, rxo, i) {
1521                 q = &rxo->q;
1522                 if (q->created) {
1523                         be_cmd_q_destroy(adapter, q, QTYPE_RXQ);
1524                         /* After the rxq is invalidated, wait for a grace time
1525                          * of 1ms for all dma to end and the flush compl to
1526                          * arrive
1527                          */
1528                         mdelay(1);
1529                         be_rx_q_clean(adapter, rxo);
1530                 }
1531                 be_queue_free(adapter, q);
1532
1533                 q = &rxo->cq;
1534                 if (q->created)
1535                         be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1536                 be_queue_free(adapter, q);
1537
1538                 /* Clear any residual events */
1539                 q = &rxo->rx_eq.q;
1540                 if (q->created) {
1541                         be_eq_clean(adapter, &rxo->rx_eq);
1542                         be_cmd_q_destroy(adapter, q, QTYPE_EQ);
1543                 }
1544                 be_queue_free(adapter, q);
1545         }
1546 }
1547
1548 static int be_rx_queues_create(struct be_adapter *adapter)
1549 {
1550         struct be_queue_info *eq, *q, *cq;
1551         struct be_rx_obj *rxo;
1552         int rc, i;
1553
1554         adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1555         for_all_rx_queues(adapter, rxo, i) {
1556                 rxo->adapter = adapter;
1557                 rxo->rx_eq.max_eqd = BE_MAX_EQD;
1558                 rxo->rx_eq.enable_aic = true;
1559
1560                 /* EQ */
1561                 eq = &rxo->rx_eq.q;
1562                 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1563                                         sizeof(struct be_eq_entry));
1564                 if (rc)
1565                         goto err;
1566
1567                 rc = be_cmd_eq_create(adapter, eq, rxo->rx_eq.cur_eqd);
1568                 if (rc)
1569                         goto err;
1570
1571                 /* CQ */
1572                 cq = &rxo->cq;
1573                 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
1574                                 sizeof(struct be_eth_rx_compl));
1575                 if (rc)
1576                         goto err;
1577
1578                 rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3);
1579                 if (rc)
1580                         goto err;
1581
1582                 /* Rx Q */
1583                 q = &rxo->q;
1584                 rc = be_queue_alloc(adapter, q, RX_Q_LEN,
1585                                 sizeof(struct be_eth_rx_d));
1586                 if (rc)
1587                         goto err;
1588
1589                 rc = be_cmd_rxq_create(adapter, q, cq->id, rx_frag_size,
1590                         BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle,
1591                         (i > 0) ? 1 : 0/* rss enable */, &rxo->rss_id);
1592                 if (rc)
1593                         goto err;
1594         }
1595
1596         if (be_multi_rxq(adapter)) {
1597                 u8 rsstable[MAX_RSS_QS];
1598
1599                 for_all_rss_queues(adapter, rxo, i)
1600                         rsstable[i] = rxo->rss_id;
1601
1602                 rc = be_cmd_rss_config(adapter, rsstable,
1603                         adapter->num_rx_qs - 1);
1604                 if (rc)
1605                         goto err;
1606         }
1607
1608         return 0;
1609 err:
1610         be_rx_queues_destroy(adapter);
1611         return -1;
1612 }
1613
1614 /* There are 8 evt ids per func. Retruns the evt id's bit number */
1615 static inline int be_evt_bit_get(struct be_adapter *adapter, u32 eq_id)
1616 {
1617         return eq_id - adapter->base_eq_id;
1618 }
1619
1620 static irqreturn_t be_intx(int irq, void *dev)
1621 {
1622         struct be_adapter *adapter = dev;
1623         struct be_rx_obj *rxo;
1624         int isr, i;
1625
1626         isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
1627                 (adapter->tx_eq.q.id/ 8) * CEV_ISR_SIZE);
1628         if (!isr)
1629                 return IRQ_NONE;
1630
1631         if ((1 << be_evt_bit_get(adapter, adapter->tx_eq.q.id) & isr))
1632                 event_handle(adapter, &adapter->tx_eq);
1633
1634         for_all_rx_queues(adapter, rxo, i) {
1635                 if ((1 << be_evt_bit_get(adapter, rxo->rx_eq.q.id) & isr))
1636                         event_handle(adapter, &rxo->rx_eq);
1637         }
1638
1639         return IRQ_HANDLED;
1640 }
1641
1642 static irqreturn_t be_msix_rx(int irq, void *dev)
1643 {
1644         struct be_rx_obj *rxo = dev;
1645         struct be_adapter *adapter = rxo->adapter;
1646
1647         event_handle(adapter, &rxo->rx_eq);
1648
1649         return IRQ_HANDLED;
1650 }
1651
1652 static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
1653 {
1654         struct be_adapter *adapter = dev;
1655
1656         event_handle(adapter, &adapter->tx_eq);
1657
1658         return IRQ_HANDLED;
1659 }
1660
1661 static inline bool do_gro(struct be_adapter *adapter, struct be_rx_obj *rxo,
1662                         struct be_eth_rx_compl *rxcp)
1663 {
1664         int err = AMAP_GET_BITS(struct amap_eth_rx_compl, err, rxcp);
1665         int tcp_frame = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
1666
1667         if (err)
1668                 rxo->stats.rxcp_err++;
1669
1670         return (tcp_frame && !err) ? true : false;
1671 }
1672
1673 static int be_poll_rx(struct napi_struct *napi, int budget)
1674 {
1675         struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1676         struct be_rx_obj *rxo = container_of(rx_eq, struct be_rx_obj, rx_eq);
1677         struct be_adapter *adapter = rxo->adapter;
1678         struct be_queue_info *rx_cq = &rxo->cq;
1679         struct be_eth_rx_compl *rxcp;
1680         u32 work_done;
1681
1682         rxo->stats.rx_polls++;
1683         for (work_done = 0; work_done < budget; work_done++) {
1684                 rxcp = be_rx_compl_get(rxo);
1685                 if (!rxcp)
1686                         break;
1687
1688                 if (do_gro(adapter, rxo, rxcp))
1689                         be_rx_compl_process_gro(adapter, rxo, rxcp);
1690                 else
1691                         be_rx_compl_process(adapter, rxo, rxcp);
1692
1693                 be_rx_compl_reset(rxcp);
1694         }
1695
1696         /* Refill the queue */
1697         if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
1698                 be_post_rx_frags(rxo);
1699
1700         /* All consumed */
1701         if (work_done < budget) {
1702                 napi_complete(napi);
1703                 be_cq_notify(adapter, rx_cq->id, true, work_done);
1704         } else {
1705                 /* More to be consumed; continue with interrupts disabled */
1706                 be_cq_notify(adapter, rx_cq->id, false, work_done);
1707         }
1708         return work_done;
1709 }
1710
1711 /* As TX and MCC share the same EQ check for both TX and MCC completions.
1712  * For TX/MCC we don't honour budget; consume everything
1713  */
1714 static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1715 {
1716         struct be_eq_obj *tx_eq = container_of(napi, struct be_eq_obj, napi);
1717         struct be_adapter *adapter =
1718                 container_of(tx_eq, struct be_adapter, tx_eq);
1719         struct be_queue_info *txq = &adapter->tx_obj.q;
1720         struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1721         struct be_eth_tx_compl *txcp;
1722         int tx_compl = 0, mcc_compl, status = 0;
1723         u16 end_idx;
1724
1725         while ((txcp = be_tx_compl_get(tx_cq))) {
1726                 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1727                                 wrb_index, txcp);
1728                 be_tx_compl_process(adapter, end_idx);
1729                 tx_compl++;
1730         }
1731
1732         mcc_compl = be_process_mcc(adapter, &status);
1733
1734         napi_complete(napi);
1735
1736         if (mcc_compl) {
1737                 struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
1738                 be_cq_notify(adapter, mcc_obj->cq.id, true, mcc_compl);
1739         }
1740
1741         if (tx_compl) {
1742                 be_cq_notify(adapter, adapter->tx_obj.cq.id, true, tx_compl);
1743
1744                 /* As Tx wrbs have been freed up, wake up netdev queue if
1745                  * it was stopped due to lack of tx wrbs.
1746                  */
1747                 if (netif_queue_stopped(adapter->netdev) &&
1748                         atomic_read(&txq->used) < txq->len / 2) {
1749                         netif_wake_queue(adapter->netdev);
1750                 }
1751
1752                 tx_stats(adapter)->be_tx_events++;
1753                 tx_stats(adapter)->be_tx_compl += tx_compl;
1754         }
1755
1756         return 1;
1757 }
1758
1759 void be_detect_dump_ue(struct be_adapter *adapter)
1760 {
1761         u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
1762         u32 i;
1763
1764         pci_read_config_dword(adapter->pdev,
1765                                 PCICFG_UE_STATUS_LOW, &ue_status_lo);
1766         pci_read_config_dword(adapter->pdev,
1767                                 PCICFG_UE_STATUS_HIGH, &ue_status_hi);
1768         pci_read_config_dword(adapter->pdev,
1769                                 PCICFG_UE_STATUS_LOW_MASK, &ue_status_lo_mask);
1770         pci_read_config_dword(adapter->pdev,
1771                                 PCICFG_UE_STATUS_HI_MASK, &ue_status_hi_mask);
1772
1773         ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
1774         ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));
1775
1776         if (ue_status_lo || ue_status_hi) {
1777                 adapter->ue_detected = true;
1778                 dev_err(&adapter->pdev->dev, "UE Detected!!\n");
1779         }
1780
1781         if (ue_status_lo) {
1782                 for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
1783                         if (ue_status_lo & 1)
1784                                 dev_err(&adapter->pdev->dev,
1785                                 "UE: %s bit set\n", ue_status_low_desc[i]);
1786                 }
1787         }
1788         if (ue_status_hi) {
1789                 for (i = 0; ue_status_hi; ue_status_hi >>= 1, i++) {
1790                         if (ue_status_hi & 1)
1791                                 dev_err(&adapter->pdev->dev,
1792                                 "UE: %s bit set\n", ue_status_hi_desc[i]);
1793                 }
1794         }
1795
1796 }
1797
1798 static void be_worker(struct work_struct *work)
1799 {
1800         struct be_adapter *adapter =
1801                 container_of(work, struct be_adapter, work.work);
1802         struct be_rx_obj *rxo;
1803         int i;
1804
1805         /* when interrupts are not yet enabled, just reap any pending
1806         * mcc completions */
1807         if (!netif_running(adapter->netdev)) {
1808                 int mcc_compl, status = 0;
1809
1810                 mcc_compl = be_process_mcc(adapter, &status);
1811
1812                 if (mcc_compl) {
1813                         struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
1814                         be_cq_notify(adapter, mcc_obj->cq.id, false, mcc_compl);
1815                 }
1816                 goto reschedule;
1817         }
1818
1819         if (!adapter->stats_ioctl_sent)
1820                 be_cmd_get_stats(adapter, &adapter->stats_cmd);
1821
1822         be_tx_rate_update(adapter);
1823
1824         for_all_rx_queues(adapter, rxo, i) {
1825                 be_rx_rate_update(rxo);
1826                 be_rx_eqd_update(adapter, rxo);
1827
1828                 if (rxo->rx_post_starved) {
1829                         rxo->rx_post_starved = false;
1830                         be_post_rx_frags(rxo);
1831                 }
1832         }
1833
1834         if (!adapter->ue_detected)
1835                 be_detect_dump_ue(adapter);
1836
1837 reschedule:
1838         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
1839 }
1840
1841 static void be_msix_disable(struct be_adapter *adapter)
1842 {
1843         if (adapter->msix_enabled) {
1844                 pci_disable_msix(adapter->pdev);
1845                 adapter->msix_enabled = false;
1846         }
1847 }
1848
1849 static int be_num_rxqs_get(struct be_adapter *adapter)
1850 {
1851         if (multi_rxq && (adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
1852                 !adapter->sriov_enabled && !(adapter->function_mode & 0x400)) {
1853                 return 1 + MAX_RSS_QS; /* one default non-RSS queue */
1854         } else {
1855                 dev_warn(&adapter->pdev->dev,
1856                         "No support for multiple RX queues\n");
1857                 return 1;
1858         }
1859 }
1860
1861 static void be_msix_enable(struct be_adapter *adapter)
1862 {
1863 #define BE_MIN_MSIX_VECTORS     (1 + 1) /* Rx + Tx */
1864         int i, status;
1865
1866         adapter->num_rx_qs = be_num_rxqs_get(adapter);
1867
1868         for (i = 0; i < (adapter->num_rx_qs + 1); i++)
1869                 adapter->msix_entries[i].entry = i;
1870
1871         status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
1872                         adapter->num_rx_qs + 1);
1873         if (status == 0) {
1874                 goto done;
1875         } else if (status >= BE_MIN_MSIX_VECTORS) {
1876                 if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
1877                                 status) == 0) {
1878                         adapter->num_rx_qs = status - 1;
1879                         dev_warn(&adapter->pdev->dev,
1880                                 "Could alloc only %d MSIx vectors. "
1881                                 "Using %d RX Qs\n", status, adapter->num_rx_qs);
1882                         goto done;
1883                 }
1884         }
1885         return;
1886 done:
1887         adapter->msix_enabled = true;
1888 }
1889
1890 static void be_sriov_enable(struct be_adapter *adapter)
1891 {
1892         be_check_sriov_fn_type(adapter);
1893 #ifdef CONFIG_PCI_IOV
1894         if (be_physfn(adapter) && num_vfs) {
1895                 int status;
1896
1897                 status = pci_enable_sriov(adapter->pdev, num_vfs);
1898                 adapter->sriov_enabled = status ? false : true;
1899         }
1900 #endif
1901 }
1902
1903 static void be_sriov_disable(struct be_adapter *adapter)
1904 {
1905 #ifdef CONFIG_PCI_IOV
1906         if (adapter->sriov_enabled) {
1907                 pci_disable_sriov(adapter->pdev);
1908                 adapter->sriov_enabled = false;
1909         }
1910 #endif
1911 }
1912
1913 static inline int be_msix_vec_get(struct be_adapter *adapter, u32 eq_id)
1914 {
1915         return adapter->msix_entries[
1916                         be_evt_bit_get(adapter, eq_id)].vector;
1917 }
1918
1919 static int be_request_irq(struct be_adapter *adapter,
1920                 struct be_eq_obj *eq_obj,
1921                 void *handler, char *desc, void *context)
1922 {
1923         struct net_device *netdev = adapter->netdev;
1924         int vec;
1925
1926         sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
1927         vec = be_msix_vec_get(adapter, eq_obj->q.id);
1928         return request_irq(vec, handler, 0, eq_obj->desc, context);
1929 }
1930
1931 static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj,
1932                         void *context)
1933 {
1934         int vec = be_msix_vec_get(adapter, eq_obj->q.id);
1935         free_irq(vec, context);
1936 }
1937
1938 static int be_msix_register(struct be_adapter *adapter)
1939 {
1940         struct be_rx_obj *rxo;
1941         int status, i;
1942         char qname[10];
1943
1944         status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx",
1945                                 adapter);
1946         if (status)
1947                 goto err;
1948
1949         for_all_rx_queues(adapter, rxo, i) {
1950                 sprintf(qname, "rxq%d", i);
1951                 status = be_request_irq(adapter, &rxo->rx_eq, be_msix_rx,
1952                                 qname, rxo);
1953                 if (status)
1954                         goto err_msix;
1955         }
1956
1957         return 0;
1958
1959 err_msix:
1960         be_free_irq(adapter, &adapter->tx_eq, adapter);
1961
1962         for (i--, rxo = &adapter->rx_obj[i]; i >= 0; i--, rxo--)
1963                 be_free_irq(adapter, &rxo->rx_eq, rxo);
1964
1965 err:
1966         dev_warn(&adapter->pdev->dev,
1967                 "MSIX Request IRQ failed - err %d\n", status);
1968         pci_disable_msix(adapter->pdev);
1969         adapter->msix_enabled = false;
1970         return status;
1971 }
1972
1973 static int be_irq_register(struct be_adapter *adapter)
1974 {
1975         struct net_device *netdev = adapter->netdev;
1976         int status;
1977
1978         if (adapter->msix_enabled) {
1979                 status = be_msix_register(adapter);
1980                 if (status == 0)
1981                         goto done;
1982                 /* INTx is not supported for VF */
1983                 if (!be_physfn(adapter))
1984                         return status;
1985         }
1986
1987         /* INTx */
1988         netdev->irq = adapter->pdev->irq;
1989         status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
1990                         adapter);
1991         if (status) {
1992                 dev_err(&adapter->pdev->dev,
1993                         "INTx request IRQ failed - err %d\n", status);
1994                 return status;
1995         }
1996 done:
1997         adapter->isr_registered = true;
1998         return 0;
1999 }
2000
2001 static void be_irq_unregister(struct be_adapter *adapter)
2002 {
2003         struct net_device *netdev = adapter->netdev;
2004         struct be_rx_obj *rxo;
2005         int i;
2006
2007         if (!adapter->isr_registered)
2008                 return;
2009
2010         /* INTx */
2011         if (!adapter->msix_enabled) {
2012                 free_irq(netdev->irq, adapter);
2013                 goto done;
2014         }
2015
2016         /* MSIx */
2017         be_free_irq(adapter, &adapter->tx_eq, adapter);
2018
2019         for_all_rx_queues(adapter, rxo, i)
2020                 be_free_irq(adapter, &rxo->rx_eq, rxo);
2021
2022 done:
2023         adapter->isr_registered = false;
2024 }
2025
2026 static int be_close(struct net_device *netdev)
2027 {
2028         struct be_adapter *adapter = netdev_priv(netdev);
2029         struct be_rx_obj *rxo;
2030         struct be_eq_obj *tx_eq = &adapter->tx_eq;
2031         int vec, i;
2032
2033         be_async_mcc_disable(adapter);
2034
2035         netif_stop_queue(netdev);
2036         netif_carrier_off(netdev);
2037         adapter->link_up = false;
2038
2039         be_intr_set(adapter, false);
2040
2041         if (adapter->msix_enabled) {
2042                 vec = be_msix_vec_get(adapter, tx_eq->q.id);
2043                 synchronize_irq(vec);
2044
2045                 for_all_rx_queues(adapter, rxo, i) {
2046                         vec = be_msix_vec_get(adapter, rxo->rx_eq.q.id);
2047                         synchronize_irq(vec);
2048                 }
2049         } else {
2050                 synchronize_irq(netdev->irq);
2051         }
2052         be_irq_unregister(adapter);
2053
2054         for_all_rx_queues(adapter, rxo, i)
2055                 napi_disable(&rxo->rx_eq.napi);
2056
2057         napi_disable(&tx_eq->napi);
2058
2059         /* Wait for all pending tx completions to arrive so that
2060          * all tx skbs are freed.
2061          */
2062         be_tx_compl_clean(adapter);
2063
2064         return 0;
2065 }
2066
2067 static int be_open(struct net_device *netdev)
2068 {
2069         struct be_adapter *adapter = netdev_priv(netdev);
2070         struct be_eq_obj *tx_eq = &adapter->tx_eq;
2071         struct be_rx_obj *rxo;
2072         bool link_up;
2073         int status, i;
2074         u8 mac_speed;
2075         u16 link_speed;
2076
2077         for_all_rx_queues(adapter, rxo, i) {
2078                 be_post_rx_frags(rxo);
2079                 napi_enable(&rxo->rx_eq.napi);
2080         }
2081         napi_enable(&tx_eq->napi);
2082
2083         be_irq_register(adapter);
2084
2085         be_intr_set(adapter, true);
2086
2087         /* The evt queues are created in unarmed state; arm them */
2088         for_all_rx_queues(adapter, rxo, i) {
2089                 be_eq_notify(adapter, rxo->rx_eq.q.id, true, false, 0);
2090                 be_cq_notify(adapter, rxo->cq.id, true, 0);
2091         }
2092         be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
2093
2094         /* Now that interrupts are on we can process async mcc */
2095         be_async_mcc_enable(adapter);
2096
2097         status = be_cmd_link_status_query(adapter, &link_up, &mac_speed,
2098                         &link_speed);
2099         if (status)
2100                 goto err;
2101         be_link_status_update(adapter, link_up);
2102
2103         if (be_physfn(adapter)) {
2104                 status = be_vid_config(adapter, false, 0);
2105                 if (status)
2106                         goto err;
2107
2108                 status = be_cmd_set_flow_control(adapter,
2109                                 adapter->tx_fc, adapter->rx_fc);
2110                 if (status)
2111                         goto err;
2112         }
2113
2114         return 0;
2115 err:
2116         be_close(adapter->netdev);
2117         return -EIO;
2118 }
2119
2120 static int be_setup_wol(struct be_adapter *adapter, bool enable)
2121 {
2122         struct be_dma_mem cmd;
2123         int status = 0;
2124         u8 mac[ETH_ALEN];
2125
2126         memset(mac, 0, ETH_ALEN);
2127
2128         cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2129         cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
2130         if (cmd.va == NULL)
2131                 return -1;
2132         memset(cmd.va, 0, cmd.size);
2133
2134         if (enable) {
2135                 status = pci_write_config_dword(adapter->pdev,
2136                         PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
2137                 if (status) {
2138                         dev_err(&adapter->pdev->dev,
2139                                 "Could not enable Wake-on-lan\n");
2140                         pci_free_consistent(adapter->pdev, cmd.size, cmd.va,
2141                                         cmd.dma);
2142                         return status;
2143                 }
2144                 status = be_cmd_enable_magic_wol(adapter,
2145                                 adapter->netdev->dev_addr, &cmd);
2146                 pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
2147                 pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
2148         } else {
2149                 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
2150                 pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
2151                 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2152         }
2153
2154         pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
2155         return status;
2156 }
2157
2158 /*
2159  * Generate a seed MAC address from the PF MAC Address using jhash.
2160  * MAC Address for VFs are assigned incrementally starting from the seed.
2161  * These addresses are programmed in the ASIC by the PF and the VF driver
2162  * queries for the MAC address during its probe.
2163  */
2164 static inline int be_vf_eth_addr_config(struct be_adapter *adapter)
2165 {
2166         u32 vf = 0;
2167         int status = 0;
2168         u8 mac[ETH_ALEN];
2169
2170         be_vf_eth_addr_generate(adapter, mac);
2171
2172         for (vf = 0; vf < num_vfs; vf++) {
2173                 status = be_cmd_pmac_add(adapter, mac,
2174                                         adapter->vf_cfg[vf].vf_if_handle,
2175                                         &adapter->vf_cfg[vf].vf_pmac_id);
2176                 if (status)
2177                         dev_err(&adapter->pdev->dev,
2178                                 "Mac address add failed for VF %d\n", vf);
2179                 else
2180                         memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
2181
2182                 mac[5] += 1;
2183         }
2184         return status;
2185 }
2186
2187 static inline void be_vf_eth_addr_rem(struct be_adapter *adapter)
2188 {
2189         u32 vf;
2190
2191         for (vf = 0; vf < num_vfs; vf++) {
2192                 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
2193                         be_cmd_pmac_del(adapter,
2194                                         adapter->vf_cfg[vf].vf_if_handle,
2195                                         adapter->vf_cfg[vf].vf_pmac_id);
2196         }
2197 }
2198
2199 static int be_setup(struct be_adapter *adapter)
2200 {
2201         struct net_device *netdev = adapter->netdev;
2202         u32 cap_flags, en_flags, vf = 0;
2203         int status;
2204         u8 mac[ETH_ALEN];
2205
2206         cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST;
2207
2208         if (be_physfn(adapter)) {
2209                 cap_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS |
2210                                 BE_IF_FLAGS_PROMISCUOUS |
2211                                 BE_IF_FLAGS_PASS_L3L4_ERRORS;
2212                 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS;
2213
2214                 if (be_multi_rxq(adapter)) {
2215                         cap_flags |= BE_IF_FLAGS_RSS;
2216                         en_flags |= BE_IF_FLAGS_RSS;
2217                 }
2218         }
2219
2220         status = be_cmd_if_create(adapter, cap_flags, en_flags,
2221                         netdev->dev_addr, false/* pmac_invalid */,
2222                         &adapter->if_handle, &adapter->pmac_id, 0);
2223         if (status != 0)
2224                 goto do_none;
2225
2226         if (be_physfn(adapter)) {
2227                 while (vf < num_vfs) {
2228                         cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED
2229                                         | BE_IF_FLAGS_BROADCAST;
2230                         status = be_cmd_if_create(adapter, cap_flags, en_flags,
2231                                         mac, true,
2232                                         &adapter->vf_cfg[vf].vf_if_handle,
2233                                         NULL, vf+1);
2234                         if (status) {
2235                                 dev_err(&adapter->pdev->dev,
2236                                 "Interface Create failed for VF %d\n", vf);
2237                                 goto if_destroy;
2238                         }
2239                         adapter->vf_cfg[vf].vf_pmac_id = BE_INVALID_PMAC_ID;
2240                         vf++;
2241                 }
2242         } else if (!be_physfn(adapter)) {
2243                 status = be_cmd_mac_addr_query(adapter, mac,
2244                         MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
2245                 if (!status) {
2246                         memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2247                         memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2248                 }
2249         }
2250
2251         status = be_tx_queues_create(adapter);
2252         if (status != 0)
2253                 goto if_destroy;
2254
2255         status = be_rx_queues_create(adapter);
2256         if (status != 0)
2257                 goto tx_qs_destroy;
2258
2259         status = be_mcc_queues_create(adapter);
2260         if (status != 0)
2261                 goto rx_qs_destroy;
2262
2263         if (be_physfn(adapter)) {
2264                 status = be_vf_eth_addr_config(adapter);
2265                 if (status)
2266                         goto mcc_q_destroy;
2267         }
2268
2269         adapter->link_speed = -1;
2270
2271         return 0;
2272
2273 mcc_q_destroy:
2274         if (be_physfn(adapter))
2275                 be_vf_eth_addr_rem(adapter);
2276         be_mcc_queues_destroy(adapter);
2277 rx_qs_destroy:
2278         be_rx_queues_destroy(adapter);
2279 tx_qs_destroy:
2280         be_tx_queues_destroy(adapter);
2281 if_destroy:
2282         for (vf = 0; vf < num_vfs; vf++)
2283                 if (adapter->vf_cfg[vf].vf_if_handle)
2284                         be_cmd_if_destroy(adapter,
2285                                         adapter->vf_cfg[vf].vf_if_handle);
2286         be_cmd_if_destroy(adapter, adapter->if_handle);
2287 do_none:
2288         return status;
2289 }
2290
2291 static int be_clear(struct be_adapter *adapter)
2292 {
2293         if (be_physfn(adapter))
2294                 be_vf_eth_addr_rem(adapter);
2295
2296         be_mcc_queues_destroy(adapter);
2297         be_rx_queues_destroy(adapter);
2298         be_tx_queues_destroy(adapter);
2299
2300         be_cmd_if_destroy(adapter, adapter->if_handle);
2301
2302         /* tell fw we're done with firing cmds */
2303         be_cmd_fw_clean(adapter);
2304         return 0;
2305 }
2306
2307
2308 #define FW_FILE_HDR_SIGN        "ServerEngines Corp. "
2309 static bool be_flash_redboot(struct be_adapter *adapter,
2310                         const u8 *p, u32 img_start, int image_size,
2311                         int hdr_size)
2312 {
2313         u32 crc_offset;
2314         u8 flashed_crc[4];
2315         int status;
2316
2317         crc_offset = hdr_size + img_start + image_size - 4;
2318
2319         p += crc_offset;
2320
2321         status = be_cmd_get_flash_crc(adapter, flashed_crc,
2322                         (image_size - 4));
2323         if (status) {
2324                 dev_err(&adapter->pdev->dev,
2325                 "could not get crc from flash, not flashing redboot\n");
2326                 return false;
2327         }
2328
2329         /*update redboot only if crc does not match*/
2330         if (!memcmp(flashed_crc, p, 4))
2331                 return false;
2332         else
2333                 return true;
2334 }
2335
2336 static int be_flash_data(struct be_adapter *adapter,
2337                         const struct firmware *fw,
2338                         struct be_dma_mem *flash_cmd, int num_of_images)
2339
2340 {
2341         int status = 0, i, filehdr_size = 0;
2342         u32 total_bytes = 0, flash_op;
2343         int num_bytes;
2344         const u8 *p = fw->data;
2345         struct be_cmd_write_flashrom *req = flash_cmd->va;
2346         struct flash_comp *pflashcomp;
2347         int num_comp;
2348
2349         struct flash_comp gen3_flash_types[9] = {
2350                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE,
2351                         FLASH_IMAGE_MAX_SIZE_g3},
2352                 { FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT,
2353                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g3},
2354                 { FLASH_iSCSI_BIOS_START_g3, IMG_TYPE_BIOS,
2355                         FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2356                 { FLASH_PXE_BIOS_START_g3, IMG_TYPE_PXE_BIOS,
2357                         FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2358                 { FLASH_FCoE_BIOS_START_g3, IMG_TYPE_FCOE_BIOS,
2359                         FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2360                 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, IMG_TYPE_ISCSI_BACKUP,
2361                         FLASH_IMAGE_MAX_SIZE_g3},
2362                 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, IMG_TYPE_FCOE_FW_ACTIVE,
2363                         FLASH_IMAGE_MAX_SIZE_g3},
2364                 { FLASH_FCoE_BACKUP_IMAGE_START_g3, IMG_TYPE_FCOE_FW_BACKUP,
2365                         FLASH_IMAGE_MAX_SIZE_g3},
2366                 { FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2367                         FLASH_NCSI_IMAGE_MAX_SIZE_g3}
2368         };
2369         struct flash_comp gen2_flash_types[8] = {
2370                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE,
2371                         FLASH_IMAGE_MAX_SIZE_g2},
2372                 { FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT,
2373                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g2},
2374                 { FLASH_iSCSI_BIOS_START_g2, IMG_TYPE_BIOS,
2375                         FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2376                 { FLASH_PXE_BIOS_START_g2, IMG_TYPE_PXE_BIOS,
2377                         FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2378                 { FLASH_FCoE_BIOS_START_g2, IMG_TYPE_FCOE_BIOS,
2379                         FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2380                 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, IMG_TYPE_ISCSI_BACKUP,
2381                         FLASH_IMAGE_MAX_SIZE_g2},
2382                 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, IMG_TYPE_FCOE_FW_ACTIVE,
2383                         FLASH_IMAGE_MAX_SIZE_g2},
2384                 { FLASH_FCoE_BACKUP_IMAGE_START_g2, IMG_TYPE_FCOE_FW_BACKUP,
2385                          FLASH_IMAGE_MAX_SIZE_g2}
2386         };
2387
2388         if (adapter->generation == BE_GEN3) {
2389                 pflashcomp = gen3_flash_types;
2390                 filehdr_size = sizeof(struct flash_file_hdr_g3);
2391                 num_comp = 9;
2392         } else {
2393                 pflashcomp = gen2_flash_types;
2394                 filehdr_size = sizeof(struct flash_file_hdr_g2);
2395                 num_comp = 8;
2396         }
2397         for (i = 0; i < num_comp; i++) {
2398                 if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) &&
2399                                 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
2400                         continue;
2401                 if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
2402                         (!be_flash_redboot(adapter, fw->data,
2403                          pflashcomp[i].offset, pflashcomp[i].size,
2404                          filehdr_size)))
2405                         continue;
2406                 p = fw->data;
2407                 p += filehdr_size + pflashcomp[i].offset
2408                         + (num_of_images * sizeof(struct image_hdr));
2409         if (p + pflashcomp[i].size > fw->data + fw->size)
2410                 return -1;
2411         total_bytes = pflashcomp[i].size;
2412                 while (total_bytes) {
2413                         if (total_bytes > 32*1024)
2414                                 num_bytes = 32*1024;
2415                         else
2416                                 num_bytes = total_bytes;
2417                         total_bytes -= num_bytes;
2418
2419                         if (!total_bytes)
2420                                 flash_op = FLASHROM_OPER_FLASH;
2421                         else
2422                                 flash_op = FLASHROM_OPER_SAVE;
2423                         memcpy(req->params.data_buf, p, num_bytes);
2424                         p += num_bytes;
2425                         status = be_cmd_write_flashrom(adapter, flash_cmd,
2426                                 pflashcomp[i].optype, flash_op, num_bytes);
2427                         if (status) {
2428                                 dev_err(&adapter->pdev->dev,
2429                                         "cmd to write to flash rom failed.\n");
2430                                 return -1;
2431                         }
2432                         yield();
2433                 }
2434         }
2435         return 0;
2436 }
2437
2438 static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
2439 {
2440         if (fhdr == NULL)
2441                 return 0;
2442         if (fhdr->build[0] == '3')
2443                 return BE_GEN3;
2444         else if (fhdr->build[0] == '2')
2445                 return BE_GEN2;
2446         else
2447                 return 0;
2448 }
2449
2450 int be_load_fw(struct be_adapter *adapter, u8 *func)
2451 {
2452         char fw_file[ETHTOOL_FLASH_MAX_FILENAME];
2453         const struct firmware *fw;
2454         struct flash_file_hdr_g2 *fhdr;
2455         struct flash_file_hdr_g3 *fhdr3;
2456         struct image_hdr *img_hdr_ptr = NULL;
2457         struct be_dma_mem flash_cmd;
2458         int status, i = 0, num_imgs = 0;
2459         const u8 *p;
2460
2461         strcpy(fw_file, func);
2462
2463         status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
2464         if (status)
2465                 goto fw_exit;
2466
2467         p = fw->data;
2468         fhdr = (struct flash_file_hdr_g2 *) p;
2469         dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
2470
2471         flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
2472         flash_cmd.va = pci_alloc_consistent(adapter->pdev, flash_cmd.size,
2473                                         &flash_cmd.dma);
2474         if (!flash_cmd.va) {
2475                 status = -ENOMEM;
2476                 dev_err(&adapter->pdev->dev,
2477                         "Memory allocation failure while flashing\n");
2478                 goto fw_exit;
2479         }
2480
2481         if ((adapter->generation == BE_GEN3) &&
2482                         (get_ufigen_type(fhdr) == BE_GEN3)) {
2483                 fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
2484                 num_imgs = le32_to_cpu(fhdr3->num_imgs);
2485                 for (i = 0; i < num_imgs; i++) {
2486                         img_hdr_ptr = (struct image_hdr *) (fw->data +
2487                                         (sizeof(struct flash_file_hdr_g3) +
2488                                          i * sizeof(struct image_hdr)));
2489                         if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
2490                                 status = be_flash_data(adapter, fw, &flash_cmd,
2491                                                         num_imgs);
2492                 }
2493         } else if ((adapter->generation == BE_GEN2) &&
2494                         (get_ufigen_type(fhdr) == BE_GEN2)) {
2495                 status = be_flash_data(adapter, fw, &flash_cmd, 0);
2496         } else {
2497                 dev_err(&adapter->pdev->dev,
2498                         "UFI and Interface are not compatible for flashing\n");
2499                 status = -1;
2500         }
2501
2502         pci_free_consistent(adapter->pdev, flash_cmd.size, flash_cmd.va,
2503                                 flash_cmd.dma);
2504         if (status) {
2505                 dev_err(&adapter->pdev->dev, "Firmware load error\n");
2506                 goto fw_exit;
2507         }
2508
2509         dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
2510
2511 fw_exit:
2512         release_firmware(fw);
2513         return status;
2514 }
2515
2516 static struct net_device_ops be_netdev_ops = {
2517         .ndo_open               = be_open,
2518         .ndo_stop               = be_close,
2519         .ndo_start_xmit         = be_xmit,
2520         .ndo_set_rx_mode        = be_set_multicast_list,
2521         .ndo_set_mac_address    = be_mac_addr_set,
2522         .ndo_change_mtu         = be_change_mtu,
2523         .ndo_validate_addr      = eth_validate_addr,
2524         .ndo_vlan_rx_register   = be_vlan_register,
2525         .ndo_vlan_rx_add_vid    = be_vlan_add_vid,
2526         .ndo_vlan_rx_kill_vid   = be_vlan_rem_vid,
2527         .ndo_set_vf_mac         = be_set_vf_mac,
2528         .ndo_set_vf_vlan        = be_set_vf_vlan,
2529         .ndo_set_vf_tx_rate     = be_set_vf_tx_rate,
2530         .ndo_get_vf_config      = be_get_vf_config
2531 };
2532
2533 static void be_netdev_init(struct net_device *netdev)
2534 {
2535         struct be_adapter *adapter = netdev_priv(netdev);
2536         struct be_rx_obj *rxo;
2537         int i;
2538
2539         netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
2540                 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_HW_CSUM |
2541                 NETIF_F_GRO | NETIF_F_TSO6;
2542
2543         netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_HW_CSUM;
2544
2545         netdev->flags |= IFF_MULTICAST;
2546
2547         adapter->rx_csum = true;
2548
2549         /* Default settings for Rx and Tx flow control */
2550         adapter->rx_fc = true;
2551         adapter->tx_fc = true;
2552
2553         netif_set_gso_max_size(netdev, 65535);
2554
2555         BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
2556
2557         SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
2558
2559         for_all_rx_queues(adapter, rxo, i)
2560                 netif_napi_add(netdev, &rxo->rx_eq.napi, be_poll_rx,
2561                                 BE_NAPI_WEIGHT);
2562
2563         netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
2564                 BE_NAPI_WEIGHT);
2565
2566         netif_stop_queue(netdev);
2567 }
2568
2569 static void be_unmap_pci_bars(struct be_adapter *adapter)
2570 {
2571         if (adapter->csr)
2572                 iounmap(adapter->csr);
2573         if (adapter->db)
2574                 iounmap(adapter->db);
2575         if (adapter->pcicfg && be_physfn(adapter))
2576                 iounmap(adapter->pcicfg);
2577 }
2578
2579 static int be_map_pci_bars(struct be_adapter *adapter)
2580 {
2581         u8 __iomem *addr;
2582         int pcicfg_reg, db_reg;
2583
2584         if (be_physfn(adapter)) {
2585                 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
2586                                 pci_resource_len(adapter->pdev, 2));
2587                 if (addr == NULL)
2588                         return -ENOMEM;
2589                 adapter->csr = addr;
2590         }
2591
2592         if (adapter->generation == BE_GEN2) {
2593                 pcicfg_reg = 1;
2594                 db_reg = 4;
2595         } else {
2596                 pcicfg_reg = 0;
2597                 if (be_physfn(adapter))
2598                         db_reg = 4;
2599                 else
2600                         db_reg = 0;
2601         }
2602         addr = ioremap_nocache(pci_resource_start(adapter->pdev, db_reg),
2603                                 pci_resource_len(adapter->pdev, db_reg));
2604         if (addr == NULL)
2605                 goto pci_map_err;
2606         adapter->db = addr;
2607
2608         if (be_physfn(adapter)) {
2609                 addr = ioremap_nocache(
2610                                 pci_resource_start(adapter->pdev, pcicfg_reg),
2611                                 pci_resource_len(adapter->pdev, pcicfg_reg));
2612                 if (addr == NULL)
2613                         goto pci_map_err;
2614                 adapter->pcicfg = addr;
2615         } else
2616                 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
2617
2618         return 0;
2619 pci_map_err:
2620         be_unmap_pci_bars(adapter);
2621         return -ENOMEM;
2622 }
2623
2624
2625 static void be_ctrl_cleanup(struct be_adapter *adapter)
2626 {
2627         struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
2628
2629         be_unmap_pci_bars(adapter);
2630
2631         if (mem->va)
2632                 pci_free_consistent(adapter->pdev, mem->size,
2633                         mem->va, mem->dma);
2634
2635         mem = &adapter->mc_cmd_mem;
2636         if (mem->va)
2637                 pci_free_consistent(adapter->pdev, mem->size,
2638                         mem->va, mem->dma);
2639 }
2640
2641 static int be_ctrl_init(struct be_adapter *adapter)
2642 {
2643         struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
2644         struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
2645         struct be_dma_mem *mc_cmd_mem = &adapter->mc_cmd_mem;
2646         int status;
2647
2648         status = be_map_pci_bars(adapter);
2649         if (status)
2650                 goto done;
2651
2652         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
2653         mbox_mem_alloc->va = pci_alloc_consistent(adapter->pdev,
2654                                 mbox_mem_alloc->size, &mbox_mem_alloc->dma);
2655         if (!mbox_mem_alloc->va) {
2656                 status = -ENOMEM;
2657                 goto unmap_pci_bars;
2658         }
2659
2660         mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
2661         mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
2662         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
2663         memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
2664
2665         mc_cmd_mem->size = sizeof(struct be_cmd_req_mcast_mac_config);
2666         mc_cmd_mem->va = pci_alloc_consistent(adapter->pdev, mc_cmd_mem->size,
2667                         &mc_cmd_mem->dma);
2668         if (mc_cmd_mem->va == NULL) {
2669                 status = -ENOMEM;
2670                 goto free_mbox;
2671         }
2672         memset(mc_cmd_mem->va, 0, mc_cmd_mem->size);
2673
2674         spin_lock_init(&adapter->mbox_lock);
2675         spin_lock_init(&adapter->mcc_lock);
2676         spin_lock_init(&adapter->mcc_cq_lock);
2677
2678         init_completion(&adapter->flash_compl);
2679         pci_save_state(adapter->pdev);
2680         return 0;
2681
2682 free_mbox:
2683         pci_free_consistent(adapter->pdev, mbox_mem_alloc->size,
2684                 mbox_mem_alloc->va, mbox_mem_alloc->dma);
2685
2686 unmap_pci_bars:
2687         be_unmap_pci_bars(adapter);
2688
2689 done:
2690         return status;
2691 }
2692
2693 static void be_stats_cleanup(struct be_adapter *adapter)
2694 {
2695         struct be_dma_mem *cmd = &adapter->stats_cmd;
2696
2697         if (cmd->va)
2698                 pci_free_consistent(adapter->pdev, cmd->size,
2699                         cmd->va, cmd->dma);
2700 }
2701
2702 static int be_stats_init(struct be_adapter *adapter)
2703 {
2704         struct be_dma_mem *cmd = &adapter->stats_cmd;
2705
2706         cmd->size = sizeof(struct be_cmd_req_get_stats);
2707         cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma);
2708         if (cmd->va == NULL)
2709                 return -1;
2710         memset(cmd->va, 0, cmd->size);
2711         return 0;
2712 }
2713
2714 static void __devexit be_remove(struct pci_dev *pdev)
2715 {
2716         struct be_adapter *adapter = pci_get_drvdata(pdev);
2717
2718         if (!adapter)
2719                 return;
2720
2721         cancel_delayed_work_sync(&adapter->work);
2722
2723         unregister_netdev(adapter->netdev);
2724
2725         be_clear(adapter);
2726
2727         be_stats_cleanup(adapter);
2728
2729         be_ctrl_cleanup(adapter);
2730
2731         be_sriov_disable(adapter);
2732
2733         be_msix_disable(adapter);
2734
2735         pci_set_drvdata(pdev, NULL);
2736         pci_release_regions(pdev);
2737         pci_disable_device(pdev);
2738
2739         free_netdev(adapter->netdev);
2740 }
2741
2742 static int be_get_config(struct be_adapter *adapter)
2743 {
2744         int status;
2745         u8 mac[ETH_ALEN];
2746
2747         status = be_cmd_get_fw_ver(adapter, adapter->fw_ver);
2748         if (status)
2749                 return status;
2750
2751         status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
2752                         &adapter->function_mode, &adapter->function_caps);
2753         if (status)
2754                 return status;
2755
2756         memset(mac, 0, ETH_ALEN);
2757
2758         if (be_physfn(adapter)) {
2759                 status = be_cmd_mac_addr_query(adapter, mac,
2760                         MAC_ADDRESS_TYPE_NETWORK, true /*permanent */, 0);
2761
2762                 if (status)
2763                         return status;
2764
2765                 if (!is_valid_ether_addr(mac))
2766                         return -EADDRNOTAVAIL;
2767
2768                 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2769                 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2770         }
2771
2772         if (adapter->function_mode & 0x400)
2773                 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/4;
2774         else
2775                 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
2776
2777         return 0;
2778 }
2779
2780 static int __devinit be_probe(struct pci_dev *pdev,
2781                         const struct pci_device_id *pdev_id)
2782 {
2783         int status = 0;
2784         struct be_adapter *adapter;
2785         struct net_device *netdev;
2786
2787         status = pci_enable_device(pdev);
2788         if (status)
2789                 goto do_none;
2790
2791         status = pci_request_regions(pdev, DRV_NAME);
2792         if (status)
2793                 goto disable_dev;
2794         pci_set_master(pdev);
2795
2796         netdev = alloc_etherdev(sizeof(struct be_adapter));
2797         if (netdev == NULL) {
2798                 status = -ENOMEM;
2799                 goto rel_reg;
2800         }
2801         adapter = netdev_priv(netdev);
2802
2803         switch (pdev->device) {
2804         case BE_DEVICE_ID1:
2805         case OC_DEVICE_ID1:
2806                 adapter->generation = BE_GEN2;
2807                 break;
2808         case BE_DEVICE_ID2:
2809         case OC_DEVICE_ID2:
2810                 adapter->generation = BE_GEN3;
2811                 break;
2812         default:
2813                 adapter->generation = 0;
2814         }
2815
2816         adapter->pdev = pdev;
2817         pci_set_drvdata(pdev, adapter);
2818         adapter->netdev = netdev;
2819         SET_NETDEV_DEV(netdev, &pdev->dev);
2820
2821         status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2822         if (!status) {
2823                 netdev->features |= NETIF_F_HIGHDMA;
2824         } else {
2825                 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2826                 if (status) {
2827                         dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
2828                         goto free_netdev;
2829                 }
2830         }
2831
2832         be_sriov_enable(adapter);
2833
2834         status = be_ctrl_init(adapter);
2835         if (status)
2836                 goto free_netdev;
2837
2838         /* sync up with fw's ready state */
2839         if (be_physfn(adapter)) {
2840                 status = be_cmd_POST(adapter);
2841                 if (status)
2842                         goto ctrl_clean;
2843         }
2844
2845         /* tell fw we're ready to fire cmds */
2846         status = be_cmd_fw_init(adapter);
2847         if (status)
2848                 goto ctrl_clean;
2849
2850         if (be_physfn(adapter)) {
2851                 status = be_cmd_reset_function(adapter);
2852                 if (status)
2853                         goto ctrl_clean;
2854         }
2855
2856         status = be_stats_init(adapter);
2857         if (status)
2858                 goto ctrl_clean;
2859
2860         status = be_get_config(adapter);
2861         if (status)
2862                 goto stats_clean;
2863
2864         be_msix_enable(adapter);
2865
2866         INIT_DELAYED_WORK(&adapter->work, be_worker);
2867
2868         status = be_setup(adapter);
2869         if (status)
2870                 goto msix_disable;
2871
2872         be_netdev_init(netdev);
2873         status = register_netdev(netdev);
2874         if (status != 0)
2875                 goto unsetup;
2876         netif_carrier_off(netdev);
2877
2878         dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
2879         schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
2880         return 0;
2881
2882 unsetup:
2883         be_clear(adapter);
2884 msix_disable:
2885         be_msix_disable(adapter);
2886 stats_clean:
2887         be_stats_cleanup(adapter);
2888 ctrl_clean:
2889         be_ctrl_cleanup(adapter);
2890 free_netdev:
2891         be_sriov_disable(adapter);
2892         free_netdev(adapter->netdev);
2893         pci_set_drvdata(pdev, NULL);
2894 rel_reg:
2895         pci_release_regions(pdev);
2896 disable_dev:
2897         pci_disable_device(pdev);
2898 do_none:
2899         dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
2900         return status;
2901 }
2902
2903 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
2904 {
2905         struct be_adapter *adapter = pci_get_drvdata(pdev);
2906         struct net_device *netdev =  adapter->netdev;
2907
2908         if (adapter->wol)
2909                 be_setup_wol(adapter, true);
2910
2911         netif_device_detach(netdev);
2912         if (netif_running(netdev)) {
2913                 rtnl_lock();
2914                 be_close(netdev);
2915                 rtnl_unlock();
2916         }
2917         be_cmd_get_flow_control(adapter, &adapter->tx_fc, &adapter->rx_fc);
2918         be_clear(adapter);
2919
2920         pci_save_state(pdev);
2921         pci_disable_device(pdev);
2922         pci_set_power_state(pdev, pci_choose_state(pdev, state));
2923         return 0;
2924 }
2925
2926 static int be_resume(struct pci_dev *pdev)
2927 {
2928         int status = 0;
2929         struct be_adapter *adapter = pci_get_drvdata(pdev);
2930         struct net_device *netdev =  adapter->netdev;
2931
2932         netif_device_detach(netdev);
2933
2934         status = pci_enable_device(pdev);
2935         if (status)
2936                 return status;
2937
2938         pci_set_power_state(pdev, 0);
2939         pci_restore_state(pdev);
2940
2941         /* tell fw we're ready to fire cmds */
2942         status = be_cmd_fw_init(adapter);
2943         if (status)
2944                 return status;
2945
2946         be_setup(adapter);
2947         if (netif_running(netdev)) {
2948                 rtnl_lock();
2949                 be_open(netdev);
2950                 rtnl_unlock();
2951         }
2952         netif_device_attach(netdev);
2953
2954         if (adapter->wol)
2955                 be_setup_wol(adapter, false);
2956         return 0;
2957 }
2958
2959 /*
2960  * An FLR will stop BE from DMAing any data.
2961  */
2962 static void be_shutdown(struct pci_dev *pdev)
2963 {
2964         struct be_adapter *adapter = pci_get_drvdata(pdev);
2965         struct net_device *netdev =  adapter->netdev;
2966
2967         netif_device_detach(netdev);
2968
2969         be_cmd_reset_function(adapter);
2970
2971         if (adapter->wol)
2972                 be_setup_wol(adapter, true);
2973
2974         pci_disable_device(pdev);
2975 }
2976
2977 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
2978                                 pci_channel_state_t state)
2979 {
2980         struct be_adapter *adapter = pci_get_drvdata(pdev);
2981         struct net_device *netdev =  adapter->netdev;
2982
2983         dev_err(&adapter->pdev->dev, "EEH error detected\n");
2984
2985         adapter->eeh_err = true;
2986
2987         netif_device_detach(netdev);
2988
2989         if (netif_running(netdev)) {
2990                 rtnl_lock();
2991                 be_close(netdev);
2992                 rtnl_unlock();
2993         }
2994         be_clear(adapter);
2995
2996         if (state == pci_channel_io_perm_failure)
2997                 return PCI_ERS_RESULT_DISCONNECT;
2998
2999         pci_disable_device(pdev);
3000
3001         return PCI_ERS_RESULT_NEED_RESET;
3002 }
3003
3004 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
3005 {
3006         struct be_adapter *adapter = pci_get_drvdata(pdev);
3007         int status;
3008
3009         dev_info(&adapter->pdev->dev, "EEH reset\n");
3010         adapter->eeh_err = false;
3011
3012         status = pci_enable_device(pdev);
3013         if (status)
3014                 return PCI_ERS_RESULT_DISCONNECT;
3015
3016         pci_set_master(pdev);
3017         pci_set_power_state(pdev, 0);
3018         pci_restore_state(pdev);
3019
3020         /* Check if card is ok and fw is ready */
3021         status = be_cmd_POST(adapter);
3022         if (status)
3023                 return PCI_ERS_RESULT_DISCONNECT;
3024
3025         return PCI_ERS_RESULT_RECOVERED;
3026 }
3027
3028 static void be_eeh_resume(struct pci_dev *pdev)
3029 {
3030         int status = 0;
3031         struct be_adapter *adapter = pci_get_drvdata(pdev);
3032         struct net_device *netdev =  adapter->netdev;
3033
3034         dev_info(&adapter->pdev->dev, "EEH resume\n");
3035
3036         pci_save_state(pdev);
3037
3038         /* tell fw we're ready to fire cmds */
3039         status = be_cmd_fw_init(adapter);
3040         if (status)
3041                 goto err;
3042
3043         status = be_setup(adapter);
3044         if (status)
3045                 goto err;
3046
3047         if (netif_running(netdev)) {
3048                 status = be_open(netdev);
3049                 if (status)
3050                         goto err;
3051         }
3052         netif_device_attach(netdev);
3053         return;
3054 err:
3055         dev_err(&adapter->pdev->dev, "EEH resume failed\n");
3056 }
3057
3058 static struct pci_error_handlers be_eeh_handlers = {
3059         .error_detected = be_eeh_err_detected,
3060         .slot_reset = be_eeh_reset,
3061         .resume = be_eeh_resume,
3062 };
3063
3064 static struct pci_driver be_driver = {
3065         .name = DRV_NAME,
3066         .id_table = be_dev_ids,
3067         .probe = be_probe,
3068         .remove = be_remove,
3069         .suspend = be_suspend,
3070         .resume = be_resume,
3071         .shutdown = be_shutdown,
3072         .err_handler = &be_eeh_handlers
3073 };
3074
3075 static int __init be_init_module(void)
3076 {
3077         if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
3078             rx_frag_size != 2048) {
3079                 printk(KERN_WARNING DRV_NAME
3080                         " : Module param rx_frag_size must be 2048/4096/8192."
3081                         " Using 2048\n");
3082                 rx_frag_size = 2048;
3083         }
3084
3085         if (num_vfs > 32) {
3086                 printk(KERN_WARNING DRV_NAME
3087                         " : Module param num_vfs must not be greater than 32."
3088                         "Using 32\n");
3089                 num_vfs = 32;
3090         }
3091
3092         return pci_register_driver(&be_driver);
3093 }
3094 module_init(be_init_module);
3095
3096 static void __exit be_exit_module(void)
3097 {
3098         pci_unregister_driver(&be_driver);
3099 }
3100 module_exit(be_exit_module);