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