drivers/net/benet/be_main.c

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