drivers/net/ethernet/emulex/benet/be_main.c

   1 /*
   2  * Copyright (C) 2005 - 2013 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 <linux/module.h>
  20 #include "be.h"
  21 #include "be_cmds.h"
  22 #include <asm/div64.h>
  23 #include <linux/aer.h>
  24 #include <linux/if_bridge.h>
  25
  26 MODULE_VERSION(DRV_VER);
  27 MODULE_DEVICE_TABLE(pci, be_dev_ids);
  28 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
  29 MODULE_AUTHOR("Emulex Corporation");
  30 MODULE_LICENSE("GPL");
  31
  32 static unsigned int num_vfs;
  33 module_param(num_vfs, uint, S_IRUGO);
  34 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
  35
  36 static ushort rx_frag_size = 2048;
  37 module_param(rx_frag_size, ushort, S_IRUGO);
  38 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
  39
  40 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
  41         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
  42         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
  43         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
  44         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
  45         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
  46         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
  47         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
  48         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
  49         { 0 }
  50 };
  51 MODULE_DEVICE_TABLE(pci, be_dev_ids);
  52 /* UE Status Low CSR */
  53 static const char * const ue_status_low_desc[] = {
  54         "CEV",
  55         "CTX",
  56         "DBUF",
  57         "ERX",
  58         "Host",
  59         "MPU",
  60         "NDMA",
  61         "PTC ",
  62         "RDMA ",
  63         "RXF ",
  64         "RXIPS ",
  65         "RXULP0 ",
  66         "RXULP1 ",
  67         "RXULP2 ",
  68         "TIM ",
  69         "TPOST ",
  70         "TPRE ",
  71         "TXIPS ",
  72         "TXULP0 ",
  73         "TXULP1 ",
  74         "UC ",
  75         "WDMA ",
  76         "TXULP2 ",
  77         "HOST1 ",
  78         "P0_OB_LINK ",
  79         "P1_OB_LINK ",
  80         "HOST_GPIO ",
  81         "MBOX ",
  82         "AXGMAC0",
  83         "AXGMAC1",
  84         "JTAG",
  85         "MPU_INTPEND"
  86 };
  87 /* UE Status High CSR */
  88 static const char * const ue_status_hi_desc[] = {
  89         "LPCMEMHOST",
  90         "MGMT_MAC",
  91         "PCS0ONLINE",
  92         "MPU_IRAM",
  93         "PCS1ONLINE",
  94         "PCTL0",
  95         "PCTL1",
  96         "PMEM",
  97         "RR",
  98         "TXPB",
  99         "RXPP",
 100         "XAUI",
 101         "TXP",
 102         "ARM",
 103         "IPC",
 104         "HOST2",
 105         "HOST3",
 106         "HOST4",
 107         "HOST5",
 108         "HOST6",
 109         "HOST7",
 110         "HOST8",
 111         "HOST9",
 112         "NETC",
 113         "Unknown",
 114         "Unknown",
 115         "Unknown",
 116         "Unknown",
 117         "Unknown",
 118         "Unknown",
 119         "Unknown",
 120         "Unknown"
 121 };
 122
 123 /* Is BE in a multi-channel mode */
 124 static inline bool be_is_mc(struct be_adapter *adapter) {
 125         return (adapter->function_mode & FLEX10_MODE ||
 126                 adapter->function_mode & VNIC_MODE ||
 127                 adapter->function_mode & UMC_ENABLED);
 128 }
 129
 130 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
 131 {
 132         struct be_dma_mem *mem = &q->dma_mem;
 133         if (mem->va) {
 134                 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
 135                                   mem->dma);
 136                 mem->va = NULL;
 137         }
 138 }
 139
 140 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
 141                 u16 len, u16 entry_size)
 142 {
 143         struct be_dma_mem *mem = &q->dma_mem;
 144
 145         memset(q, 0, sizeof(*q));
 146         q->len = len;
 147         q->entry_size = entry_size;
 148         mem->size = len * entry_size;
 149         mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
 150                                       GFP_KERNEL);
 151         if (!mem->va)
 152                 return -ENOMEM;
 153         return 0;
 154 }
 155
 156 static void be_reg_intr_set(struct be_adapter *adapter, bool enable)
 157 {
 158         u32 reg, enabled;
 159
 160         pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
 161                                 &reg);
 162         enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 163
 164         if (!enabled && enable)
 165                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 166         else if (enabled && !enable)
 167                 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 168         else
 169                 return;
 170
 171         pci_write_config_dword(adapter->pdev,
 172                         PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
 173 }
 174
 175 static void be_intr_set(struct be_adapter *adapter, bool enable)
 176 {
 177         int status = 0;
 178
 179         /* On lancer interrupts can't be controlled via this register */
 180         if (lancer_chip(adapter))
 181                 return;
 182
 183         if (adapter->eeh_error)
 184                 return;
 185
 186         status = be_cmd_intr_set(adapter, enable);
 187         if (status)
 188                 be_reg_intr_set(adapter, enable);
 189 }
 190
 191 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
 192 {
 193         u32 val = 0;
 194         val |= qid & DB_RQ_RING_ID_MASK;
 195         val |= posted << DB_RQ_NUM_POSTED_SHIFT;
 196
 197         wmb();
 198         iowrite32(val, adapter->db + DB_RQ_OFFSET);
 199 }
 200
 201 static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
 202                           u16 posted)
 203 {
 204         u32 val = 0;
 205         val |= txo->q.id & DB_TXULP_RING_ID_MASK;
 206         val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
 207
 208         wmb();
 209         iowrite32(val, adapter->db + txo->db_offset);
 210 }
 211
 212 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
 213                 bool arm, bool clear_int, u16 num_popped)
 214 {
 215         u32 val = 0;
 216         val |= qid & DB_EQ_RING_ID_MASK;
 217         val |= ((qid & DB_EQ_RING_ID_EXT_MASK) <<
 218                         DB_EQ_RING_ID_EXT_MASK_SHIFT);
 219
 220         if (adapter->eeh_error)
 221                 return;
 222
 223         if (arm)
 224                 val |= 1 << DB_EQ_REARM_SHIFT;
 225         if (clear_int)
 226                 val |= 1 << DB_EQ_CLR_SHIFT;
 227         val |= 1 << DB_EQ_EVNT_SHIFT;
 228         val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
 229         iowrite32(val, adapter->db + DB_EQ_OFFSET);
 230 }
 231
 232 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
 233 {
 234         u32 val = 0;
 235         val |= qid & DB_CQ_RING_ID_MASK;
 236         val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
 237                         DB_CQ_RING_ID_EXT_MASK_SHIFT);
 238
 239         if (adapter->eeh_error)
 240                 return;
 241
 242         if (arm)
 243                 val |= 1 << DB_CQ_REARM_SHIFT;
 244         val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
 245         iowrite32(val, adapter->db + DB_CQ_OFFSET);
 246 }
 247
 248 static int be_mac_addr_set(struct net_device *netdev, void *p)
 249 {
 250         struct be_adapter *adapter = netdev_priv(netdev);
 251         struct device *dev = &adapter->pdev->dev;
 252         struct sockaddr *addr = p;
 253         int status;
 254         u8 mac[ETH_ALEN];
 255         u32 old_pmac_id = adapter->pmac_id[0], curr_pmac_id = 0;
 256
 257         if (!is_valid_ether_addr(addr->sa_data))
 258                 return -EADDRNOTAVAIL;
 259
 260         /* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT
 261          * privilege or if PF did not provision the new MAC address.
 262          * On BE3, this cmd will always fail if the VF doesn't have the
 263          * FILTMGMT privilege. This failure is OK, only if the PF programmed
 264          * the MAC for the VF.
 265          */
 266         status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
 267                                  adapter->if_handle, &adapter->pmac_id[0], 0);
 268         if (!status) {
 269                 curr_pmac_id = adapter->pmac_id[0];
 270
 271                 /* Delete the old programmed MAC. This call may fail if the
 272                  * old MAC was already deleted by the PF driver.
 273                  */
 274                 if (adapter->pmac_id[0] != old_pmac_id)
 275                         be_cmd_pmac_del(adapter, adapter->if_handle,
 276                                         old_pmac_id, 0);
 277         }
 278
 279         /* Decide if the new MAC is successfully activated only after
 280          * querying the FW
 281          */
 282         status = be_cmd_get_active_mac(adapter, curr_pmac_id, mac);
 283         if (status)
 284                 goto err;
 285
 286         /* The MAC change did not happen, either due to lack of privilege
 287          * or PF didn't pre-provision.
 288          */
 289         if (memcmp(addr->sa_data, mac, ETH_ALEN)) {
 290                 status = -EPERM;
 291                 goto err;
 292         }
 293
 294         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 295         dev_info(dev, "MAC address changed to %pM\n", mac);
 296         return 0;
 297 err:
 298         dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data);
 299         return status;
 300 }
 301
 302 /* BE2 supports only v0 cmd */
 303 static void *hw_stats_from_cmd(struct be_adapter *adapter)
 304 {
 305         if (BE2_chip(adapter)) {
 306                 struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
 307
 308                 return &cmd->hw_stats;
 309         } else  {
 310                 struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
 311
 312                 return &cmd->hw_stats;
 313         }
 314 }
 315
 316 /* BE2 supports only v0 cmd */
 317 static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
 318 {
 319         if (BE2_chip(adapter)) {
 320                 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
 321
 322                 return &hw_stats->erx;
 323         } else {
 324                 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
 325
 326                 return &hw_stats->erx;
 327         }
 328 }
 329
 330 static void populate_be_v0_stats(struct be_adapter *adapter)
 331 {
 332         struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
 333         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
 334         struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
 335         struct be_port_rxf_stats_v0 *port_stats =
 336                                         &rxf_stats->port[adapter->port_num];
 337         struct be_drv_stats *drvs = &adapter->drv_stats;
 338
 339         be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
 340         drvs->rx_pause_frames = port_stats->rx_pause_frames;
 341         drvs->rx_crc_errors = port_stats->rx_crc_errors;
 342         drvs->rx_control_frames = port_stats->rx_control_frames;
 343         drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
 344         drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
 345         drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
 346         drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
 347         drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
 348         drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
 349         drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
 350         drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
 351         drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
 352         drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
 353         drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
 354         drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
 355         drvs->rx_dropped_header_too_small =
 356                 port_stats->rx_dropped_header_too_small;
 357         drvs->rx_address_filtered =
 358                                         port_stats->rx_address_filtered +
 359                                         port_stats->rx_vlan_filtered;
 360         drvs->rx_alignment_symbol_errors =
 361                 port_stats->rx_alignment_symbol_errors;
 362
 363         drvs->tx_pauseframes = port_stats->tx_pauseframes;
 364         drvs->tx_controlframes = port_stats->tx_controlframes;
 365
 366         if (adapter->port_num)
 367                 drvs->jabber_events = rxf_stats->port1_jabber_events;
 368         else
 369                 drvs->jabber_events = rxf_stats->port0_jabber_events;
 370         drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
 371         drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
 372         drvs->forwarded_packets = rxf_stats->forwarded_packets;
 373         drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
 374         drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
 375         drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
 376         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 377 }
 378
 379 static void populate_be_v1_stats(struct be_adapter *adapter)
 380 {
 381         struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
 382         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
 383         struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
 384         struct be_port_rxf_stats_v1 *port_stats =
 385                                         &rxf_stats->port[adapter->port_num];
 386         struct be_drv_stats *drvs = &adapter->drv_stats;
 387
 388         be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
 389         drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
 390         drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
 391         drvs->rx_pause_frames = port_stats->rx_pause_frames;
 392         drvs->rx_crc_errors = port_stats->rx_crc_errors;
 393         drvs->rx_control_frames = port_stats->rx_control_frames;
 394         drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
 395         drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
 396         drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
 397         drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
 398         drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
 399         drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
 400         drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
 401         drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
 402         drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
 403         drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
 404         drvs->rx_dropped_header_too_small =
 405                 port_stats->rx_dropped_header_too_small;
 406         drvs->rx_input_fifo_overflow_drop =
 407                 port_stats->rx_input_fifo_overflow_drop;
 408         drvs->rx_address_filtered = port_stats->rx_address_filtered;
 409         drvs->rx_alignment_symbol_errors =
 410                 port_stats->rx_alignment_symbol_errors;
 411         drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
 412         drvs->tx_pauseframes = port_stats->tx_pauseframes;
 413         drvs->tx_controlframes = port_stats->tx_controlframes;
 414         drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
 415         drvs->jabber_events = port_stats->jabber_events;
 416         drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
 417         drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
 418         drvs->forwarded_packets = rxf_stats->forwarded_packets;
 419         drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
 420         drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
 421         drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
 422         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 423 }
 424
 425 static void populate_lancer_stats(struct be_adapter *adapter)
 426 {
 427
 428         struct be_drv_stats *drvs = &adapter->drv_stats;
 429         struct lancer_pport_stats *pport_stats =
 430                                         pport_stats_from_cmd(adapter);
 431
 432         be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
 433         drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
 434         drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
 435         drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
 436         drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
 437         drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
 438         drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
 439         drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
 440         drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
 441         drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
 442         drvs->rx_dropped_tcp_length =
 443                                 pport_stats->rx_dropped_invalid_tcp_length;
 444         drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
 445         drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
 446         drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
 447         drvs->rx_dropped_header_too_small =
 448                                 pport_stats->rx_dropped_header_too_small;
 449         drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
 450         drvs->rx_address_filtered =
 451                                         pport_stats->rx_address_filtered +
 452                                         pport_stats->rx_vlan_filtered;
 453         drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
 454         drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
 455         drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
 456         drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
 457         drvs->jabber_events = pport_stats->rx_jabbers;
 458         drvs->forwarded_packets = pport_stats->num_forwards_lo;
 459         drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
 460         drvs->rx_drops_too_many_frags =
 461                                 pport_stats->rx_drops_too_many_frags_lo;
 462 }
 463
 464 static void accumulate_16bit_val(u32 *acc, u16 val)
 465 {
 466 #define lo(x)                   (x & 0xFFFF)
 467 #define hi(x)                   (x & 0xFFFF0000)
 468         bool wrapped = val < lo(*acc);
 469         u32 newacc = hi(*acc) + val;
 470
 471         if (wrapped)
 472                 newacc += 65536;
 473         ACCESS_ONCE(*acc) = newacc;
 474 }
 475
 476 static void populate_erx_stats(struct be_adapter *adapter,
 477                         struct be_rx_obj *rxo,
 478                         u32 erx_stat)
 479 {
 480         if (!BEx_chip(adapter))
 481                 rx_stats(rxo)->rx_drops_no_frags = erx_stat;
 482         else
 483                 /* below erx HW counter can actually wrap around after
 484                  * 65535. Driver accumulates a 32-bit value
 485                  */
 486                 accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
 487                                      (u16)erx_stat);
 488 }
 489
 490 void be_parse_stats(struct be_adapter *adapter)
 491 {
 492         struct be_erx_stats_v1 *erx = be_erx_stats_from_cmd(adapter);
 493         struct be_rx_obj *rxo;
 494         int i;
 495         u32 erx_stat;
 496
 497         if (lancer_chip(adapter)) {
 498                 populate_lancer_stats(adapter);
 499         } else {
 500                 if (BE2_chip(adapter))
 501                         populate_be_v0_stats(adapter);
 502                 else
 503                         /* for BE3 and Skyhawk */
 504                         populate_be_v1_stats(adapter);
 505
 506                 /* as erx_v1 is longer than v0, ok to use v1 for v0 access */
 507                 for_all_rx_queues(adapter, rxo, i) {
 508                         erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
 509                         populate_erx_stats(adapter, rxo, erx_stat);
 510                 }
 511         }
 512 }
 513
 514 static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
 515                                         struct rtnl_link_stats64 *stats)
 516 {
 517         struct be_adapter *adapter = netdev_priv(netdev);
 518         struct be_drv_stats *drvs = &adapter->drv_stats;
 519         struct be_rx_obj *rxo;
 520         struct be_tx_obj *txo;
 521         u64 pkts, bytes;
 522         unsigned int start;
 523         int i;
 524
 525         for_all_rx_queues(adapter, rxo, i) {
 526                 const struct be_rx_stats *rx_stats = rx_stats(rxo);
 527                 do {
 528                         start = u64_stats_fetch_begin_bh(&rx_stats->sync);
 529                         pkts = rx_stats(rxo)->rx_pkts;
 530                         bytes = rx_stats(rxo)->rx_bytes;
 531                 } while (u64_stats_fetch_retry_bh(&rx_stats->sync, start));
 532                 stats->rx_packets += pkts;
 533                 stats->rx_bytes += bytes;
 534                 stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
 535                 stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
 536                                         rx_stats(rxo)->rx_drops_no_frags;
 537         }
 538
 539         for_all_tx_queues(adapter, txo, i) {
 540                 const struct be_tx_stats *tx_stats = tx_stats(txo);
 541                 do {
 542                         start = u64_stats_fetch_begin_bh(&tx_stats->sync);
 543                         pkts = tx_stats(txo)->tx_pkts;
 544                         bytes = tx_stats(txo)->tx_bytes;
 545                 } while (u64_stats_fetch_retry_bh(&tx_stats->sync, start));
 546                 stats->tx_packets += pkts;
 547                 stats->tx_bytes += bytes;
 548         }
 549
 550         /* bad pkts received */
 551         stats->rx_errors = drvs->rx_crc_errors +
 552                 drvs->rx_alignment_symbol_errors +
 553                 drvs->rx_in_range_errors +
 554                 drvs->rx_out_range_errors +
 555                 drvs->rx_frame_too_long +
 556                 drvs->rx_dropped_too_small +
 557                 drvs->rx_dropped_too_short +
 558                 drvs->rx_dropped_header_too_small +
 559                 drvs->rx_dropped_tcp_length +
 560                 drvs->rx_dropped_runt;
 561
 562         /* detailed rx errors */
 563         stats->rx_length_errors = drvs->rx_in_range_errors +
 564                 drvs->rx_out_range_errors +
 565                 drvs->rx_frame_too_long;
 566
 567         stats->rx_crc_errors = drvs->rx_crc_errors;
 568
 569         /* frame alignment errors */
 570         stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
 571
 572         /* receiver fifo overrun */
 573         /* drops_no_pbuf is no per i/f, it's per BE card */
 574         stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
 575                                 drvs->rx_input_fifo_overflow_drop +
 576                                 drvs->rx_drops_no_pbuf;
 577         return stats;
 578 }
 579
 580 void be_link_status_update(struct be_adapter *adapter, u8 link_status)
 581 {
 582         struct net_device *netdev = adapter->netdev;
 583
 584         if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
 585                 netif_carrier_off(netdev);
 586                 adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
 587         }
 588
 589         if ((link_status & LINK_STATUS_MASK) == LINK_UP)
 590                 netif_carrier_on(netdev);
 591         else
 592                 netif_carrier_off(netdev);
 593 }
 594
 595 static void be_tx_stats_update(struct be_tx_obj *txo,
 596                         u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
 597 {
 598         struct be_tx_stats *stats = tx_stats(txo);
 599
 600         u64_stats_update_begin(&stats->sync);
 601         stats->tx_reqs++;
 602         stats->tx_wrbs += wrb_cnt;
 603         stats->tx_bytes += copied;
 604         stats->tx_pkts += (gso_segs ? gso_segs : 1);
 605         if (stopped)
 606                 stats->tx_stops++;
 607         u64_stats_update_end(&stats->sync);
 608 }
 609
 610 /* Determine number of WRB entries needed to xmit data in an skb */
 611 static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
 612                                                                 bool *dummy)
 613 {
 614         int cnt = (skb->len > skb->data_len);
 615
 616         cnt += skb_shinfo(skb)->nr_frags;
 617
 618         /* to account for hdr wrb */
 619         cnt++;
 620         if (lancer_chip(adapter) || !(cnt & 1)) {
 621                 *dummy = false;
 622         } else {
 623                 /* add a dummy to make it an even num */
 624                 cnt++;
 625                 *dummy = true;
 626         }
 627         BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
 628         return cnt;
 629 }
 630
 631 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
 632 {
 633         wrb->frag_pa_hi = upper_32_bits(addr);
 634         wrb->frag_pa_lo = addr & 0xFFFFFFFF;
 635         wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
 636         wrb->rsvd0 = 0;
 637 }
 638
 639 static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
 640                                         struct sk_buff *skb)
 641 {
 642         u8 vlan_prio;
 643         u16 vlan_tag;
 644
 645         vlan_tag = vlan_tx_tag_get(skb);
 646         vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
 647         /* If vlan priority provided by OS is NOT in available bmap */
 648         if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
 649                 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
 650                                 adapter->recommended_prio;
 651
 652         return vlan_tag;
 653 }
 654
 655 static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
 656                 struct sk_buff *skb, u32 wrb_cnt, u32 len, bool skip_hw_vlan)
 657 {
 658         u16 vlan_tag;
 659
 660         memset(hdr, 0, sizeof(*hdr));
 661
 662         AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
 663
 664         if (skb_is_gso(skb)) {
 665                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
 666                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
 667                         hdr, skb_shinfo(skb)->gso_size);
 668                 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
 669                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
 670         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 671                 if (is_tcp_pkt(skb))
 672                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
 673                 else if (is_udp_pkt(skb))
 674                         AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
 675         }
 676
 677         if (vlan_tx_tag_present(skb)) {
 678                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
 679                 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
 680                 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
 681         }
 682
 683         /* To skip HW VLAN tagging: evt = 1, compl = 0 */
 684         AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, !skip_hw_vlan);
 685         AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
 686         AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
 687         AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
 688 }
 689
 690 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
 691                 bool unmap_single)
 692 {
 693         dma_addr_t dma;
 694
 695         be_dws_le_to_cpu(wrb, sizeof(*wrb));
 696
 697         dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
 698         if (wrb->frag_len) {
 699                 if (unmap_single)
 700                         dma_unmap_single(dev, dma, wrb->frag_len,
 701                                          DMA_TO_DEVICE);
 702                 else
 703                         dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
 704         }
 705 }
 706
 707 static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
 708                 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb,
 709                 bool skip_hw_vlan)
 710 {
 711         dma_addr_t busaddr;
 712         int i, copied = 0;
 713         struct device *dev = &adapter->pdev->dev;
 714         struct sk_buff *first_skb = skb;
 715         struct be_eth_wrb *wrb;
 716         struct be_eth_hdr_wrb *hdr;
 717         bool map_single = false;
 718         u16 map_head;
 719
 720         hdr = queue_head_node(txq);
 721         queue_head_inc(txq);
 722         map_head = txq->head;
 723
 724         if (skb->len > skb->data_len) {
 725                 int len = skb_headlen(skb);
 726                 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
 727                 if (dma_mapping_error(dev, busaddr))
 728                         goto dma_err;
 729                 map_single = true;
 730                 wrb = queue_head_node(txq);
 731                 wrb_fill(wrb, busaddr, len);
 732                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 733                 queue_head_inc(txq);
 734                 copied += len;
 735         }
 736
 737         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 738                 const struct skb_frag_struct *frag =
 739                         &skb_shinfo(skb)->frags[i];
 740                 busaddr = skb_frag_dma_map(dev, frag, 0,
 741                                            skb_frag_size(frag), DMA_TO_DEVICE);
 742                 if (dma_mapping_error(dev, busaddr))
 743                         goto dma_err;
 744                 wrb = queue_head_node(txq);
 745                 wrb_fill(wrb, busaddr, skb_frag_size(frag));
 746                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 747                 queue_head_inc(txq);
 748                 copied += skb_frag_size(frag);
 749         }
 750
 751         if (dummy_wrb) {
 752                 wrb = queue_head_node(txq);
 753                 wrb_fill(wrb, 0, 0);
 754                 be_dws_cpu_to_le(wrb, sizeof(*wrb));
 755                 queue_head_inc(txq);
 756         }
 757
 758         wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied, skip_hw_vlan);
 759         be_dws_cpu_to_le(hdr, sizeof(*hdr));
 760
 761         return copied;
 762 dma_err:
 763         txq->head = map_head;
 764         while (copied) {
 765                 wrb = queue_head_node(txq);
 766                 unmap_tx_frag(dev, wrb, map_single);
 767                 map_single = false;
 768                 copied -= wrb->frag_len;
 769                 queue_head_inc(txq);
 770         }
 771         return 0;
 772 }
 773
 774 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
 775                                              struct sk_buff *skb,
 776                                              bool *skip_hw_vlan)
 777 {
 778         u16 vlan_tag = 0;
 779
 780         skb = skb_share_check(skb, GFP_ATOMIC);
 781         if (unlikely(!skb))
 782                 return skb;
 783
 784         if (vlan_tx_tag_present(skb))
 785                 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
 786
 787         if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
 788                 if (!vlan_tag)
 789                         vlan_tag = adapter->pvid;
 790                 /* f/w workaround to set skip_hw_vlan = 1, informs the F/W to
 791                  * skip VLAN insertion
 792                  */
 793                 if (skip_hw_vlan)
 794                         *skip_hw_vlan = true;
 795         }
 796
 797         if (vlan_tag) {
 798                 skb = __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
 799                 if (unlikely(!skb))
 800                         return skb;
 801                 skb->vlan_tci = 0;
 802         }
 803
 804         /* Insert the outer VLAN, if any */
 805         if (adapter->qnq_vid) {
 806                 vlan_tag = adapter->qnq_vid;
 807                 skb = __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
 808                 if (unlikely(!skb))
 809                         return skb;
 810                 if (skip_hw_vlan)
 811                         *skip_hw_vlan = true;
 812         }
 813
 814         return skb;
 815 }
 816
 817 static bool be_ipv6_exthdr_check(struct sk_buff *skb)
 818 {
 819         struct ethhdr *eh = (struct ethhdr *)skb->data;
 820         u16 offset = ETH_HLEN;
 821
 822         if (eh->h_proto == htons(ETH_P_IPV6)) {
 823                 struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);
 824
 825                 offset += sizeof(struct ipv6hdr);
 826                 if (ip6h->nexthdr != NEXTHDR_TCP &&
 827                     ip6h->nexthdr != NEXTHDR_UDP) {
 828                         struct ipv6_opt_hdr *ehdr =
 829                                 (struct ipv6_opt_hdr *) (skb->data + offset);
 830
 831                         /* offending pkt: 2nd byte following IPv6 hdr is 0xff */
 832                         if (ehdr->hdrlen == 0xff)
 833                                 return true;
 834                 }
 835         }
 836         return false;
 837 }
 838
 839 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
 840 {
 841         return vlan_tx_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
 842 }
 843
 844 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter,
 845                                 struct sk_buff *skb)
 846 {
 847         return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
 848 }
 849
 850 static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
 851                                            struct sk_buff *skb,
 852                                            bool *skip_hw_vlan)
 853 {
 854         struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
 855         unsigned int eth_hdr_len;
 856         struct iphdr *ip;
 857
 858         /* Lancer ASIC has a bug wherein packets that are 32 bytes or less
 859          * may cause a transmit stall on that port. So the work-around is to
 860          * pad such packets to a 36-byte length.
 861          */
 862         if (unlikely(lancer_chip(adapter) && skb->len <= 32)) {
 863                 if (skb_padto(skb, 36))
 864                         goto tx_drop;
 865                 skb->len = 36;
 866         }
 867
 868         /* For padded packets, BE HW modifies tot_len field in IP header
 869          * incorrecly when VLAN tag is inserted by HW.
 870          * For padded packets, Lancer computes incorrect checksum.
 871          */
 872         eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
 873                                                 VLAN_ETH_HLEN : ETH_HLEN;
 874         if (skb->len <= 60 &&
 875             (lancer_chip(adapter) || vlan_tx_tag_present(skb)) &&
 876             is_ipv4_pkt(skb)) {
 877                 ip = (struct iphdr *)ip_hdr(skb);
 878                 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
 879         }
 880
 881         /* If vlan tag is already inlined in the packet, skip HW VLAN
 882          * tagging in UMC mode
 883          */
 884         if ((adapter->function_mode & UMC_ENABLED) &&
 885             veh->h_vlan_proto == htons(ETH_P_8021Q))
 886                         *skip_hw_vlan = true;
 887
 888         /* HW has a bug wherein it will calculate CSUM for VLAN
 889          * pkts even though it is disabled.
 890          * Manually insert VLAN in pkt.
 891          */
 892         if (skb->ip_summed != CHECKSUM_PARTIAL &&
 893             vlan_tx_tag_present(skb)) {
 894                 skb = be_insert_vlan_in_pkt(adapter, skb, skip_hw_vlan);
 895                 if (unlikely(!skb))
 896                         goto tx_drop;
 897         }
 898
 899         /* HW may lockup when VLAN HW tagging is requested on
 900          * certain ipv6 packets. Drop such pkts if the HW workaround to
 901          * skip HW tagging is not enabled by FW.
 902          */
 903         if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
 904             (adapter->pvid || adapter->qnq_vid) &&
 905             !qnq_async_evt_rcvd(adapter)))
 906                 goto tx_drop;
 907
 908         /* Manual VLAN tag insertion to prevent:
 909          * ASIC lockup when the ASIC inserts VLAN tag into
 910          * certain ipv6 packets. Insert VLAN tags in driver,
 911          * and set event, completion, vlan bits accordingly
 912          * in the Tx WRB.
 913          */
 914         if (be_ipv6_tx_stall_chk(adapter, skb) &&
 915             be_vlan_tag_tx_chk(adapter, skb)) {
 916                 skb = be_insert_vlan_in_pkt(adapter, skb, skip_hw_vlan);
 917                 if (unlikely(!skb))
 918                         goto tx_drop;
 919         }
 920
 921         return skb;
 922 tx_drop:
 923         dev_kfree_skb_any(skb);
 924         return NULL;
 925 }
 926
 927 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
 928 {
 929         struct be_adapter *adapter = netdev_priv(netdev);
 930         struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
 931         struct be_queue_info *txq = &txo->q;
 932         bool dummy_wrb, stopped = false;
 933         u32 wrb_cnt = 0, copied = 0;
 934         bool skip_hw_vlan = false;
 935         u32 start = txq->head;
 936
 937         skb = be_xmit_workarounds(adapter, skb, &skip_hw_vlan);
 938         if (!skb)
 939                 return NETDEV_TX_OK;
 940
 941         wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
 942
 943         copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb,
 944                               skip_hw_vlan);
 945         if (copied) {
 946                 int gso_segs = skb_shinfo(skb)->gso_segs;
 947
 948                 /* record the sent skb in the sent_skb table */
 949                 BUG_ON(txo->sent_skb_list[start]);
 950                 txo->sent_skb_list[start] = skb;
 951
 952                 /* Ensure txq has space for the next skb; Else stop the queue
 953                  * *BEFORE* ringing the tx doorbell, so that we serialze the
 954                  * tx compls of the current transmit which'll wake up the queue
 955                  */
 956                 atomic_add(wrb_cnt, &txq->used);
 957                 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
 958                                                                 txq->len) {
 959                         netif_stop_subqueue(netdev, skb_get_queue_mapping(skb));
 960                         stopped = true;
 961                 }
 962
 963                 be_txq_notify(adapter, txo, wrb_cnt);
 964
 965                 be_tx_stats_update(txo, wrb_cnt, copied, gso_segs, stopped);
 966         } else {
 967                 txq->head = start;
 968                 dev_kfree_skb_any(skb);
 969         }
 970         return NETDEV_TX_OK;
 971 }
 972
 973 static int be_change_mtu(struct net_device *netdev, int new_mtu)
 974 {
 975         struct be_adapter *adapter = netdev_priv(netdev);
 976         if (new_mtu < BE_MIN_MTU ||
 977                         new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
 978                                         (ETH_HLEN + ETH_FCS_LEN))) {
 979                 dev_info(&adapter->pdev->dev,
 980                         "MTU must be between %d and %d bytes\n",
 981                         BE_MIN_MTU,
 982                         (BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
 983                 return -EINVAL;
 984         }
 985         dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
 986                         netdev->mtu, new_mtu);
 987         netdev->mtu = new_mtu;
 988         return 0;
 989 }
 990
 991 /*
 992  * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
 993  * If the user configures more, place BE in vlan promiscuous mode.
 994  */
 995 static int be_vid_config(struct be_adapter *adapter)
 996 {
 997         u16 vids[BE_NUM_VLANS_SUPPORTED];
 998         u16 num = 0, i;
 999         int status = 0;
1000
1001         /* No need to further configure vids if in promiscuous mode */
1002         if (adapter->promiscuous)
1003                 return 0;
1004
1005         if (adapter->vlans_added > be_max_vlans(adapter))
1006                 goto set_vlan_promisc;
1007
1008         /* Construct VLAN Table to give to HW */
1009         for (i = 0; i < VLAN_N_VID; i++)
1010                 if (adapter->vlan_tag[i])
1011                         vids[num++] = cpu_to_le16(i);
1012
1013         status = be_cmd_vlan_config(adapter, adapter->if_handle,
1014                                     vids, num, 1, 0);
1015
1016         /* Set to VLAN promisc mode as setting VLAN filter failed */
1017         if (status) {
1018                 dev_info(&adapter->pdev->dev, "Exhausted VLAN HW filters.\n");
1019                 dev_info(&adapter->pdev->dev, "Disabling HW VLAN filtering.\n");
1020                 goto set_vlan_promisc;
1021         }
1022
1023         return status;
1024
1025 set_vlan_promisc:
1026         status = be_cmd_vlan_config(adapter, adapter->if_handle,
1027                                     NULL, 0, 1, 1);
1028         return status;
1029 }
1030
1031 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
1032 {
1033         struct be_adapter *adapter = netdev_priv(netdev);
1034         int status = 0;
1035
1036         if (!lancer_chip(adapter) && !be_physfn(adapter)) {
1037                 status = -EINVAL;
1038                 goto ret;
1039         }
1040
1041         /* Packets with VID 0 are always received by Lancer by default */
1042         if (lancer_chip(adapter) && vid == 0)
1043                 goto ret;
1044
1045         adapter->vlan_tag[vid] = 1;
1046         if (adapter->vlans_added <= (be_max_vlans(adapter) + 1))
1047                 status = be_vid_config(adapter);
1048
1049         if (!status)
1050                 adapter->vlans_added++;
1051         else
1052                 adapter->vlan_tag[vid] = 0;
1053 ret:
1054         return status;
1055 }
1056
1057 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
1058 {
1059         struct be_adapter *adapter = netdev_priv(netdev);
1060         int status = 0;
1061
1062         if (!lancer_chip(adapter) && !be_physfn(adapter)) {
1063                 status = -EINVAL;
1064                 goto ret;
1065         }
1066
1067         /* Packets with VID 0 are always received by Lancer by default */
1068         if (lancer_chip(adapter) && vid == 0)
1069                 goto ret;
1070
1071         adapter->vlan_tag[vid] = 0;
1072         if (adapter->vlans_added <= be_max_vlans(adapter))
1073                 status = be_vid_config(adapter);
1074
1075         if (!status)
1076                 adapter->vlans_added--;
1077         else
1078                 adapter->vlan_tag[vid] = 1;
1079 ret:
1080         return status;
1081 }
1082
1083 static void be_set_rx_mode(struct net_device *netdev)
1084 {
1085         struct be_adapter *adapter = netdev_priv(netdev);
1086         int status;
1087
1088         if (netdev->flags & IFF_PROMISC) {
1089                 be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
1090                 adapter->promiscuous = true;
1091                 goto done;
1092         }
1093
1094         /* BE was previously in promiscuous mode; disable it */
1095         if (adapter->promiscuous) {
1096                 adapter->promiscuous = false;
1097                 be_cmd_rx_filter(adapter, IFF_PROMISC, OFF);
1098
1099                 if (adapter->vlans_added)
1100                         be_vid_config(adapter);
1101         }
1102
1103         /* Enable multicast promisc if num configured exceeds what we support */
1104         if (netdev->flags & IFF_ALLMULTI ||
1105             netdev_mc_count(netdev) > be_max_mc(adapter)) {
1106                 be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
1107                 goto done;
1108         }
1109
1110         if (netdev_uc_count(netdev) != adapter->uc_macs) {
1111                 struct netdev_hw_addr *ha;
1112                 int i = 1; /* First slot is claimed by the Primary MAC */
1113
1114                 for (; adapter->uc_macs > 0; adapter->uc_macs--, i++) {
1115                         be_cmd_pmac_del(adapter, adapter->if_handle,
1116                                         adapter->pmac_id[i], 0);
1117                 }
1118
1119                 if (netdev_uc_count(netdev) > be_max_uc(adapter)) {
1120                         be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
1121                         adapter->promiscuous = true;
1122                         goto done;
1123                 }
1124
1125                 netdev_for_each_uc_addr(ha, adapter->netdev) {
1126                         adapter->uc_macs++; /* First slot is for Primary MAC */
1127                         be_cmd_pmac_add(adapter, (u8 *)ha->addr,
1128                                         adapter->if_handle,
1129                                         &adapter->pmac_id[adapter->uc_macs], 0);
1130                 }
1131         }
1132
1133         status = be_cmd_rx_filter(adapter, IFF_MULTICAST, ON);
1134
1135         /* Set to MCAST promisc mode if setting MULTICAST address fails */
1136         if (status) {
1137                 dev_info(&adapter->pdev->dev, "Exhausted multicast HW filters.\n");
1138                 dev_info(&adapter->pdev->dev, "Disabling HW multicast filtering.\n");
1139                 be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
1140         }
1141 done:
1142         return;
1143 }
1144
1145 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1146 {
1147         struct be_adapter *adapter = netdev_priv(netdev);
1148         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1149         int status;
1150
1151         if (!sriov_enabled(adapter))
1152                 return -EPERM;
1153
1154         if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
1155                 return -EINVAL;
1156
1157         if (BEx_chip(adapter)) {
1158                 be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id,
1159                                 vf + 1);
1160
1161                 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
1162                                          &vf_cfg->pmac_id, vf + 1);
1163         } else {
1164                 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
1165                                         vf + 1);
1166         }
1167
1168         if (status)
1169                 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
1170                                 mac, vf);
1171         else
1172                 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
1173
1174         return status;
1175 }
1176
1177 static int be_get_vf_config(struct net_device *netdev, int vf,
1178                         struct ifla_vf_info *vi)
1179 {
1180         struct be_adapter *adapter = netdev_priv(netdev);
1181         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1182
1183         if (!sriov_enabled(adapter))
1184                 return -EPERM;
1185
1186         if (vf >= adapter->num_vfs)
1187                 return -EINVAL;
1188
1189         vi->vf = vf;
1190         vi->tx_rate = vf_cfg->tx_rate;
1191         vi->vlan = vf_cfg->vlan_tag;
1192         vi->qos = 0;
1193         memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
1194
1195         return 0;
1196 }
1197
1198 static int be_set_vf_vlan(struct net_device *netdev,
1199                         int vf, u16 vlan, u8 qos)
1200 {
1201         struct be_adapter *adapter = netdev_priv(netdev);
1202         int status = 0;
1203
1204         if (!sriov_enabled(adapter))
1205                 return -EPERM;
1206
1207         if (vf >= adapter->num_vfs || vlan > 4095)
1208                 return -EINVAL;
1209
1210         if (vlan) {
1211                 if (adapter->vf_cfg[vf].vlan_tag != vlan) {
1212                         /* If this is new value, program it. Else skip. */
1213                         adapter->vf_cfg[vf].vlan_tag = vlan;
1214
1215                         status = be_cmd_set_hsw_config(adapter, vlan,
1216                                 vf + 1, adapter->vf_cfg[vf].if_handle, 0);
1217                 }
1218         } else {
1219                 /* Reset Transparent Vlan Tagging. */
1220                 adapter->vf_cfg[vf].vlan_tag = 0;
1221                 vlan = adapter->vf_cfg[vf].def_vid;
1222                 status = be_cmd_set_hsw_config(adapter, vlan, vf + 1,
1223                         adapter->vf_cfg[vf].if_handle, 0);
1224         }
1225
1226
1227         if (status)
1228                 dev_info(&adapter->pdev->dev,
1229                                 "VLAN %d config on VF %d failed\n", vlan, vf);
1230         return status;
1231 }
1232
1233 static int be_set_vf_tx_rate(struct net_device *netdev,
1234                         int vf, int rate)
1235 {
1236         struct be_adapter *adapter = netdev_priv(netdev);
1237         int status = 0;
1238
1239         if (!sriov_enabled(adapter))
1240                 return -EPERM;
1241
1242         if (vf >= adapter->num_vfs)
1243                 return -EINVAL;
1244
1245         if (rate < 100 || rate > 10000) {
1246                 dev_err(&adapter->pdev->dev,
1247                         "tx rate must be between 100 and 10000 Mbps\n");
1248                 return -EINVAL;
1249         }
1250
1251         if (lancer_chip(adapter))
1252                 status = be_cmd_set_profile_config(adapter, rate / 10, vf + 1);
1253         else
1254                 status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
1255
1256         if (status)
1257                 dev_err(&adapter->pdev->dev,
1258                                 "tx rate %d on VF %d failed\n", rate, vf);
1259         else
1260                 adapter->vf_cfg[vf].tx_rate = rate;
1261         return status;
1262 }
1263
1264 static void be_eqd_update(struct be_adapter *adapter, struct be_eq_obj *eqo)
1265 {
1266         struct be_rx_stats *stats = rx_stats(&adapter->rx_obj[eqo->idx]);
1267         ulong now = jiffies;
1268         ulong delta = now - stats->rx_jiffies;
1269         u64 pkts;
1270         unsigned int start, eqd;
1271
1272         if (!eqo->enable_aic) {
1273                 eqd = eqo->eqd;
1274                 goto modify_eqd;
1275         }
1276
1277         if (eqo->idx >= adapter->num_rx_qs)
1278                 return;
1279
1280         stats = rx_stats(&adapter->rx_obj[eqo->idx]);
1281
1282         /* Wrapped around */
1283         if (time_before(now, stats->rx_jiffies)) {
1284                 stats->rx_jiffies = now;
1285                 return;
1286         }
1287
1288         /* Update once a second */
1289         if (delta < HZ)
1290                 return;
1291
1292         do {
1293                 start = u64_stats_fetch_begin_bh(&stats->sync);
1294                 pkts = stats->rx_pkts;
1295         } while (u64_stats_fetch_retry_bh(&stats->sync, start));
1296
1297         stats->rx_pps = (unsigned long)(pkts - stats->rx_pkts_prev) / (delta / HZ);
1298         stats->rx_pkts_prev = pkts;
1299         stats->rx_jiffies = now;
1300         eqd = (stats->rx_pps / 110000) << 3;
1301         eqd = min(eqd, eqo->max_eqd);
1302         eqd = max(eqd, eqo->min_eqd);
1303         if (eqd < 10)
1304                 eqd = 0;
1305
1306 modify_eqd:
1307         if (eqd != eqo->cur_eqd) {
1308                 be_cmd_modify_eqd(adapter, eqo->q.id, eqd);
1309                 eqo->cur_eqd = eqd;
1310         }
1311 }
1312
1313 static void be_rx_stats_update(struct be_rx_obj *rxo,
1314                 struct be_rx_compl_info *rxcp)
1315 {
1316         struct be_rx_stats *stats = rx_stats(rxo);
1317
1318         u64_stats_update_begin(&stats->sync);
1319         stats->rx_compl++;
1320         stats->rx_bytes += rxcp->pkt_size;
1321         stats->rx_pkts++;
1322         if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1323                 stats->rx_mcast_pkts++;
1324         if (rxcp->err)
1325                 stats->rx_compl_err++;
1326         u64_stats_update_end(&stats->sync);
1327 }
1328
1329 static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1330 {
1331         /* L4 checksum is not reliable for non TCP/UDP packets.
1332          * Also ignore ipcksm for ipv6 pkts */
1333         return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
1334                                 (rxcp->ip_csum || rxcp->ipv6);
1335 }
1336
1337 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo,
1338                                                 u16 frag_idx)
1339 {
1340         struct be_adapter *adapter = rxo->adapter;
1341         struct be_rx_page_info *rx_page_info;
1342         struct be_queue_info *rxq = &rxo->q;
1343
1344         rx_page_info = &rxo->page_info_tbl[frag_idx];
1345         BUG_ON(!rx_page_info->page);
1346
1347         if (rx_page_info->last_page_user) {
1348                 dma_unmap_page(&adapter->pdev->dev,
1349                                dma_unmap_addr(rx_page_info, bus),
1350                                adapter->big_page_size, DMA_FROM_DEVICE);
1351                 rx_page_info->last_page_user = false;
1352         }
1353
1354         atomic_dec(&rxq->used);
1355         return rx_page_info;
1356 }
1357
1358 /* Throwaway the data in the Rx completion */
1359 static void be_rx_compl_discard(struct be_rx_obj *rxo,
1360                                 struct be_rx_compl_info *rxcp)
1361 {
1362         struct be_queue_info *rxq = &rxo->q;
1363         struct be_rx_page_info *page_info;
1364         u16 i, num_rcvd = rxcp->num_rcvd;
1365
1366         for (i = 0; i < num_rcvd; i++) {
1367                 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1368                 put_page(page_info->page);
1369                 memset(page_info, 0, sizeof(*page_info));
1370                 index_inc(&rxcp->rxq_idx, rxq->len);
1371         }
1372 }
1373
1374 /*
1375  * skb_fill_rx_data forms a complete skb for an ether frame
1376  * indicated by rxcp.
1377  */
1378 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
1379                              struct be_rx_compl_info *rxcp)
1380 {
1381         struct be_queue_info *rxq = &rxo->q;
1382         struct be_rx_page_info *page_info;
1383         u16 i, j;
1384         u16 hdr_len, curr_frag_len, remaining;
1385         u8 *start;
1386
1387         page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1388         start = page_address(page_info->page) + page_info->page_offset;
1389         prefetch(start);
1390
1391         /* Copy data in the first descriptor of this completion */
1392         curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
1393
1394         skb->len = curr_frag_len;
1395         if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
1396                 memcpy(skb->data, start, curr_frag_len);
1397                 /* Complete packet has now been moved to data */
1398                 put_page(page_info->page);
1399                 skb->data_len = 0;
1400                 skb->tail += curr_frag_len;
1401         } else {
1402                 hdr_len = ETH_HLEN;
1403                 memcpy(skb->data, start, hdr_len);
1404                 skb_shinfo(skb)->nr_frags = 1;
1405                 skb_frag_set_page(skb, 0, page_info->page);
1406                 skb_shinfo(skb)->frags[0].page_offset =
1407                                         page_info->page_offset + hdr_len;
1408                 skb_frag_size_set(&skb_shinfo(skb)->frags[0], curr_frag_len - hdr_len);
1409                 skb->data_len = curr_frag_len - hdr_len;
1410                 skb->truesize += rx_frag_size;
1411                 skb->tail += hdr_len;
1412         }
1413         page_info->page = NULL;
1414
1415         if (rxcp->pkt_size <= rx_frag_size) {
1416                 BUG_ON(rxcp->num_rcvd != 1);
1417                 return;
1418         }
1419
1420         /* More frags present for this completion */
1421         index_inc(&rxcp->rxq_idx, rxq->len);
1422         remaining = rxcp->pkt_size - curr_frag_len;
1423         for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
1424                 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1425                 curr_frag_len = min(remaining, rx_frag_size);
1426
1427                 /* Coalesce all frags from the same physical page in one slot */
1428                 if (page_info->page_offset == 0) {
1429                         /* Fresh page */
1430                         j++;
1431                         skb_frag_set_page(skb, j, page_info->page);
1432                         skb_shinfo(skb)->frags[j].page_offset =
1433                                                         page_info->page_offset;
1434                         skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1435                         skb_shinfo(skb)->nr_frags++;
1436                 } else {
1437                         put_page(page_info->page);
1438                 }
1439
1440                 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
1441                 skb->len += curr_frag_len;
1442                 skb->data_len += curr_frag_len;
1443                 skb->truesize += rx_frag_size;
1444                 remaining -= curr_frag_len;
1445                 index_inc(&rxcp->rxq_idx, rxq->len);
1446                 page_info->page = NULL;
1447         }
1448         BUG_ON(j > MAX_SKB_FRAGS);
1449 }
1450
1451 /* Process the RX completion indicated by rxcp when GRO is disabled */
1452 static void be_rx_compl_process(struct be_rx_obj *rxo,
1453                                 struct be_rx_compl_info *rxcp)
1454 {
1455         struct be_adapter *adapter = rxo->adapter;
1456         struct net_device *netdev = adapter->netdev;
1457         struct sk_buff *skb;
1458
1459         skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
1460         if (unlikely(!skb)) {
1461                 rx_stats(rxo)->rx_drops_no_skbs++;
1462                 be_rx_compl_discard(rxo, rxcp);
1463                 return;
1464         }
1465
1466         skb_fill_rx_data(rxo, skb, rxcp);
1467
1468         if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1469                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1470         else
1471                 skb_checksum_none_assert(skb);
1472
1473         skb->protocol = eth_type_trans(skb, netdev);
1474         skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
1475         if (netdev->features & NETIF_F_RXHASH)
1476                 skb->rxhash = rxcp->rss_hash;
1477
1478
1479         if (rxcp->vlanf)
1480                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
1481
1482         netif_receive_skb(skb);
1483 }
1484
1485 /* Process the RX completion indicated by rxcp when GRO is enabled */
1486 static void be_rx_compl_process_gro(struct be_rx_obj *rxo,
1487                                     struct napi_struct *napi,
1488                                     struct be_rx_compl_info *rxcp)
1489 {
1490         struct be_adapter *adapter = rxo->adapter;
1491         struct be_rx_page_info *page_info;
1492         struct sk_buff *skb = NULL;
1493         struct be_queue_info *rxq = &rxo->q;
1494         u16 remaining, curr_frag_len;
1495         u16 i, j;
1496
1497         skb = napi_get_frags(napi);
1498         if (!skb) {
1499                 be_rx_compl_discard(rxo, rxcp);
1500                 return;
1501         }
1502
1503         remaining = rxcp->pkt_size;
1504         for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
1505                 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1506
1507                 curr_frag_len = min(remaining, rx_frag_size);
1508
1509                 /* Coalesce all frags from the same physical page in one slot */
1510                 if (i == 0 || page_info->page_offset == 0) {
1511                         /* First frag or Fresh page */
1512                         j++;
1513                         skb_frag_set_page(skb, j, page_info->page);
1514                         skb_shinfo(skb)->frags[j].page_offset =
1515                                                         page_info->page_offset;
1516                         skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1517                 } else {
1518                         put_page(page_info->page);
1519                 }
1520                 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
1521                 skb->truesize += rx_frag_size;
1522                 remaining -= curr_frag_len;
1523                 index_inc(&rxcp->rxq_idx, rxq->len);
1524                 memset(page_info, 0, sizeof(*page_info));
1525         }
1526         BUG_ON(j > MAX_SKB_FRAGS);
1527
1528         skb_shinfo(skb)->nr_frags = j + 1;
1529         skb->len = rxcp->pkt_size;
1530         skb->data_len = rxcp->pkt_size;
1531         skb->ip_summed = CHECKSUM_UNNECESSARY;
1532         skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
1533         if (adapter->netdev->features & NETIF_F_RXHASH)
1534                 skb->rxhash = rxcp->rss_hash;
1535
1536         if (rxcp->vlanf)
1537                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
1538
1539         napi_gro_frags(napi);
1540 }
1541
1542 static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
1543                                  struct be_rx_compl_info *rxcp)
1544 {
1545         rxcp->pkt_size =
1546                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, pktsize, compl);
1547         rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtp, compl);
1548         rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, err, compl);
1549         rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, tcpf, compl);
1550         rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1551         rxcp->ip_csum =
1552                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ipcksm, compl);
1553         rxcp->l4_csum =
1554                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, l4_cksm, compl);
1555         rxcp->ipv6 =
1556                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ip_version, compl);
1557         rxcp->rxq_idx =
1558                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, fragndx, compl);
1559         rxcp->num_rcvd =
1560                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
1561         rxcp->pkt_type =
1562                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
1563         rxcp->rss_hash =
1564                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, compl);
1565         if (rxcp->vlanf) {
1566                 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1567                                           compl);
1568                 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
1569                                                compl);
1570         }
1571         rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, port, compl);
1572 }
1573
1574 static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
1575                                  struct be_rx_compl_info *rxcp)
1576 {
1577         rxcp->pkt_size =
1578                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, pktsize, compl);
1579         rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtp, compl);
1580         rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, err, compl);
1581         rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, tcpf, compl);
1582         rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1583         rxcp->ip_csum =
1584                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ipcksm, compl);
1585         rxcp->l4_csum =
1586                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, l4_cksm, compl);
1587         rxcp->ipv6 =
1588                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ip_version, compl);
1589         rxcp->rxq_idx =
1590                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, fragndx, compl);
1591         rxcp->num_rcvd =
1592                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
1593         rxcp->pkt_type =
1594                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
1595         rxcp->rss_hash =
1596                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, compl);
1597         if (rxcp->vlanf) {
1598                 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1599                                           compl);
1600                 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
1601                                                compl);
1602         }
1603         rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, port, compl);
1604         rxcp->ip_frag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0,
1605                                       ip_frag, compl);
1606 }
1607
1608 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
1609 {
1610         struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
1611         struct be_rx_compl_info *rxcp = &rxo->rxcp;
1612         struct be_adapter *adapter = rxo->adapter;
1613
1614         /* For checking the valid bit it is Ok to use either definition as the
1615          * valid bit is at the same position in both v0 and v1 Rx compl */
1616         if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
1617                 return NULL;
1618
1619         rmb();
1620         be_dws_le_to_cpu(compl, sizeof(*compl));
1621
1622         if (adapter->be3_native)
1623                 be_parse_rx_compl_v1(compl, rxcp);
1624         else
1625                 be_parse_rx_compl_v0(compl, rxcp);
1626
1627         if (rxcp->ip_frag)
1628                 rxcp->l4_csum = 0;
1629
1630         if (rxcp->vlanf) {
1631                 /* vlanf could be wrongly set in some cards.
1632                  * ignore if vtm is not set */
1633                 if ((adapter->function_mode & FLEX10_MODE) && !rxcp->vtm)
1634                         rxcp->vlanf = 0;
1635
1636                 if (!lancer_chip(adapter))
1637                         rxcp->vlan_tag = swab16(rxcp->vlan_tag);
1638
1639                 if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
1640                     !adapter->vlan_tag[rxcp->vlan_tag])
1641                         rxcp->vlanf = 0;
1642         }
1643
1644         /* As the compl has been parsed, reset it; we wont touch it again */
1645         compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
1646
1647         queue_tail_inc(&rxo->cq);
1648         return rxcp;
1649 }
1650
1651 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
1652 {
1653         u32 order = get_order(size);
1654
1655         if (order > 0)
1656                 gfp |= __GFP_COMP;
1657         return  alloc_pages(gfp, order);
1658 }
1659
1660 /*
1661  * Allocate a page, split it to fragments of size rx_frag_size and post as
1662  * receive buffers to BE
1663  */
1664 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
1665 {
1666         struct be_adapter *adapter = rxo->adapter;
1667         struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1668         struct be_queue_info *rxq = &rxo->q;
1669         struct page *pagep = NULL;
1670         struct be_eth_rx_d *rxd;
1671         u64 page_dmaaddr = 0, frag_dmaaddr;
1672         u32 posted, page_offset = 0;
1673
1674         page_info = &rxo->page_info_tbl[rxq->head];
1675         for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1676                 if (!pagep) {
1677                         pagep = be_alloc_pages(adapter->big_page_size, gfp);
1678                         if (unlikely(!pagep)) {
1679                                 rx_stats(rxo)->rx_post_fail++;
1680                                 break;
1681                         }
1682                         page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
1683                                                     0, adapter->big_page_size,
1684                                                     DMA_FROM_DEVICE);
1685                         page_info->page_offset = 0;
1686                 } else {
1687                         get_page(pagep);
1688                         page_info->page_offset = page_offset + rx_frag_size;
1689                 }
1690                 page_offset = page_info->page_offset;
1691                 page_info->page = pagep;
1692                 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
1693                 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
1694
1695                 rxd = queue_head_node(rxq);
1696                 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
1697                 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
1698
1699                 /* Any space left in the current big page for another frag? */
1700                 if ((page_offset + rx_frag_size + rx_frag_size) >
1701                                         adapter->big_page_size) {
1702                         pagep = NULL;
1703                         page_info->last_page_user = true;
1704                 }
1705
1706                 prev_page_info = page_info;
1707                 queue_head_inc(rxq);
1708                 page_info = &rxo->page_info_tbl[rxq->head];
1709         }
1710         if (pagep)
1711                 prev_page_info->last_page_user = true;
1712
1713         if (posted) {
1714                 atomic_add(posted, &rxq->used);
1715                 be_rxq_notify(adapter, rxq->id, posted);
1716         } else if (atomic_read(&rxq->used) == 0) {
1717                 /* Let be_worker replenish when memory is available */
1718                 rxo->rx_post_starved = true;
1719         }
1720 }
1721
1722 static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
1723 {
1724         struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
1725
1726         if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
1727                 return NULL;
1728
1729         rmb();
1730         be_dws_le_to_cpu(txcp, sizeof(*txcp));
1731
1732         txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
1733
1734         queue_tail_inc(tx_cq);
1735         return txcp;
1736 }
1737
1738 static u16 be_tx_compl_process(struct be_adapter *adapter,
1739                 struct be_tx_obj *txo, u16 last_index)
1740 {
1741         struct be_queue_info *txq = &txo->q;
1742         struct be_eth_wrb *wrb;
1743         struct sk_buff **sent_skbs = txo->sent_skb_list;
1744         struct sk_buff *sent_skb;
1745         u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
1746         bool unmap_skb_hdr = true;
1747
1748         sent_skb = sent_skbs[txq->tail];
1749         BUG_ON(!sent_skb);
1750         sent_skbs[txq->tail] = NULL;
1751
1752         /* skip header wrb */
1753         queue_tail_inc(txq);
1754
1755         do {
1756                 cur_index = txq->tail;
1757                 wrb = queue_tail_node(txq);
1758                 unmap_tx_frag(&adapter->pdev->dev, wrb,
1759                               (unmap_skb_hdr && skb_headlen(sent_skb)));
1760                 unmap_skb_hdr = false;
1761
1762                 num_wrbs++;
1763                 queue_tail_inc(txq);
1764         } while (cur_index != last_index);
1765
1766         kfree_skb(sent_skb);
1767         return num_wrbs;
1768 }
1769
1770 /* Return the number of events in the event queue */
1771 static inline int events_get(struct be_eq_obj *eqo)
1772 {
1773         struct be_eq_entry *eqe;
1774         int num = 0;
1775
1776         do {
1777                 eqe = queue_tail_node(&eqo->q);
1778                 if (eqe->evt == 0)
1779                         break;
1780
1781                 rmb();
1782                 eqe->evt = 0;
1783                 num++;
1784                 queue_tail_inc(&eqo->q);
1785         } while (true);
1786
1787         return num;
1788 }
1789
1790 /* Leaves the EQ is disarmed state */
1791 static void be_eq_clean(struct be_eq_obj *eqo)
1792 {
1793         int num = events_get(eqo);
1794
1795         be_eq_notify(eqo->adapter, eqo->q.id, false, true, num);
1796 }
1797
1798 static void be_rx_cq_clean(struct be_rx_obj *rxo)
1799 {
1800         struct be_rx_page_info *page_info;
1801         struct be_queue_info *rxq = &rxo->q;
1802         struct be_queue_info *rx_cq = &rxo->cq;
1803         struct be_rx_compl_info *rxcp;
1804         struct be_adapter *adapter = rxo->adapter;
1805         int flush_wait = 0;
1806         u16 tail;
1807
1808         /* Consume pending rx completions.
1809          * Wait for the flush completion (identified by zero num_rcvd)
1810          * to arrive. Notify CQ even when there are no more CQ entries
1811          * for HW to flush partially coalesced CQ entries.
1812          * In Lancer, there is no need to wait for flush compl.
1813          */
1814         for (;;) {
1815                 rxcp = be_rx_compl_get(rxo);
1816                 if (rxcp == NULL) {
1817                         if (lancer_chip(adapter))
1818                                 break;
1819
1820                         if (flush_wait++ > 10 || be_hw_error(adapter)) {
1821                                 dev_warn(&adapter->pdev->dev,
1822                                          "did not receive flush compl\n");
1823                                 break;
1824                         }
1825                         be_cq_notify(adapter, rx_cq->id, true, 0);
1826                         mdelay(1);
1827                 } else {
1828                         be_rx_compl_discard(rxo, rxcp);
1829                         be_cq_notify(adapter, rx_cq->id, false, 1);
1830                         if (rxcp->num_rcvd == 0)
1831                                 break;
1832                 }
1833         }
1834
1835         /* After cleanup, leave the CQ in unarmed state */
1836         be_cq_notify(adapter, rx_cq->id, false, 0);
1837
1838         /* Then free posted rx buffers that were not used */
1839         tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1840         for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1841                 page_info = get_rx_page_info(rxo, tail);
1842                 put_page(page_info->page);
1843                 memset(page_info, 0, sizeof(*page_info));
1844         }
1845         BUG_ON(atomic_read(&rxq->used));
1846         rxq->tail = rxq->head = 0;
1847 }
1848
1849 static void be_tx_compl_clean(struct be_adapter *adapter)
1850 {
1851         struct be_tx_obj *txo;
1852         struct be_queue_info *txq;
1853         struct be_eth_tx_compl *txcp;
1854         u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
1855         struct sk_buff *sent_skb;
1856         bool dummy_wrb;
1857         int i, pending_txqs;
1858
1859         /* Wait for a max of 200ms for all the tx-completions to arrive. */
1860         do {
1861                 pending_txqs = adapter->num_tx_qs;
1862
1863                 for_all_tx_queues(adapter, txo, i) {
1864                         txq = &txo->q;
1865                         while ((txcp = be_tx_compl_get(&txo->cq))) {
1866                                 end_idx =
1867                                         AMAP_GET_BITS(struct amap_eth_tx_compl,
1868                                                       wrb_index, txcp);
1869                                 num_wrbs += be_tx_compl_process(adapter, txo,
1870                                                                 end_idx);
1871                                 cmpl++;
1872                         }
1873                         if (cmpl) {
1874                                 be_cq_notify(adapter, txo->cq.id, false, cmpl);
1875                                 atomic_sub(num_wrbs, &txq->used);
1876                                 cmpl = 0;
1877                                 num_wrbs = 0;
1878                         }
1879                         if (atomic_read(&txq->used) == 0)
1880                                 pending_txqs--;
1881                 }
1882
1883                 if (pending_txqs == 0 || ++timeo > 200)
1884                         break;
1885
1886                 mdelay(1);
1887         } while (true);
1888
1889         for_all_tx_queues(adapter, txo, i) {
1890                 txq = &txo->q;
1891                 if (atomic_read(&txq->used))
1892                         dev_err(&adapter->pdev->dev, "%d pending tx-compls\n",
1893                                 atomic_read(&txq->used));
1894
1895                 /* free posted tx for which compls will never arrive */
1896                 while (atomic_read(&txq->used)) {
1897                         sent_skb = txo->sent_skb_list[txq->tail];
1898                         end_idx = txq->tail;
1899                         num_wrbs = wrb_cnt_for_skb(adapter, sent_skb,
1900                                                    &dummy_wrb);
1901                         index_adv(&end_idx, num_wrbs - 1, txq->len);
1902                         num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
1903                         atomic_sub(num_wrbs, &txq->used);
1904                 }
1905         }
1906 }
1907
1908 static void be_evt_queues_destroy(struct be_adapter *adapter)
1909 {
1910         struct be_eq_obj *eqo;
1911         int i;
1912
1913         for_all_evt_queues(adapter, eqo, i) {
1914                 if (eqo->q.created) {
1915                         be_eq_clean(eqo);
1916                         be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
1917                         netif_napi_del(&eqo->napi);
1918                 }
1919                 be_queue_free(adapter, &eqo->q);
1920         }
1921 }
1922
1923 static int be_evt_queues_create(struct be_adapter *adapter)
1924 {
1925         struct be_queue_info *eq;
1926         struct be_eq_obj *eqo;
1927         int i, rc;
1928
1929         adapter->num_evt_qs = min_t(u16, num_irqs(adapter),
1930                                     adapter->cfg_num_qs);
1931
1932         for_all_evt_queues(adapter, eqo, i) {
1933                 netif_napi_add(adapter->netdev, &eqo->napi, be_poll,
1934                                BE_NAPI_WEIGHT);
1935                 eqo->adapter = adapter;
1936                 eqo->tx_budget = BE_TX_BUDGET;
1937                 eqo->idx = i;
1938                 eqo->max_eqd = BE_MAX_EQD;
1939                 eqo->enable_aic = true;
1940
1941                 eq = &eqo->q;
1942                 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1943                                         sizeof(struct be_eq_entry));
1944                 if (rc)
1945                         return rc;
1946
1947                 rc = be_cmd_eq_create(adapter, eqo);
1948                 if (rc)
1949                         return rc;
1950         }
1951         return 0;
1952 }
1953
1954 static void be_mcc_queues_destroy(struct be_adapter *adapter)
1955 {
1956         struct be_queue_info *q;
1957
1958         q = &adapter->mcc_obj.q;
1959         if (q->created)
1960                 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1961         be_queue_free(adapter, q);
1962
1963         q = &adapter->mcc_obj.cq;
1964         if (q->created)
1965                 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1966         be_queue_free(adapter, q);
1967 }
1968
1969 /* Must be called only after TX qs are created as MCC shares TX EQ */
1970 static int be_mcc_queues_create(struct be_adapter *adapter)
1971 {
1972         struct be_queue_info *q, *cq;
1973
1974         cq = &adapter->mcc_obj.cq;
1975         if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1976                         sizeof(struct be_mcc_compl)))
1977                 goto err;
1978
1979         /* Use the default EQ for MCC completions */
1980         if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
1981                 goto mcc_cq_free;
1982
1983         q = &adapter->mcc_obj.q;
1984         if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1985                 goto mcc_cq_destroy;
1986
1987         if (be_cmd_mccq_create(adapter, q, cq))
1988                 goto mcc_q_free;
1989
1990         return 0;
1991
1992 mcc_q_free:
1993         be_queue_free(adapter, q);
1994 mcc_cq_destroy:
1995         be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1996 mcc_cq_free:
1997         be_queue_free(adapter, cq);
1998 err:
1999         return -1;
2000 }
2001
2002 static void be_tx_queues_destroy(struct be_adapter *adapter)
2003 {
2004         struct be_queue_info *q;
2005         struct be_tx_obj *txo;
2006         u8 i;
2007
2008         for_all_tx_queues(adapter, txo, i) {
2009                 q = &txo->q;
2010                 if (q->created)
2011                         be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
2012                 be_queue_free(adapter, q);
2013
2014                 q = &txo->cq;
2015                 if (q->created)
2016                         be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2017                 be_queue_free(adapter, q);
2018         }
2019 }
2020
2021 static int be_tx_qs_create(struct be_adapter *adapter)
2022 {
2023         struct be_queue_info *cq, *eq;
2024         struct be_tx_obj *txo;
2025         int status, i;
2026
2027         adapter->num_tx_qs = min(adapter->num_evt_qs, be_max_txqs(adapter));
2028
2029         for_all_tx_queues(adapter, txo, i) {
2030                 cq = &txo->cq;
2031                 status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
2032                                         sizeof(struct be_eth_tx_compl));
2033                 if (status)
2034                         return status;
2035
2036                 /* If num_evt_qs is less than num_tx_qs, then more than
2037                  * one txq share an eq
2038                  */
2039                 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2040                 status = be_cmd_cq_create(adapter, cq, eq, false, 3);
2041                 if (status)
2042                         return status;
2043
2044                 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
2045                                         sizeof(struct be_eth_wrb));
2046                 if (status)
2047                         return status;
2048
2049                 status = be_cmd_txq_create(adapter, txo);
2050                 if (status)
2051                         return status;
2052         }
2053
2054         dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
2055                  adapter->num_tx_qs);
2056         return 0;
2057 }
2058
2059 static void be_rx_cqs_destroy(struct be_adapter *adapter)
2060 {
2061         struct be_queue_info *q;
2062         struct be_rx_obj *rxo;
2063         int i;
2064
2065         for_all_rx_queues(adapter, rxo, i) {
2066                 q = &rxo->cq;
2067                 if (q->created)
2068                         be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2069                 be_queue_free(adapter, q);
2070         }
2071 }
2072
2073 static int be_rx_cqs_create(struct be_adapter *adapter)
2074 {
2075         struct be_queue_info *eq, *cq;
2076         struct be_rx_obj *rxo;
2077         int rc, i;
2078
2079         /* We can create as many RSS rings as there are EQs. */
2080         adapter->num_rx_qs = adapter->num_evt_qs;
2081
2082         /* We'll use RSS only if atleast 2 RSS rings are supported.
2083          * When RSS is used, we'll need a default RXQ for non-IP traffic.
2084          */
2085         if (adapter->num_rx_qs > 1)
2086                 adapter->num_rx_qs++;
2087
2088         adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
2089         for_all_rx_queues(adapter, rxo, i) {
2090                 rxo->adapter = adapter;
2091                 cq = &rxo->cq;
2092                 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
2093                                 sizeof(struct be_eth_rx_compl));
2094                 if (rc)
2095                         return rc;
2096
2097                 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2098                 rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
2099                 if (rc)
2100                         return rc;
2101         }
2102
2103         dev_info(&adapter->pdev->dev,
2104                  "created %d RSS queue(s) and 1 default RX queue\n",
2105                  adapter->num_rx_qs - 1);
2106         return 0;
2107 }
2108
2109 static irqreturn_t be_intx(int irq, void *dev)
2110 {
2111         struct be_eq_obj *eqo = dev;
2112         struct be_adapter *adapter = eqo->adapter;
2113         int num_evts = 0;
2114
2115         /* IRQ is not expected when NAPI is scheduled as the EQ
2116          * will not be armed.
2117          * But, this can happen on Lancer INTx where it takes
2118          * a while to de-assert INTx or in BE2 where occasionaly
2119          * an interrupt may be raised even when EQ is unarmed.
2120          * If NAPI is already scheduled, then counting & notifying
2121          * events will orphan them.
2122          */
2123         if (napi_schedule_prep(&eqo->napi)) {
2124                 num_evts = events_get(eqo);
2125                 __napi_schedule(&eqo->napi);
2126                 if (num_evts)
2127                         eqo->spurious_intr = 0;
2128         }
2129         be_eq_notify(adapter, eqo->q.id, false, true, num_evts);
2130
2131         /* Return IRQ_HANDLED only for the the first spurious intr
2132          * after a valid intr to stop the kernel from branding
2133          * this irq as a bad one!
2134          */
2135         if (num_evts || eqo->spurious_intr++ == 0)
2136                 return IRQ_HANDLED;
2137         else
2138                 return IRQ_NONE;
2139 }
2140
2141 static irqreturn_t be_msix(int irq, void *dev)
2142 {
2143         struct be_eq_obj *eqo = dev;
2144
2145         be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0);
2146         napi_schedule(&eqo->napi);
2147         return IRQ_HANDLED;
2148 }
2149
2150 static inline bool do_gro(struct be_rx_compl_info *rxcp)
2151 {
2152         return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false;
2153 }
2154
2155 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
2156                         int budget)
2157 {
2158         struct be_adapter *adapter = rxo->adapter;
2159         struct be_queue_info *rx_cq = &rxo->cq;
2160         struct be_rx_compl_info *rxcp;
2161         u32 work_done;
2162
2163         for (work_done = 0; work_done < budget; work_done++) {
2164                 rxcp = be_rx_compl_get(rxo);
2165                 if (!rxcp)
2166                         break;
2167
2168                 /* Is it a flush compl that has no data */
2169                 if (unlikely(rxcp->num_rcvd == 0))
2170                         goto loop_continue;
2171
2172                 /* Discard compl with partial DMA Lancer B0 */
2173                 if (unlikely(!rxcp->pkt_size)) {
2174                         be_rx_compl_discard(rxo, rxcp);
2175                         goto loop_continue;
2176                 }
2177
2178                 /* On BE drop pkts that arrive due to imperfect filtering in
2179                  * promiscuous mode on some skews
2180                  */
2181                 if (unlikely(rxcp->port != adapter->port_num &&
2182                                 !lancer_chip(adapter))) {
2183                         be_rx_compl_discard(rxo, rxcp);
2184                         goto loop_continue;
2185                 }
2186
2187                 if (do_gro(rxcp))
2188                         be_rx_compl_process_gro(rxo, napi, rxcp);
2189                 else
2190                         be_rx_compl_process(rxo, rxcp);
2191 loop_continue:
2192                 be_rx_stats_update(rxo, rxcp);
2193         }
2194
2195         if (work_done) {
2196                 be_cq_notify(adapter, rx_cq->id, true, work_done);
2197
2198                 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
2199                         be_post_rx_frags(rxo, GFP_ATOMIC);
2200         }
2201
2202         return work_done;
2203 }
2204
2205 static bool be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
2206                           int budget, int idx)
2207 {
2208         struct be_eth_tx_compl *txcp;
2209         int num_wrbs = 0, work_done;
2210
2211         for (work_done = 0; work_done < budget; work_done++) {
2212                 txcp = be_tx_compl_get(&txo->cq);
2213                 if (!txcp)
2214                         break;
2215                 num_wrbs += be_tx_compl_process(adapter, txo,
2216                                 AMAP_GET_BITS(struct amap_eth_tx_compl,
2217                                         wrb_index, txcp));
2218         }
2219
2220         if (work_done) {
2221                 be_cq_notify(adapter, txo->cq.id, true, work_done);
2222                 atomic_sub(num_wrbs, &txo->q.used);
2223
2224                 /* As Tx wrbs have been freed up, wake up netdev queue
2225                  * if it was stopped due to lack of tx wrbs.  */
2226                 if (__netif_subqueue_stopped(adapter->netdev, idx) &&
2227                         atomic_read(&txo->q.used) < txo->q.len / 2) {
2228                         netif_wake_subqueue(adapter->netdev, idx);
2229                 }
2230
2231                 u64_stats_update_begin(&tx_stats(txo)->sync_compl);
2232                 tx_stats(txo)->tx_compl += work_done;
2233                 u64_stats_update_end(&tx_stats(txo)->sync_compl);
2234         }
2235         return (work_done < budget); /* Done */
2236 }
2237
2238 int be_poll(struct napi_struct *napi, int budget)
2239 {
2240         struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
2241         struct be_adapter *adapter = eqo->adapter;
2242         int max_work = 0, work, i, num_evts;
2243         bool tx_done;
2244
2245         num_evts = events_get(eqo);
2246
2247         /* Process all TXQs serviced by this EQ */
2248         for (i = eqo->idx; i < adapter->num_tx_qs; i += adapter->num_evt_qs) {
2249                 tx_done = be_process_tx(adapter, &adapter->tx_obj[i],
2250                                         eqo->tx_budget, i);
2251                 if (!tx_done)
2252                         max_work = budget;
2253         }
2254
2255         /* This loop will iterate twice for EQ0 in which
2256          * completions of the last RXQ (default one) are also processed
2257          * For other EQs the loop iterates only once
2258          */
2259         for (i = eqo->idx; i < adapter->num_rx_qs; i += adapter->num_evt_qs) {
2260                 work = be_process_rx(&adapter->rx_obj[i], napi, budget);
2261                 max_work = max(work, max_work);
2262         }
2263
2264         if (is_mcc_eqo(eqo))
2265                 be_process_mcc(adapter);
2266
2267         if (max_work < budget) {
2268                 napi_complete(napi);
2269                 be_eq_notify(adapter, eqo->q.id, true, false, num_evts);
2270         } else {
2271                 /* As we'll continue in polling mode, count and clear events */
2272                 be_eq_notify(adapter, eqo->q.id, false, false, num_evts);
2273         }
2274         return max_work;
2275 }
2276
2277 void be_detect_error(struct be_adapter *adapter)
2278 {
2279         u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
2280         u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
2281         u32 i;
2282
2283         if (be_hw_error(adapter))
2284                 return;
2285
2286         if (lancer_chip(adapter)) {
2287                 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
2288                 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2289                         sliport_err1 = ioread32(adapter->db +
2290                                         SLIPORT_ERROR1_OFFSET);
2291                         sliport_err2 = ioread32(adapter->db +
2292                                         SLIPORT_ERROR2_OFFSET);
2293                 }
2294         } else {
2295                 pci_read_config_dword(adapter->pdev,
2296                                 PCICFG_UE_STATUS_LOW, &ue_lo);
2297                 pci_read_config_dword(adapter->pdev,
2298                                 PCICFG_UE_STATUS_HIGH, &ue_hi);
2299                 pci_read_config_dword(adapter->pdev,
2300                                 PCICFG_UE_STATUS_LOW_MASK, &ue_lo_mask);
2301                 pci_read_config_dword(adapter->pdev,
2302                                 PCICFG_UE_STATUS_HI_MASK, &ue_hi_mask);
2303
2304                 ue_lo = (ue_lo & ~ue_lo_mask);
2305                 ue_hi = (ue_hi & ~ue_hi_mask);
2306         }
2307
2308         /* On certain platforms BE hardware can indicate spurious UEs.
2309          * Allow the h/w to stop working completely in case of a real UE.
2310          * Hence not setting the hw_error for UE detection.
2311          */
2312         if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2313                 adapter->hw_error = true;
2314                 dev_err(&adapter->pdev->dev,
2315                         "Error detected in the card\n");
2316         }
2317
2318         if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2319                 dev_err(&adapter->pdev->dev,
2320                         "ERR: sliport status 0x%x\n", sliport_status);
2321                 dev_err(&adapter->pdev->dev,
2322                         "ERR: sliport error1 0x%x\n", sliport_err1);
2323                 dev_err(&adapter->pdev->dev,
2324                         "ERR: sliport error2 0x%x\n", sliport_err2);
2325         }
2326
2327         if (ue_lo) {
2328                 for (i = 0; ue_lo; ue_lo >>= 1, i++) {
2329                         if (ue_lo & 1)
2330                                 dev_err(&adapter->pdev->dev,
2331                                 "UE: %s bit set\n", ue_status_low_desc[i]);
2332                 }
2333         }
2334
2335         if (ue_hi) {
2336                 for (i = 0; ue_hi; ue_hi >>= 1, i++) {
2337                         if (ue_hi & 1)
2338                                 dev_err(&adapter->pdev->dev,
2339                                 "UE: %s bit set\n", ue_status_hi_desc[i]);
2340                 }
2341         }
2342
2343 }
2344
2345 static void be_msix_disable(struct be_adapter *adapter)
2346 {
2347         if (msix_enabled(adapter)) {
2348                 pci_disable_msix(adapter->pdev);
2349                 adapter->num_msix_vec = 0;
2350                 adapter->num_msix_roce_vec = 0;
2351         }
2352 }
2353
2354 static int be_msix_enable(struct be_adapter *adapter)
2355 {
2356         int i, status, num_vec;
2357         struct device *dev = &adapter->pdev->dev;
2358
2359         /* If RoCE is supported, program the max number of NIC vectors that
2360          * may be configured via set-channels, along with vectors needed for
2361          * RoCe. Else, just program the number we'll use initially.
2362          */
2363         if (be_roce_supported(adapter))
2364                 num_vec = min_t(int, 2 * be_max_eqs(adapter),
2365                                 2 * num_online_cpus());
2366         else
2367                 num_vec = adapter->cfg_num_qs;
2368
2369         for (i = 0; i < num_vec; i++)
2370                 adapter->msix_entries[i].entry = i;
2371
2372         status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
2373         if (status == 0) {
2374                 goto done;
2375         } else if (status >= MIN_MSIX_VECTORS) {
2376                 num_vec = status;
2377                 status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
2378                                          num_vec);
2379                 if (!status)
2380                         goto done;
2381         }
2382
2383         dev_warn(dev, "MSIx enable failed\n");
2384
2385         /* INTx is not supported in VFs, so fail probe if enable_msix fails */
2386         if (!be_physfn(adapter))
2387                 return status;
2388         return 0;
2389 done:
2390         if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) {
2391                 adapter->num_msix_roce_vec = num_vec / 2;
2392                 dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n",
2393                          adapter->num_msix_roce_vec);
2394         }
2395
2396         adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec;
2397
2398         dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n",
2399                  adapter->num_msix_vec);
2400         return 0;
2401 }
2402
2403 static inline int be_msix_vec_get(struct be_adapter *adapter,
2404                                 struct be_eq_obj *eqo)
2405 {
2406         return adapter->msix_entries[eqo->msix_idx].vector;
2407 }
2408
2409 static int be_msix_register(struct be_adapter *adapter)
2410 {
2411         struct net_device *netdev = adapter->netdev;
2412         struct be_eq_obj *eqo;
2413         int status, i, vec;
2414
2415         for_all_evt_queues(adapter, eqo, i) {
2416                 sprintf(eqo->desc, "%s-q%d", netdev->name, i);
2417                 vec = be_msix_vec_get(adapter, eqo);
2418                 status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
2419                 if (status)
2420                         goto err_msix;
2421         }
2422
2423         return 0;
2424 err_msix:
2425         for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
2426                 free_irq(be_msix_vec_get(adapter, eqo), eqo);
2427         dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
2428                 status);
2429         be_msix_disable(adapter);
2430         return status;
2431 }
2432
2433 static int be_irq_register(struct be_adapter *adapter)
2434 {
2435         struct net_device *netdev = adapter->netdev;
2436         int status;
2437
2438         if (msix_enabled(adapter)) {
2439                 status = be_msix_register(adapter);
2440                 if (status == 0)
2441                         goto done;
2442                 /* INTx is not supported for VF */
2443                 if (!be_physfn(adapter))
2444                         return status;
2445         }
2446
2447         /* INTx: only the first EQ is used */
2448         netdev->irq = adapter->pdev->irq;
2449         status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
2450                              &adapter->eq_obj[0]);
2451         if (status) {
2452                 dev_err(&adapter->pdev->dev,
2453                         "INTx request IRQ failed - err %d\n", status);
2454                 return status;
2455         }
2456 done:
2457         adapter->isr_registered = true;
2458         return 0;
2459 }
2460
2461 static void be_irq_unregister(struct be_adapter *adapter)
2462 {
2463         struct net_device *netdev = adapter->netdev;
2464         struct be_eq_obj *eqo;
2465         int i;
2466
2467         if (!adapter->isr_registered)
2468                 return;
2469
2470         /* INTx */
2471         if (!msix_enabled(adapter)) {
2472                 free_irq(netdev->irq, &adapter->eq_obj[0]);
2473                 goto done;
2474         }
2475
2476         /* MSIx */
2477         for_all_evt_queues(adapter, eqo, i)
2478                 free_irq(be_msix_vec_get(adapter, eqo), eqo);
2479
2480 done:
2481         adapter->isr_registered = false;
2482 }
2483
2484 static void be_rx_qs_destroy(struct be_adapter *adapter)
2485 {
2486         struct be_queue_info *q;
2487         struct be_rx_obj *rxo;
2488         int i;
2489
2490         for_all_rx_queues(adapter, rxo, i) {
2491                 q = &rxo->q;
2492                 if (q->created) {
2493                         be_cmd_rxq_destroy(adapter, q);
2494                         be_rx_cq_clean(rxo);
2495                 }
2496                 be_queue_free(adapter, q);
2497         }
2498 }
2499
2500 static int be_close(struct net_device *netdev)
2501 {
2502         struct be_adapter *adapter = netdev_priv(netdev);
2503         struct be_eq_obj *eqo;
2504         int i;
2505
2506         be_roce_dev_close(adapter);
2507
2508         if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
2509                 for_all_evt_queues(adapter, eqo, i)
2510                         napi_disable(&eqo->napi);
2511                 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED;
2512         }
2513
2514         be_async_mcc_disable(adapter);
2515
2516         /* Wait for all pending tx completions to arrive so that
2517          * all tx skbs are freed.
2518          */
2519         netif_tx_disable(netdev);
2520         be_tx_compl_clean(adapter);
2521
2522         be_rx_qs_destroy(adapter);
2523
2524         for_all_evt_queues(adapter, eqo, i) {
2525                 if (msix_enabled(adapter))
2526                         synchronize_irq(be_msix_vec_get(adapter, eqo));
2527                 else
2528                         synchronize_irq(netdev->irq);
2529                 be_eq_clean(eqo);
2530         }
2531
2532         be_irq_unregister(adapter);
2533
2534         return 0;
2535 }
2536
2537 static int be_rx_qs_create(struct be_adapter *adapter)
2538 {
2539         struct be_rx_obj *rxo;
2540         int rc, i, j;
2541         u8 rsstable[128];
2542
2543         for_all_rx_queues(adapter, rxo, i) {
2544                 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
2545                                     sizeof(struct be_eth_rx_d));
2546                 if (rc)
2547                         return rc;
2548         }
2549
2550         /* The FW would like the default RXQ to be created first */
2551         rxo = default_rxo(adapter);
2552         rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, rx_frag_size,
2553                                adapter->if_handle, false, &rxo->rss_id);
2554         if (rc)
2555                 return rc;
2556
2557         for_all_rss_queues(adapter, rxo, i) {
2558                 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
2559                                        rx_frag_size, adapter->if_handle,
2560                                        true, &rxo->rss_id);
2561                 if (rc)
2562                         return rc;
2563         }
2564
2565         if (be_multi_rxq(adapter)) {
2566                 for (j = 0; j < 128; j += adapter->num_rx_qs - 1) {
2567                         for_all_rss_queues(adapter, rxo, i) {
2568                                 if ((j + i) >= 128)
2569                                         break;
2570                                 rsstable[j + i] = rxo->rss_id;
2571                         }
2572                 }
2573                 adapter->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 |
2574                                         RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6;
2575
2576                 if (!BEx_chip(adapter))
2577                         adapter->rss_flags |= RSS_ENABLE_UDP_IPV4 |
2578                                                 RSS_ENABLE_UDP_IPV6;
2579
2580                 rc = be_cmd_rss_config(adapter, rsstable, adapter->rss_flags,
2581                                        128);
2582                 if (rc) {
2583                         adapter->rss_flags = 0;
2584                         return rc;
2585                 }
2586         }
2587
2588         /* First time posting */
2589         for_all_rx_queues(adapter, rxo, i)
2590                 be_post_rx_frags(rxo, GFP_KERNEL);
2591         return 0;
2592 }
2593
2594 static int be_open(struct net_device *netdev)
2595 {
2596         struct be_adapter *adapter = netdev_priv(netdev);
2597         struct be_eq_obj *eqo;
2598         struct be_rx_obj *rxo;
2599         struct be_tx_obj *txo;
2600         u8 link_status;
2601         int status, i;
2602
2603         status = be_rx_qs_create(adapter);
2604         if (status)
2605                 goto err;
2606
2607         status = be_irq_register(adapter);
2608         if (status)
2609                 goto err;
2610
2611         for_all_rx_queues(adapter, rxo, i)
2612                 be_cq_notify(adapter, rxo->cq.id, true, 0);
2613
2614         for_all_tx_queues(adapter, txo, i)
2615                 be_cq_notify(adapter, txo->cq.id, true, 0);
2616
2617         be_async_mcc_enable(adapter);
2618
2619         for_all_evt_queues(adapter, eqo, i) {
2620                 napi_enable(&eqo->napi);
2621                 be_eq_notify(adapter, eqo->q.id, true, false, 0);
2622         }
2623         adapter->flags |= BE_FLAGS_NAPI_ENABLED;
2624
2625         status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
2626         if (!status)
2627                 be_link_status_update(adapter, link_status);
2628
2629         netif_tx_start_all_queues(netdev);
2630         be_roce_dev_open(adapter);
2631         return 0;
2632 err:
2633         be_close(adapter->netdev);
2634         return -EIO;
2635 }
2636
2637 static int be_setup_wol(struct be_adapter *adapter, bool enable)
2638 {
2639         struct be_dma_mem cmd;
2640         int status = 0;
2641         u8 mac[ETH_ALEN];
2642
2643         memset(mac, 0, ETH_ALEN);
2644
2645         cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2646         cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
2647                                      GFP_KERNEL);
2648         if (cmd.va == NULL)
2649                 return -1;
2650
2651         if (enable) {
2652                 status = pci_write_config_dword(adapter->pdev,
2653                         PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
2654                 if (status) {
2655                         dev_err(&adapter->pdev->dev,
2656                                 "Could not enable Wake-on-lan\n");
2657                         dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
2658                                           cmd.dma);
2659                         return status;
2660                 }
2661                 status = be_cmd_enable_magic_wol(adapter,
2662                                 adapter->netdev->dev_addr, &cmd);
2663                 pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
2664                 pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
2665         } else {
2666                 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
2667                 pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
2668                 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2669         }
2670
2671         dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2672         return status;
2673 }
2674
2675 /*
2676  * Generate a seed MAC address from the PF MAC Address using jhash.
2677  * MAC Address for VFs are assigned incrementally starting from the seed.
2678  * These addresses are programmed in the ASIC by the PF and the VF driver
2679  * queries for the MAC address during its probe.
2680  */
2681 static int be_vf_eth_addr_config(struct be_adapter *adapter)
2682 {
2683         u32 vf;
2684         int status = 0;
2685         u8 mac[ETH_ALEN];
2686         struct be_vf_cfg *vf_cfg;
2687
2688         be_vf_eth_addr_generate(adapter, mac);
2689
2690         for_all_vfs(adapter, vf_cfg, vf) {
2691                 if (BEx_chip(adapter))
2692                         status = be_cmd_pmac_add(adapter, mac,
2693                                                  vf_cfg->if_handle,
2694                                                  &vf_cfg->pmac_id, vf + 1);
2695                 else
2696                         status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
2697                                                 vf + 1);
2698
2699                 if (status)
2700                         dev_err(&adapter->pdev->dev,
2701                         "Mac address assignment failed for VF %d\n", vf);
2702                 else
2703                         memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
2704
2705                 mac[5] += 1;
2706         }
2707         return status;
2708 }
2709
2710 static int be_vfs_mac_query(struct be_adapter *adapter)
2711 {
2712         int status, vf;
2713         u8 mac[ETH_ALEN];
2714         struct be_vf_cfg *vf_cfg;
2715         bool active = false;
2716
2717         for_all_vfs(adapter, vf_cfg, vf) {
2718                 be_cmd_get_mac_from_list(adapter, mac, &active,
2719                                          &vf_cfg->pmac_id, 0);
2720
2721                 status = be_cmd_mac_addr_query(adapter, mac, false,
2722                                                vf_cfg->if_handle, 0);
2723                 if (status)
2724                         return status;
2725                 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
2726         }
2727         return 0;
2728 }
2729
2730 static void be_vf_clear(struct be_adapter *adapter)
2731 {
2732         struct be_vf_cfg *vf_cfg;
2733         u32 vf;
2734
2735         if (pci_vfs_assigned(adapter->pdev)) {
2736                 dev_warn(&adapter->pdev->dev,
2737                          "VFs are assigned to VMs: not disabling VFs\n");
2738                 goto done;
2739         }
2740
2741         pci_disable_sriov(adapter->pdev);
2742
2743         for_all_vfs(adapter, vf_cfg, vf) {
2744                 if (BEx_chip(adapter))
2745                         be_cmd_pmac_del(adapter, vf_cfg->if_handle,
2746                                         vf_cfg->pmac_id, vf + 1);
2747                 else
2748                         be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle,
2749                                        vf + 1);
2750
2751                 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
2752         }
2753 done:
2754         kfree(adapter->vf_cfg);
2755         adapter->num_vfs = 0;
2756 }
2757
2758 static void be_clear_queues(struct be_adapter *adapter)
2759 {
2760         be_mcc_queues_destroy(adapter);
2761         be_rx_cqs_destroy(adapter);
2762         be_tx_queues_destroy(adapter);
2763         be_evt_queues_destroy(adapter);
2764 }
2765
2766 static void be_cancel_worker(struct be_adapter *adapter)
2767 {
2768         if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
2769                 cancel_delayed_work_sync(&adapter->work);
2770                 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
2771         }
2772 }
2773
2774 static int be_clear(struct be_adapter *adapter)
2775 {
2776         int i;
2777
2778         be_cancel_worker(adapter);
2779
2780         if (sriov_enabled(adapter))
2781                 be_vf_clear(adapter);
2782
2783         /* delete the primary mac along with the uc-mac list */
2784         for (i = 0; i < (adapter->uc_macs + 1); i++)
2785                 be_cmd_pmac_del(adapter, adapter->if_handle,
2786                                 adapter->pmac_id[i], 0);
2787         adapter->uc_macs = 0;
2788
2789         be_cmd_if_destroy(adapter, adapter->if_handle,  0);
2790
2791         be_clear_queues(adapter);
2792
2793         kfree(adapter->pmac_id);
2794         adapter->pmac_id = NULL;
2795
2796         be_msix_disable(adapter);
2797         return 0;
2798 }
2799
2800 static int be_vfs_if_create(struct be_adapter *adapter)
2801 {
2802         struct be_resources res = {0};
2803         struct be_vf_cfg *vf_cfg;
2804         u32 cap_flags, en_flags, vf;
2805         int status;
2806
2807         cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
2808                     BE_IF_FLAGS_MULTICAST;
2809
2810         for_all_vfs(adapter, vf_cfg, vf) {
2811                 if (!BE3_chip(adapter)) {
2812                         status = be_cmd_get_profile_config(adapter, &res,
2813                                                            vf + 1);
2814                         if (!status)
2815                                 cap_flags = res.if_cap_flags;
2816                 }
2817
2818                 /* If a FW profile exists, then cap_flags are updated */
2819                 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
2820                            BE_IF_FLAGS_BROADCAST | BE_IF_FLAGS_MULTICAST);
2821                 status = be_cmd_if_create(adapter, cap_flags, en_flags,
2822                                           &vf_cfg->if_handle, vf + 1);
2823                 if (status)
2824                         goto err;
2825         }
2826 err:
2827         return status;
2828 }
2829
2830 static int be_vf_setup_init(struct be_adapter *adapter)
2831 {
2832         struct be_vf_cfg *vf_cfg;
2833         int vf;
2834
2835         adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
2836                                   GFP_KERNEL);
2837         if (!adapter->vf_cfg)
2838                 return -ENOMEM;
2839
2840         for_all_vfs(adapter, vf_cfg, vf) {
2841                 vf_cfg->if_handle = -1;
2842                 vf_cfg->pmac_id = -1;
2843         }
2844         return 0;
2845 }
2846
2847 static int be_vf_setup(struct be_adapter *adapter)
2848 {
2849         struct be_vf_cfg *vf_cfg;
2850         u16 def_vlan, lnk_speed;
2851         int status, old_vfs, vf;
2852         struct device *dev = &adapter->pdev->dev;
2853         u32 privileges;
2854
2855         old_vfs = pci_num_vf(adapter->pdev);
2856         if (old_vfs) {
2857                 dev_info(dev, "%d VFs are already enabled\n", old_vfs);
2858                 if (old_vfs != num_vfs)
2859                         dev_warn(dev, "Ignoring num_vfs=%d setting\n", num_vfs);
2860                 adapter->num_vfs = old_vfs;
2861         } else {
2862                 if (num_vfs > be_max_vfs(adapter))
2863                         dev_info(dev, "Device supports %d VFs and not %d\n",
2864                                  be_max_vfs(adapter), num_vfs);
2865                 adapter->num_vfs = min_t(u16, num_vfs, be_max_vfs(adapter));
2866                 if (!adapter->num_vfs)
2867                         return 0;
2868         }
2869
2870         status = be_vf_setup_init(adapter);
2871         if (status)
2872                 goto err;
2873
2874         if (old_vfs) {
2875                 for_all_vfs(adapter, vf_cfg, vf) {
2876                         status = be_cmd_get_if_id(adapter, vf_cfg, vf);
2877                         if (status)
2878                                 goto err;
2879                 }
2880         } else {
2881                 status = be_vfs_if_create(adapter);
2882                 if (status)
2883                         goto err;
2884         }
2885
2886         if (old_vfs) {
2887                 status = be_vfs_mac_query(adapter);
2888                 if (status)
2889                         goto err;
2890         } else {
2891                 status = be_vf_eth_addr_config(adapter);
2892                 if (status)
2893                         goto err;
2894         }
2895
2896         for_all_vfs(adapter, vf_cfg, vf) {
2897                 /* Allow VFs to programs MAC/VLAN filters */
2898                 status = be_cmd_get_fn_privileges(adapter, &privileges, vf + 1);
2899                 if (!status && !(privileges & BE_PRIV_FILTMGMT)) {
2900                         status = be_cmd_set_fn_privileges(adapter,
2901                                                           privileges |
2902                                                           BE_PRIV_FILTMGMT,
2903                                                           vf + 1);
2904                         if (!status)
2905                                 dev_info(dev, "VF%d has FILTMGMT privilege\n",
2906                                          vf);
2907                 }
2908
2909                 /* BE3 FW, by default, caps VF TX-rate to 100mbps.
2910                  * Allow full available bandwidth
2911                  */
2912                 if (BE3_chip(adapter) && !old_vfs)
2913                         be_cmd_set_qos(adapter, 1000, vf+1);
2914
2915                 status = be_cmd_link_status_query(adapter, &lnk_speed,
2916                                                   NULL, vf + 1);
2917                 if (!status)
2918                         vf_cfg->tx_rate = lnk_speed;
2919
2920                 status = be_cmd_get_hsw_config(adapter, &def_vlan,
2921                                                vf + 1, vf_cfg->if_handle, NULL);
2922                 if (status)
2923                         goto err;
2924                 vf_cfg->def_vid = def_vlan;
2925
2926                 be_cmd_enable_vf(adapter, vf + 1);
2927         }
2928
2929         if (!old_vfs) {
2930                 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
2931                 if (status) {
2932                         dev_err(dev, "SRIOV enable failed\n");
2933                         adapter->num_vfs = 0;
2934                         goto err;
2935                 }
2936         }
2937         return 0;
2938 err:
2939         dev_err(dev, "VF setup failed\n");
2940         be_vf_clear(adapter);
2941         return status;
2942 }
2943
2944 /* On BE2/BE3 FW does not suggest the supported limits */
2945 static void BEx_get_resources(struct be_adapter *adapter,
2946                               struct be_resources *res)
2947 {
2948         struct pci_dev *pdev = adapter->pdev;
2949         bool use_sriov = false;
2950
2951         if (BE3_chip(adapter) && be_physfn(adapter)) {
2952                 int max_vfs;
2953
2954                 max_vfs = pci_sriov_get_totalvfs(pdev);
2955                 res->max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0;
2956                 use_sriov = res->max_vfs && num_vfs;
2957         }
2958
2959         if (be_physfn(adapter))
2960                 res->max_uc_mac = BE_UC_PMAC_COUNT;
2961         else
2962                 res->max_uc_mac = BE_VF_UC_PMAC_COUNT;
2963
2964         if (adapter->function_mode & FLEX10_MODE)
2965                 res->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
2966         else
2967                 res->max_vlans = BE_NUM_VLANS_SUPPORTED;
2968         res->max_mcast_mac = BE_MAX_MC;
2969
2970         if (BE2_chip(adapter) || use_sriov || be_is_mc(adapter) ||
2971             !be_physfn(adapter))
2972                 res->max_tx_qs = 1;
2973         else
2974                 res->max_tx_qs = BE3_MAX_TX_QS;
2975
2976         if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
2977             !use_sriov && be_physfn(adapter))
2978                 res->max_rss_qs = (adapter->be3_native) ?
2979                                            BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
2980         res->max_rx_qs = res->max_rss_qs + 1;
2981
2982         res->max_evt_qs = be_physfn(adapter) ? BE3_MAX_EVT_QS : 1;
2983
2984         res->if_cap_flags = BE_IF_CAP_FLAGS_WANT;
2985         if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS))
2986                 res->if_cap_flags &= ~BE_IF_FLAGS_RSS;
2987 }
2988
2989 static void be_setup_init(struct be_adapter *adapter)
2990 {
2991         adapter->vlan_prio_bmap = 0xff;
2992         adapter->phy.link_speed = -1;
2993         adapter->if_handle = -1;
2994         adapter->be3_native = false;
2995         adapter->promiscuous = false;
2996         if (be_physfn(adapter))
2997                 adapter->cmd_privileges = MAX_PRIVILEGES;
2998         else
2999                 adapter->cmd_privileges = MIN_PRIVILEGES;
3000 }
3001
3002 static int be_get_resources(struct be_adapter *adapter)
3003 {
3004         struct device *dev = &adapter->pdev->dev;
3005         struct be_resources res = {0};
3006         int status;
3007
3008         if (BEx_chip(adapter)) {
3009                 BEx_get_resources(adapter, &res);
3010                 adapter->res = res;
3011         }
3012
3013         /* For BE3 only check if FW suggests a different max-txqs value */
3014         if (BE3_chip(adapter)) {
3015                 status = be_cmd_get_profile_config(adapter, &res, 0);
3016                 if (!status && res.max_tx_qs)
3017                         adapter->res.max_tx_qs =
3018                                 min(adapter->res.max_tx_qs, res.max_tx_qs);
3019         }
3020
3021         /* For Lancer, SH etc read per-function resource limits from FW.
3022          * GET_FUNC_CONFIG returns per function guaranteed limits.
3023          * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits
3024          */
3025         if (!BEx_chip(adapter)) {
3026                 status = be_cmd_get_func_config(adapter, &res);
3027                 if (status)
3028                         return status;
3029
3030                 /* If RoCE may be enabled stash away half the EQs for RoCE */
3031                 if (be_roce_supported(adapter))
3032                         res.max_evt_qs /= 2;
3033                 adapter->res = res;
3034
3035                 if (be_physfn(adapter)) {
3036                         status = be_cmd_get_profile_config(adapter, &res, 0);
3037                         if (status)
3038                                 return status;
3039                         adapter->res.max_vfs = res.max_vfs;
3040                 }
3041
3042                 dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n",
3043                          be_max_txqs(adapter), be_max_rxqs(adapter),
3044                          be_max_rss(adapter), be_max_eqs(adapter),
3045                          be_max_vfs(adapter));
3046                 dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n",
3047                          be_max_uc(adapter), be_max_mc(adapter),
3048                          be_max_vlans(adapter));
3049         }
3050
3051         return 0;
3052 }
3053
3054 /* Routine to query per function resource limits */
3055 static int be_get_config(struct be_adapter *adapter)
3056 {
3057         int status;
3058
3059         status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
3060                                      &adapter->function_mode,
3061                                      &adapter->function_caps,
3062                                      &adapter->asic_rev);
3063         if (status)
3064                 return status;
3065
3066         status = be_get_resources(adapter);
3067         if (status)
3068                 return status;
3069
3070         /* primary mac needs 1 pmac entry */
3071         adapter->pmac_id = kcalloc(be_max_uc(adapter) + 1, sizeof(u32),
3072                                    GFP_KERNEL);
3073         if (!adapter->pmac_id)
3074                 return -ENOMEM;
3075
3076         /* Sanitize cfg_num_qs based on HW and platform limits */
3077         adapter->cfg_num_qs = min(adapter->cfg_num_qs, be_max_qs(adapter));
3078
3079         return 0;
3080 }
3081
3082 static int be_mac_setup(struct be_adapter *adapter)
3083 {
3084         u8 mac[ETH_ALEN];
3085         int status;
3086
3087         if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
3088                 status = be_cmd_get_perm_mac(adapter, mac);
3089                 if (status)
3090                         return status;
3091
3092                 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
3093                 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
3094         } else {
3095                 /* Maybe the HW was reset; dev_addr must be re-programmed */
3096                 memcpy(mac, adapter->netdev->dev_addr, ETH_ALEN);
3097         }
3098
3099         /* On BE3 VFs this cmd may fail due to lack of privilege.
3100          * Ignore the failure as in this case pmac_id is fetched
3101          * in the IFACE_CREATE cmd.
3102          */
3103         be_cmd_pmac_add(adapter, mac, adapter->if_handle,
3104                         &adapter->pmac_id[0], 0);
3105         return 0;
3106 }
3107
3108 static void be_schedule_worker(struct be_adapter *adapter)
3109 {
3110         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
3111         adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
3112 }
3113
3114 static int be_setup_queues(struct be_adapter *adapter)
3115 {
3116         struct net_device *netdev = adapter->netdev;
3117         int status;
3118
3119         status = be_evt_queues_create(adapter);
3120         if (status)
3121                 goto err;
3122
3123         status = be_tx_qs_create(adapter);
3124         if (status)
3125                 goto err;
3126
3127         status = be_rx_cqs_create(adapter);
3128         if (status)
3129                 goto err;
3130
3131         status = be_mcc_queues_create(adapter);
3132         if (status)
3133                 goto err;
3134
3135         status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs);
3136         if (status)
3137                 goto err;
3138
3139         status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs);
3140         if (status)
3141                 goto err;
3142
3143         return 0;
3144 err:
3145         dev_err(&adapter->pdev->dev, "queue_setup failed\n");
3146         return status;
3147 }
3148
3149 int be_update_queues(struct be_adapter *adapter)
3150 {
3151         struct net_device *netdev = adapter->netdev;
3152         int status;
3153
3154         if (netif_running(netdev))
3155                 be_close(netdev);
3156
3157         be_cancel_worker(adapter);
3158
3159         /* If any vectors have been shared with RoCE we cannot re-program
3160          * the MSIx table.
3161          */
3162         if (!adapter->num_msix_roce_vec)
3163                 be_msix_disable(adapter);
3164
3165         be_clear_queues(adapter);
3166
3167         if (!msix_enabled(adapter)) {
3168                 status = be_msix_enable(adapter);
3169                 if (status)
3170                         return status;
3171         }
3172
3173         status = be_setup_queues(adapter);
3174         if (status)
3175                 return status;
3176
3177         be_schedule_worker(adapter);
3178
3179         if (netif_running(netdev))
3180                 status = be_open(netdev);
3181
3182         return status;
3183 }
3184
3185 static int be_setup(struct be_adapter *adapter)
3186 {
3187         struct device *dev = &adapter->pdev->dev;
3188         u32 tx_fc, rx_fc, en_flags;
3189         int status;
3190
3191         be_setup_init(adapter);
3192
3193         if (!lancer_chip(adapter))
3194                 be_cmd_req_native_mode(adapter);
3195
3196         status = be_get_config(adapter);
3197         if (status)
3198                 goto err;
3199
3200         status = be_msix_enable(adapter);
3201         if (status)
3202                 goto err;
3203
3204         en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3205                    BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3206         if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
3207                 en_flags |= BE_IF_FLAGS_RSS;
3208         en_flags = en_flags & be_if_cap_flags(adapter);
3209         status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
3210                                   &adapter->if_handle, 0);
3211         if (status)
3212                 goto err;
3213
3214         /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
3215         rtnl_lock();
3216         status = be_setup_queues(adapter);
3217         rtnl_unlock();
3218         if (status)
3219                 goto err;
3220
3221         be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
3222         /* In UMC mode FW does not return right privileges.
3223          * Override with correct privilege equivalent to PF.
3224          */
3225         if (be_is_mc(adapter))
3226                 adapter->cmd_privileges = MAX_PRIVILEGES;
3227
3228         status = be_mac_setup(adapter);
3229         if (status)
3230                 goto err;
3231
3232         be_cmd_get_fw_ver(adapter, adapter->fw_ver, adapter->fw_on_flash);
3233
3234         if (adapter->vlans_added)
3235                 be_vid_config(adapter);
3236
3237         be_set_rx_mode(adapter->netdev);
3238
3239         be_cmd_get_flow_control(adapter, &tx_fc, &rx_fc);
3240
3241         if (rx_fc != adapter->rx_fc || tx_fc != adapter->tx_fc)
3242                 be_cmd_set_flow_control(adapter, adapter->tx_fc,
3243                                         adapter->rx_fc);
3244
3245         if (be_physfn(adapter) && num_vfs) {
3246                 if (be_max_vfs(adapter))
3247                         be_vf_setup(adapter);
3248                 else
3249                         dev_warn(dev, "device doesn't support SRIOV\n");
3250         }
3251
3252         status = be_cmd_get_phy_info(adapter);
3253         if (!status && be_pause_supported(adapter))
3254                 adapter->phy.fc_autoneg = 1;
3255
3256         be_schedule_worker(adapter);
3257         return 0;
3258 err:
3259         be_clear(adapter);
3260         return status;
3261 }
3262
3263 #ifdef CONFIG_NET_POLL_CONTROLLER
3264 static void be_netpoll(struct net_device *netdev)
3265 {
3266         struct be_adapter *adapter = netdev_priv(netdev);
3267         struct be_eq_obj *eqo;
3268         int i;
3269
3270         for_all_evt_queues(adapter, eqo, i) {
3271                 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0);
3272                 napi_schedule(&eqo->napi);
3273         }
3274
3275         return;
3276 }
3277 #endif
3278
3279 #define FW_FILE_HDR_SIGN        "ServerEngines Corp. "
3280 static char flash_cookie[2][16] =      {"*** SE FLAS", "H DIRECTORY *** "};
3281
3282 static bool be_flash_redboot(struct be_adapter *adapter,
3283                         const u8 *p, u32 img_start, int image_size,
3284                         int hdr_size)
3285 {
3286         u32 crc_offset;
3287         u8 flashed_crc[4];
3288         int status;
3289
3290         crc_offset = hdr_size + img_start + image_size - 4;
3291
3292         p += crc_offset;
3293
3294         status = be_cmd_get_flash_crc(adapter, flashed_crc,
3295                         (image_size - 4));
3296         if (status) {
3297                 dev_err(&adapter->pdev->dev,
3298                 "could not get crc from flash, not flashing redboot\n");
3299                 return false;
3300         }
3301
3302         /*update redboot only if crc does not match*/
3303         if (!memcmp(flashed_crc, p, 4))
3304                 return false;
3305         else
3306                 return true;
3307 }
3308
3309 static bool phy_flashing_required(struct be_adapter *adapter)
3310 {
3311         return (adapter->phy.phy_type == TN_8022 &&
3312                 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
3313 }
3314
3315 static bool is_comp_in_ufi(struct be_adapter *adapter,
3316                            struct flash_section_info *fsec, int type)
3317 {
3318         int i = 0, img_type = 0;
3319         struct flash_section_info_g2 *fsec_g2 = NULL;
3320
3321         if (BE2_chip(adapter))
3322                 fsec_g2 = (struct flash_section_info_g2 *)fsec;
3323
3324         for (i = 0; i < MAX_FLASH_COMP; i++) {
3325                 if (fsec_g2)
3326                         img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
3327                 else
3328                         img_type = le32_to_cpu(fsec->fsec_entry[i].type);
3329
3330                 if (img_type == type)
3331                         return true;
3332         }
3333         return false;
3334
3335 }
3336
3337 static struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
3338                                          int header_size,
3339                                          const struct firmware *fw)
3340 {
3341         struct flash_section_info *fsec = NULL;
3342         const u8 *p = fw->data;
3343
3344         p += header_size;
3345         while (p < (fw->data + fw->size)) {
3346                 fsec = (struct flash_section_info *)p;
3347                 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
3348                         return fsec;
3349                 p += 32;
3350         }
3351         return NULL;
3352 }
3353
3354 static int be_flash(struct be_adapter *adapter, const u8 *img,
3355                 struct be_dma_mem *flash_cmd, int optype, int img_size)
3356 {
3357         u32 total_bytes = 0, flash_op, num_bytes = 0;
3358         int status = 0;
3359         struct be_cmd_write_flashrom *req = flash_cmd->va;
3360
3361         total_bytes = img_size;
3362         while (total_bytes) {
3363                 num_bytes = min_t(u32, 32*1024, total_bytes);
3364
3365                 total_bytes -= num_bytes;
3366
3367                 if (!total_bytes) {
3368                         if (optype == OPTYPE_PHY_FW)
3369                                 flash_op = FLASHROM_OPER_PHY_FLASH;
3370                         else
3371                                 flash_op = FLASHROM_OPER_FLASH;
3372                 } else {
3373                         if (optype == OPTYPE_PHY_FW)
3374                                 flash_op = FLASHROM_OPER_PHY_SAVE;
3375                         else
3376                                 flash_op = FLASHROM_OPER_SAVE;
3377                 }
3378
3379                 memcpy(req->data_buf, img, num_bytes);
3380                 img += num_bytes;
3381                 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
3382                                                 flash_op, num_bytes);
3383                 if (status) {
3384                         if (status == ILLEGAL_IOCTL_REQ &&
3385                             optype == OPTYPE_PHY_FW)
3386                                 break;
3387                         dev_err(&adapter->pdev->dev,
3388                                 "cmd to write to flash rom failed.\n");
3389                         return status;
3390                 }
3391         }
3392         return 0;
3393 }
3394
3395 /* For BE2, BE3 and BE3-R */
3396 static int be_flash_BEx(struct be_adapter *adapter,
3397                          const struct firmware *fw,
3398                          struct be_dma_mem *flash_cmd,
3399                          int num_of_images)
3400
3401 {
3402         int status = 0, i, filehdr_size = 0;
3403         int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
3404         const u8 *p = fw->data;
3405         const struct flash_comp *pflashcomp;
3406         int num_comp, redboot;
3407         struct flash_section_info *fsec = NULL;
3408
3409         struct flash_comp gen3_flash_types[] = {
3410                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
3411                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
3412                 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
3413                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
3414                 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
3415                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
3416                 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
3417                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
3418                 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
3419                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
3420                 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
3421                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
3422                 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
3423                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
3424                 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
3425                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
3426                 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
3427                         FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
3428                 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
3429                         FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
3430         };
3431
3432         struct flash_comp gen2_flash_types[] = {
3433                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
3434                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
3435                 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
3436                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
3437                 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
3438                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
3439                 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
3440                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
3441                 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
3442                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
3443                 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
3444                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
3445                 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
3446                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
3447                 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
3448                          FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
3449         };
3450
3451         if (BE3_chip(adapter)) {
3452                 pflashcomp = gen3_flash_types;
3453                 filehdr_size = sizeof(struct flash_file_hdr_g3);
3454                 num_comp = ARRAY_SIZE(gen3_flash_types);
3455         } else {
3456                 pflashcomp = gen2_flash_types;
3457                 filehdr_size = sizeof(struct flash_file_hdr_g2);
3458                 num_comp = ARRAY_SIZE(gen2_flash_types);
3459         }
3460
3461         /* Get flash section info*/
3462         fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
3463         if (!fsec) {
3464                 dev_err(&adapter->pdev->dev,
3465                         "Invalid Cookie. UFI corrupted ?\n");
3466                 return -1;
3467         }
3468         for (i = 0; i < num_comp; i++) {
3469                 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
3470                         continue;
3471
3472                 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
3473                     memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
3474                         continue;
3475
3476                 if (pflashcomp[i].optype == OPTYPE_PHY_FW  &&
3477                     !phy_flashing_required(adapter))
3478                                 continue;
3479
3480                 if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
3481                         redboot = be_flash_redboot(adapter, fw->data,
3482                                 pflashcomp[i].offset, pflashcomp[i].size,
3483                                 filehdr_size + img_hdrs_size);
3484                         if (!redboot)
3485                                 continue;
3486                 }
3487
3488                 p = fw->data;
3489                 p += filehdr_size + pflashcomp[i].offset + img_hdrs_size;
3490                 if (p + pflashcomp[i].size > fw->data + fw->size)
3491                         return -1;
3492
3493                 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
3494                                         pflashcomp[i].size);
3495                 if (status) {
3496                         dev_err(&adapter->pdev->dev,
3497                                 "Flashing section type %d failed.\n",
3498                                 pflashcomp[i].img_type);
3499                         return status;
3500                 }
3501         }
3502         return 0;
3503 }
3504
3505 static int be_flash_skyhawk(struct be_adapter *adapter,
3506                 const struct firmware *fw,
3507                 struct be_dma_mem *flash_cmd, int num_of_images)
3508 {
3509         int status = 0, i, filehdr_size = 0;
3510         int img_offset, img_size, img_optype, redboot;
3511         int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
3512         const u8 *p = fw->data;
3513         struct flash_section_info *fsec = NULL;
3514
3515         filehdr_size = sizeof(struct flash_file_hdr_g3);
3516         fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
3517         if (!fsec) {
3518                 dev_err(&adapter->pdev->dev,
3519                         "Invalid Cookie. UFI corrupted ?\n");
3520                 return -1;
3521         }
3522
3523         for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
3524                 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
3525                 img_size   = le32_to_cpu(fsec->fsec_entry[i].pad_size);
3526
3527                 switch (le32_to_cpu(fsec->fsec_entry[i].type)) {
3528                 case IMAGE_FIRMWARE_iSCSI:
3529                         img_optype = OPTYPE_ISCSI_ACTIVE;
3530                         break;
3531                 case IMAGE_BOOT_CODE:
3532                         img_optype = OPTYPE_REDBOOT;
3533                         break;
3534                 case IMAGE_OPTION_ROM_ISCSI:
3535                         img_optype = OPTYPE_BIOS;
3536                         break;
3537                 case IMAGE_OPTION_ROM_PXE:
3538                         img_optype = OPTYPE_PXE_BIOS;
3539                         break;
3540                 case IMAGE_OPTION_ROM_FCoE:
3541                         img_optype = OPTYPE_FCOE_BIOS;
3542                         break;
3543                 case IMAGE_FIRMWARE_BACKUP_iSCSI:
3544                         img_optype = OPTYPE_ISCSI_BACKUP;
3545                         break;
3546                 case IMAGE_NCSI:
3547                         img_optype = OPTYPE_NCSI_FW;
3548                         break;
3549                 default:
3550                         continue;
3551                 }
3552
3553                 if (img_optype == OPTYPE_REDBOOT) {
3554                         redboot = be_flash_redboot(adapter, fw->data,
3555                                         img_offset, img_size,
3556                                         filehdr_size + img_hdrs_size);
3557                         if (!redboot)
3558                                 continue;
3559                 }
3560
3561                 p = fw->data;
3562                 p += filehdr_size + img_offset + img_hdrs_size;
3563                 if (p + img_size > fw->data + fw->size)
3564                         return -1;
3565
3566                 status = be_flash(adapter, p, flash_cmd, img_optype, img_size);
3567                 if (status) {
3568                         dev_err(&adapter->pdev->dev,
3569                                 "Flashing section type %d failed.\n",
3570                                 fsec->fsec_entry[i].type);
3571                         return status;
3572                 }
3573         }
3574         return 0;
3575 }
3576
3577 static int lancer_fw_download(struct be_adapter *adapter,
3578                                 const struct firmware *fw)
3579 {
3580 #define LANCER_FW_DOWNLOAD_CHUNK      (32 * 1024)
3581 #define LANCER_FW_DOWNLOAD_LOCATION   "/prg"
3582         struct be_dma_mem flash_cmd;
3583         const u8 *data_ptr = NULL;
3584         u8 *dest_image_ptr = NULL;
3585         size_t image_size = 0;
3586         u32 chunk_size = 0;
3587         u32 data_written = 0;
3588         u32 offset = 0;
3589         int status = 0;
3590         u8 add_status = 0;
3591         u8 change_status;
3592
3593         if (!IS_ALIGNED(fw->size, sizeof(u32))) {
3594                 dev_err(&adapter->pdev->dev,
3595                         "FW Image not properly aligned. "
3596                         "Length must be 4 byte aligned.\n");
3597                 status = -EINVAL;
3598                 goto lancer_fw_exit;
3599         }
3600
3601         flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
3602                                 + LANCER_FW_DOWNLOAD_CHUNK;
3603         flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
3604                                           &flash_cmd.dma, GFP_KERNEL);
3605         if (!flash_cmd.va) {
3606                 status = -ENOMEM;
3607                 goto lancer_fw_exit;
3608         }
3609
3610         dest_image_ptr = flash_cmd.va +
3611                                 sizeof(struct lancer_cmd_req_write_object);
3612         image_size = fw->size;
3613         data_ptr = fw->data;
3614
3615         while (image_size) {
3616                 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
3617
3618                 /* Copy the image chunk content. */
3619                 memcpy(dest_image_ptr, data_ptr, chunk_size);
3620
3621                 status = lancer_cmd_write_object(adapter, &flash_cmd,
3622                                                  chunk_size, offset,
3623                                                  LANCER_FW_DOWNLOAD_LOCATION,
3624                                                  &data_written, &change_status,
3625                                                  &add_status);
3626                 if (status)
3627                         break;
3628
3629                 offset += data_written;
3630                 data_ptr += data_written;
3631                 image_size -= data_written;
3632         }
3633
3634         if (!status) {
3635                 /* Commit the FW written */
3636                 status = lancer_cmd_write_object(adapter, &flash_cmd,
3637                                                  0, offset,
3638                                                  LANCER_FW_DOWNLOAD_LOCATION,
3639                                                  &data_written, &change_status,
3640                                                  &add_status);
3641         }
3642
3643         dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
3644                                 flash_cmd.dma);
3645         if (status) {
3646                 dev_err(&adapter->pdev->dev,
3647                         "Firmware load error. "
3648                         "Status code: 0x%x Additional Status: 0x%x\n",
3649                         status, add_status);
3650                 goto lancer_fw_exit;
3651         }
3652
3653         if (change_status == LANCER_FW_RESET_NEEDED) {
3654                 status = lancer_physdev_ctrl(adapter,
3655                                              PHYSDEV_CONTROL_FW_RESET_MASK);
3656                 if (status) {
3657                         dev_err(&adapter->pdev->dev,
3658                                 "Adapter busy for FW reset.\n"
3659                                 "New FW will not be active.\n");
3660                         goto lancer_fw_exit;
3661                 }
3662         } else if (change_status != LANCER_NO_RESET_NEEDED) {
3663                         dev_err(&adapter->pdev->dev,
3664                                 "System reboot required for new FW"
3665                                 " to be active\n");
3666         }
3667
3668         dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
3669 lancer_fw_exit:
3670         return status;
3671 }
3672
3673 #define UFI_TYPE2               2
3674 #define UFI_TYPE3               3
3675 #define UFI_TYPE3R              10
3676 #define UFI_TYPE4               4
3677 static int be_get_ufi_type(struct be_adapter *adapter,
3678                            struct flash_file_hdr_g3 *fhdr)
3679 {
3680         if (fhdr == NULL)
3681                 goto be_get_ufi_exit;
3682
3683         if (skyhawk_chip(adapter) && fhdr->build[0] == '4')
3684                 return UFI_TYPE4;
3685         else if (BE3_chip(adapter) && fhdr->build[0] == '3') {
3686                 if (fhdr->asic_type_rev == 0x10)
3687                         return UFI_TYPE3R;
3688                 else
3689                         return UFI_TYPE3;
3690         } else if (BE2_chip(adapter) && fhdr->build[0] == '2')
3691                 return UFI_TYPE2;
3692
3693 be_get_ufi_exit:
3694         dev_err(&adapter->pdev->dev,
3695                 "UFI and Interface are not compatible for flashing\n");
3696         return -1;
3697 }
3698
3699 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
3700 {
3701         struct flash_file_hdr_g3 *fhdr3;
3702         struct image_hdr *img_hdr_ptr = NULL;
3703         struct be_dma_mem flash_cmd;
3704         const u8 *p;
3705         int status = 0, i = 0, num_imgs = 0, ufi_type = 0;
3706
3707         flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
3708         flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
3709                                           &flash_cmd.dma, GFP_KERNEL);
3710         if (!flash_cmd.va) {
3711                 status = -ENOMEM;
3712                 goto be_fw_exit;
3713         }
3714
3715         p = fw->data;
3716         fhdr3 = (struct flash_file_hdr_g3 *)p;
3717
3718         ufi_type = be_get_ufi_type(adapter, fhdr3);
3719
3720         num_imgs = le32_to_cpu(fhdr3->num_imgs);
3721         for (i = 0; i < num_imgs; i++) {
3722                 img_hdr_ptr = (struct image_hdr *)(fw->data +
3723                                 (sizeof(struct flash_file_hdr_g3) +
3724                                  i * sizeof(struct image_hdr)));
3725                 if (le32_to_cpu(img_hdr_ptr->imageid) == 1) {
3726                         switch (ufi_type) {
3727                         case UFI_TYPE4:
3728                                 status = be_flash_skyhawk(adapter, fw,
3729                                                         &flash_cmd, num_imgs);
3730                                 break;
3731                         case UFI_TYPE3R:
3732                                 status = be_flash_BEx(adapter, fw, &flash_cmd,
3733                                                       num_imgs);
3734                                 break;
3735                         case UFI_TYPE3:
3736                                 /* Do not flash this ufi on BE3-R cards */
3737                                 if (adapter->asic_rev < 0x10)
3738                                         status = be_flash_BEx(adapter, fw,
3739                                                               &flash_cmd,
3740                                                               num_imgs);
3741                                 else {
3742                                         status = -1;
3743                                         dev_err(&adapter->pdev->dev,
3744                                                 "Can't load BE3 UFI on BE3R\n");
3745                                 }
3746                         }
3747                 }
3748         }
3749
3750         if (ufi_type == UFI_TYPE2)
3751                 status = be_flash_BEx(adapter, fw, &flash_cmd, 0);
3752         else if (ufi_type == -1)
3753                 status = -1;
3754
3755         dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
3756                           flash_cmd.dma);
3757         if (status) {
3758                 dev_err(&adapter->pdev->dev, "Firmware load error\n");
3759                 goto be_fw_exit;
3760         }
3761
3762         dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
3763
3764 be_fw_exit:
3765         return status;
3766 }
3767
3768 int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
3769 {
3770         const struct firmware *fw;
3771         int status;
3772
3773         if (!netif_running(adapter->netdev)) {
3774                 dev_err(&adapter->pdev->dev,
3775                         "Firmware load not allowed (interface is down)\n");
3776                 return -1;
3777         }
3778
3779         status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
3780         if (status)
3781                 goto fw_exit;
3782
3783         dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
3784
3785         if (lancer_chip(adapter))
3786                 status = lancer_fw_download(adapter, fw);
3787         else
3788                 status = be_fw_download(adapter, fw);
3789
3790         if (!status)
3791                 be_cmd_get_fw_ver(adapter, adapter->fw_ver,
3792                                   adapter->fw_on_flash);
3793
3794 fw_exit:
3795         release_firmware(fw);
3796         return status;
3797 }
3798
3799 static int be_ndo_bridge_setlink(struct net_device *dev,
3800                                     struct nlmsghdr *nlh)
3801 {
3802         struct be_adapter *adapter = netdev_priv(dev);
3803         struct nlattr *attr, *br_spec;
3804         int rem;
3805         int status = 0;
3806         u16 mode = 0;
3807
3808         if (!sriov_enabled(adapter))
3809                 return -EOPNOTSUPP;
3810
3811         br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
3812
3813         nla_for_each_nested(attr, br_spec, rem) {
3814                 if (nla_type(attr) != IFLA_BRIDGE_MODE)
3815                         continue;
3816
3817                 mode = nla_get_u16(attr);
3818                 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
3819                         return -EINVAL;
3820
3821                 status = be_cmd_set_hsw_config(adapter, 0, 0,
3822                                                adapter->if_handle,
3823                                                mode == BRIDGE_MODE_VEPA ?
3824                                                PORT_FWD_TYPE_VEPA :
3825                                                PORT_FWD_TYPE_VEB);
3826                 if (status)
3827                         goto err;
3828
3829                 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n",
3830                          mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
3831
3832                 return status;
3833         }
3834 err:
3835         dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n",
3836                 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
3837
3838         return status;
3839 }
3840
3841 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
3842                                     struct net_device *dev,
3843                                     u32 filter_mask)
3844 {
3845         struct be_adapter *adapter = netdev_priv(dev);
3846         int status = 0;
3847         u8 hsw_mode;
3848
3849         if (!sriov_enabled(adapter))
3850                 return 0;
3851
3852         /* BE and Lancer chips support VEB mode only */
3853         if (BEx_chip(adapter) || lancer_chip(adapter)) {
3854                 hsw_mode = PORT_FWD_TYPE_VEB;
3855         } else {
3856                 status = be_cmd_get_hsw_config(adapter, NULL, 0,
3857                                                adapter->if_handle, &hsw_mode);
3858                 if (status)
3859                         return 0;
3860         }
3861
3862         return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
3863                                        hsw_mode == PORT_FWD_TYPE_VEPA ?
3864                                        BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB);
3865 }
3866
3867 static const struct net_device_ops be_netdev_ops = {
3868         .ndo_open               = be_open,
3869         .ndo_stop               = be_close,
3870         .ndo_start_xmit         = be_xmit,
3871         .ndo_set_rx_mode        = be_set_rx_mode,
3872         .ndo_set_mac_address    = be_mac_addr_set,
3873         .ndo_change_mtu         = be_change_mtu,
3874         .ndo_get_stats64        = be_get_stats64,
3875         .ndo_validate_addr      = eth_validate_addr,
3876         .ndo_vlan_rx_add_vid    = be_vlan_add_vid,
3877         .ndo_vlan_rx_kill_vid   = be_vlan_rem_vid,
3878         .ndo_set_vf_mac         = be_set_vf_mac,
3879         .ndo_set_vf_vlan        = be_set_vf_vlan,
3880         .ndo_set_vf_tx_rate     = be_set_vf_tx_rate,
3881         .ndo_get_vf_config      = be_get_vf_config,
3882 #ifdef CONFIG_NET_POLL_CONTROLLER
3883         .ndo_poll_controller    = be_netpoll,
3884 #endif
3885         .ndo_bridge_setlink     = be_ndo_bridge_setlink,
3886         .ndo_bridge_getlink     = be_ndo_bridge_getlink,
3887 };
3888
3889 static void be_netdev_init(struct net_device *netdev)
3890 {
3891         struct be_adapter *adapter = netdev_priv(netdev);
3892
3893         netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3894                 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
3895                 NETIF_F_HW_VLAN_CTAG_TX;
3896         if (be_multi_rxq(adapter))
3897                 netdev->hw_features |= NETIF_F_RXHASH;
3898
3899         netdev->features |= netdev->hw_features |
3900                 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
3901
3902         netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3903                 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
3904
3905         netdev->priv_flags |= IFF_UNICAST_FLT;
3906
3907         netdev->flags |= IFF_MULTICAST;
3908
3909         netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
3910
3911         netdev->netdev_ops = &be_netdev_ops;
3912
3913         SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
3914 }
3915
3916 static void be_unmap_pci_bars(struct be_adapter *adapter)
3917 {
3918         if (adapter->csr)
3919                 pci_iounmap(adapter->pdev, adapter->csr);
3920         if (adapter->db)
3921                 pci_iounmap(adapter->pdev, adapter->db);
3922 }
3923
3924 static int db_bar(struct be_adapter *adapter)
3925 {
3926         if (lancer_chip(adapter) || !be_physfn(adapter))
3927                 return 0;
3928         else
3929                 return 4;
3930 }
3931
3932 static int be_roce_map_pci_bars(struct be_adapter *adapter)
3933 {
3934         if (skyhawk_chip(adapter)) {
3935                 adapter->roce_db.size = 4096;
3936                 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
3937                                                               db_bar(adapter));
3938                 adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
3939                                                                db_bar(adapter));
3940         }
3941         return 0;
3942 }
3943
3944 static int be_map_pci_bars(struct be_adapter *adapter)
3945 {
3946         u8 __iomem *addr;
3947         u32 sli_intf;
3948
3949         pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
3950         adapter->if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
3951                                 SLI_INTF_IF_TYPE_SHIFT;
3952
3953         if (BEx_chip(adapter) && be_physfn(adapter)) {
3954                 adapter->csr = pci_iomap(adapter->pdev, 2, 0);
3955                 if (adapter->csr == NULL)
3956                         return -ENOMEM;
3957         }
3958
3959         addr = pci_iomap(adapter->pdev, db_bar(adapter), 0);
3960         if (addr == NULL)
3961                 goto pci_map_err;
3962         adapter->db = addr;
3963
3964         be_roce_map_pci_bars(adapter);
3965         return 0;
3966
3967 pci_map_err:
3968         be_unmap_pci_bars(adapter);
3969         return -ENOMEM;
3970 }
3971
3972 static void be_ctrl_cleanup(struct be_adapter *adapter)
3973 {
3974         struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
3975
3976         be_unmap_pci_bars(adapter);
3977
3978         if (mem->va)
3979                 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
3980                                   mem->dma);
3981
3982         mem = &adapter->rx_filter;
3983         if (mem->va)
3984                 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
3985                                   mem->dma);
3986 }
3987
3988 static int be_ctrl_init(struct be_adapter *adapter)
3989 {
3990         struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
3991         struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
3992         struct be_dma_mem *rx_filter = &adapter->rx_filter;
3993         u32 sli_intf;
3994         int status;
3995
3996         pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
3997         adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
3998                                  SLI_INTF_FAMILY_SHIFT;
3999         adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
4000
4001         status = be_map_pci_bars(adapter);
4002         if (status)
4003                 goto done;
4004
4005         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
4006         mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
4007                                                 mbox_mem_alloc->size,
4008                                                 &mbox_mem_alloc->dma,
4009                                                 GFP_KERNEL);
4010         if (!mbox_mem_alloc->va) {
4011                 status = -ENOMEM;
4012                 goto unmap_pci_bars;
4013         }
4014         mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
4015         mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
4016         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
4017         memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
4018
4019         rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
4020         rx_filter->va = dma_zalloc_coherent(&adapter->pdev->dev,
4021                                             rx_filter->size, &rx_filter->dma,
4022                                             GFP_KERNEL);
4023         if (rx_filter->va == NULL) {
4024                 status = -ENOMEM;
4025                 goto free_mbox;
4026         }
4027
4028         mutex_init(&adapter->mbox_lock);
4029         spin_lock_init(&adapter->mcc_lock);
4030         spin_lock_init(&adapter->mcc_cq_lock);
4031
4032         init_completion(&adapter->flash_compl);
4033         pci_save_state(adapter->pdev);
4034         return 0;
4035
4036 free_mbox:
4037         dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
4038                           mbox_mem_alloc->va, mbox_mem_alloc->dma);
4039
4040 unmap_pci_bars:
4041         be_unmap_pci_bars(adapter);
4042
4043 done:
4044         return status;
4045 }
4046
4047 static void be_stats_cleanup(struct be_adapter *adapter)
4048 {
4049         struct be_dma_mem *cmd = &adapter->stats_cmd;
4050
4051         if (cmd->va)
4052                 dma_free_coherent(&adapter->pdev->dev, cmd->size,
4053                                   cmd->va, cmd->dma);
4054 }
4055
4056 static int be_stats_init(struct be_adapter *adapter)
4057 {
4058         struct be_dma_mem *cmd = &adapter->stats_cmd;
4059
4060         if (lancer_chip(adapter))
4061                 cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
4062         else if (BE2_chip(adapter))
4063                 cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
4064         else
4065                 /* BE3 and Skyhawk */
4066                 cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
4067
4068         cmd->va = dma_zalloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
4069                                       GFP_KERNEL);
4070         if (cmd->va == NULL)
4071                 return -1;
4072         return 0;
4073 }
4074
4075 static void be_remove(struct pci_dev *pdev)
4076 {
4077         struct be_adapter *adapter = pci_get_drvdata(pdev);
4078
4079         if (!adapter)
4080                 return;
4081
4082         be_roce_dev_remove(adapter);
4083         be_intr_set(adapter, false);
4084
4085         cancel_delayed_work_sync(&adapter->func_recovery_work);
4086
4087         unregister_netdev(adapter->netdev);
4088
4089         be_clear(adapter);
4090
4091         /* tell fw we're done with firing cmds */
4092         be_cmd_fw_clean(adapter);
4093
4094         be_stats_cleanup(adapter);
4095
4096         be_ctrl_cleanup(adapter);
4097
4098         pci_disable_pcie_error_reporting(pdev);
4099
4100         pci_set_drvdata(pdev, NULL);
4101         pci_release_regions(pdev);
4102         pci_disable_device(pdev);
4103
4104         free_netdev(adapter->netdev);
4105 }
4106
4107 bool be_is_wol_supported(struct be_adapter *adapter)
4108 {
4109         return ((adapter->wol_cap & BE_WOL_CAP) &&
4110                 !be_is_wol_excluded(adapter)) ? true : false;
4111 }
4112
4113 u32 be_get_fw_log_level(struct be_adapter *adapter)
4114 {
4115         struct be_dma_mem extfat_cmd;
4116         struct be_fat_conf_params *cfgs;
4117         int status;
4118         u32 level = 0;
4119         int j;
4120
4121         if (lancer_chip(adapter))
4122                 return 0;
4123
4124         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
4125         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
4126         extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
4127                                              &extfat_cmd.dma);
4128
4129         if (!extfat_cmd.va) {
4130                 dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
4131                         __func__);
4132                 goto err;
4133         }
4134
4135         status = be_cmd_get_ext_fat_capabilites(adapter, &extfat_cmd);
4136         if (!status) {
4137                 cfgs = (struct be_fat_conf_params *)(extfat_cmd.va +
4138                                                 sizeof(struct be_cmd_resp_hdr));
4139                 for (j = 0; j < le32_to_cpu(cfgs->module[0].num_modes); j++) {
4140                         if (cfgs->module[0].trace_lvl[j].mode == MODE_UART)
4141                                 level = cfgs->module[0].trace_lvl[j].dbg_lvl;
4142                 }
4143         }
4144         pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
4145                             extfat_cmd.dma);
4146 err:
4147         return level;
4148 }
4149
4150 static int be_get_initial_config(struct be_adapter *adapter)
4151 {
4152         int status;
4153         u32 level;
4154
4155         status = be_cmd_get_cntl_attributes(adapter);
4156         if (status)
4157                 return status;
4158
4159         status = be_cmd_get_acpi_wol_cap(adapter);
4160         if (status) {
4161                 /* in case of a failure to get wol capabillities
4162                  * check the exclusion list to determine WOL capability */
4163                 if (!be_is_wol_excluded(adapter))
4164                         adapter->wol_cap |= BE_WOL_CAP;
4165         }
4166
4167         if (be_is_wol_supported(adapter))
4168                 adapter->wol = true;
4169
4170         /* Must be a power of 2 or else MODULO will BUG_ON */
4171         adapter->be_get_temp_freq = 64;
4172
4173         level = be_get_fw_log_level(adapter);
4174         adapter->msg_enable = level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
4175
4176         adapter->cfg_num_qs = netif_get_num_default_rss_queues();
4177         return 0;
4178 }
4179
4180 static int lancer_recover_func(struct be_adapter *adapter)
4181 {
4182         struct device *dev = &adapter->pdev->dev;
4183         int status;
4184
4185         status = lancer_test_and_set_rdy_state(adapter);
4186         if (status)
4187                 goto err;
4188
4189         if (netif_running(adapter->netdev))
4190                 be_close(adapter->netdev);
4191
4192         be_clear(adapter);
4193
4194         be_clear_all_error(adapter);
4195
4196         status = be_setup(adapter);
4197         if (status)
4198                 goto err;
4199
4200         if (netif_running(adapter->netdev)) {
4201                 status = be_open(adapter->netdev);
4202                 if (status)
4203                         goto err;
4204         }
4205
4206         dev_err(dev, "Error recovery successful\n");
4207         return 0;
4208 err:
4209         if (status == -EAGAIN)
4210                 dev_err(dev, "Waiting for resource provisioning\n");
4211         else
4212                 dev_err(dev, "Error recovery failed\n");
4213
4214         return status;
4215 }
4216
4217 static void be_func_recovery_task(struct work_struct *work)
4218 {
4219         struct be_adapter *adapter =
4220                 container_of(work, struct be_adapter,  func_recovery_work.work);
4221         int status = 0;
4222
4223         be_detect_error(adapter);
4224
4225         if (adapter->hw_error && lancer_chip(adapter)) {
4226
4227                 rtnl_lock();
4228                 netif_device_detach(adapter->netdev);
4229                 rtnl_unlock();
4230
4231                 status = lancer_recover_func(adapter);
4232                 if (!status)
4233                         netif_device_attach(adapter->netdev);
4234         }
4235
4236         /* In Lancer, for all errors other than provisioning error (-EAGAIN),
4237          * no need to attempt further recovery.
4238          */
4239         if (!status || status == -EAGAIN)
4240                 schedule_delayed_work(&adapter->func_recovery_work,
4241                                       msecs_to_jiffies(1000));
4242 }
4243
4244 static void be_worker(struct work_struct *work)
4245 {
4246         struct be_adapter *adapter =
4247                 container_of(work, struct be_adapter, work.work);
4248         struct be_rx_obj *rxo;
4249         struct be_eq_obj *eqo;
4250         int i;
4251
4252         /* when interrupts are not yet enabled, just reap any pending
4253         * mcc completions */
4254         if (!netif_running(adapter->netdev)) {
4255                 local_bh_disable();
4256                 be_process_mcc(adapter);
4257                 local_bh_enable();
4258                 goto reschedule;
4259         }
4260
4261         if (!adapter->stats_cmd_sent) {
4262                 if (lancer_chip(adapter))
4263                         lancer_cmd_get_pport_stats(adapter,
4264                                                 &adapter->stats_cmd);
4265                 else
4266                         be_cmd_get_stats(adapter, &adapter->stats_cmd);
4267         }
4268
4269         if (be_physfn(adapter) &&
4270             MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
4271                 be_cmd_get_die_temperature(adapter);
4272
4273         for_all_rx_queues(adapter, rxo, i) {
4274                 if (rxo->rx_post_starved) {
4275                         rxo->rx_post_starved = false;
4276                         be_post_rx_frags(rxo, GFP_KERNEL);
4277                 }
4278         }
4279
4280         for_all_evt_queues(adapter, eqo, i)
4281                 be_eqd_update(adapter, eqo);
4282
4283 reschedule:
4284         adapter->work_counter++;
4285         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
4286 }
4287
4288 /* If any VFs are already enabled don't FLR the PF */
4289 static bool be_reset_required(struct be_adapter *adapter)
4290 {
4291         return pci_num_vf(adapter->pdev) ? false : true;
4292 }
4293
4294 static char *mc_name(struct be_adapter *adapter)
4295 {
4296         if (adapter->function_mode & FLEX10_MODE)
4297                 return "FLEX10";
4298         else if (adapter->function_mode & VNIC_MODE)
4299                 return "vNIC";
4300         else if (adapter->function_mode & UMC_ENABLED)
4301                 return "UMC";
4302         else
4303                 return "";
4304 }
4305
4306 static inline char *func_name(struct be_adapter *adapter)
4307 {
4308         return be_physfn(adapter) ? "PF" : "VF";
4309 }
4310
4311 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
4312 {
4313         int status = 0;
4314         struct be_adapter *adapter;
4315         struct net_device *netdev;
4316         char port_name;
4317
4318         status = pci_enable_device(pdev);
4319         if (status)
4320                 goto do_none;
4321
4322         status = pci_request_regions(pdev, DRV_NAME);
4323         if (status)
4324                 goto disable_dev;
4325         pci_set_master(pdev);
4326
4327         netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
4328         if (netdev == NULL) {
4329                 status = -ENOMEM;
4330                 goto rel_reg;
4331         }
4332         adapter = netdev_priv(netdev);
4333         adapter->pdev = pdev;
4334         pci_set_drvdata(pdev, adapter);
4335         adapter->netdev = netdev;
4336         SET_NETDEV_DEV(netdev, &pdev->dev);
4337
4338         status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
4339         if (!status) {
4340                 status = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
4341                 if (status < 0) {
4342                         dev_err(&pdev->dev, "dma_set_coherent_mask failed\n");
4343                         goto free_netdev;
4344                 }
4345                 netdev->features |= NETIF_F_HIGHDMA;
4346         } else {
4347                 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
4348                 if (!status)
4349                         status = dma_set_coherent_mask(&pdev->dev,
4350                                                        DMA_BIT_MASK(32));
4351                 if (status) {
4352                         dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
4353                         goto free_netdev;
4354                 }
4355         }
4356
4357         status = pci_enable_pcie_error_reporting(pdev);
4358         if (status)
4359                 dev_info(&pdev->dev, "Could not use PCIe error reporting\n");
4360
4361         status = be_ctrl_init(adapter);
4362         if (status)
4363                 goto free_netdev;
4364
4365         /* sync up with fw's ready state */
4366         if (be_physfn(adapter)) {
4367                 status = be_fw_wait_ready(adapter);
4368                 if (status)
4369                         goto ctrl_clean;
4370         }
4371
4372         if (be_reset_required(adapter)) {
4373                 status = be_cmd_reset_function(adapter);
4374                 if (status)
4375                         goto ctrl_clean;
4376
4377                 /* Wait for interrupts to quiesce after an FLR */
4378                 msleep(100);
4379         }
4380
4381         /* Allow interrupts for other ULPs running on NIC function */
4382         be_intr_set(adapter, true);
4383
4384         /* tell fw we're ready to fire cmds */
4385         status = be_cmd_fw_init(adapter);
4386         if (status)
4387                 goto ctrl_clean;
4388
4389         status = be_stats_init(adapter);
4390         if (status)
4391                 goto ctrl_clean;
4392
4393         status = be_get_initial_config(adapter);
4394         if (status)
4395                 goto stats_clean;
4396
4397         INIT_DELAYED_WORK(&adapter->work, be_worker);
4398         INIT_DELAYED_WORK(&adapter->func_recovery_work, be_func_recovery_task);
4399         adapter->rx_fc = adapter->tx_fc = true;
4400
4401         status = be_setup(adapter);
4402         if (status)
4403                 goto stats_clean;
4404
4405         be_netdev_init(netdev);
4406         status = register_netdev(netdev);
4407         if (status != 0)
4408                 goto unsetup;
4409
4410         be_roce_dev_add(adapter);
4411
4412         schedule_delayed_work(&adapter->func_recovery_work,
4413                               msecs_to_jiffies(1000));
4414
4415         be_cmd_query_port_name(adapter, &port_name);
4416
4417         dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
4418                  func_name(adapter), mc_name(adapter), port_name);
4419
4420         return 0;
4421
4422 unsetup:
4423         be_clear(adapter);
4424 stats_clean:
4425         be_stats_cleanup(adapter);
4426 ctrl_clean:
4427         be_ctrl_cleanup(adapter);
4428 free_netdev:
4429         free_netdev(netdev);
4430         pci_set_drvdata(pdev, NULL);
4431 rel_reg:
4432         pci_release_regions(pdev);
4433 disable_dev:
4434         pci_disable_device(pdev);
4435 do_none:
4436         dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
4437         return status;
4438 }
4439
4440 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
4441 {
4442         struct be_adapter *adapter = pci_get_drvdata(pdev);
4443         struct net_device *netdev =  adapter->netdev;
4444
4445         if (adapter->wol)
4446                 be_setup_wol(adapter, true);
4447
4448         cancel_delayed_work_sync(&adapter->func_recovery_work);
4449
4450         netif_device_detach(netdev);
4451         if (netif_running(netdev)) {
4452                 rtnl_lock();
4453                 be_close(netdev);
4454                 rtnl_unlock();
4455         }
4456         be_clear(adapter);
4457
4458         pci_save_state(pdev);
4459         pci_disable_device(pdev);
4460         pci_set_power_state(pdev, pci_choose_state(pdev, state));
4461         return 0;
4462 }
4463
4464 static int be_resume(struct pci_dev *pdev)
4465 {
4466         int status = 0;
4467         struct be_adapter *adapter = pci_get_drvdata(pdev);
4468         struct net_device *netdev =  adapter->netdev;
4469
4470         netif_device_detach(netdev);
4471
4472         status = pci_enable_device(pdev);
4473         if (status)
4474                 return status;
4475
4476         pci_set_power_state(pdev, PCI_D0);
4477         pci_restore_state(pdev);
4478
4479         status = be_fw_wait_ready(adapter);
4480         if (status)
4481                 return status;
4482
4483         /* tell fw we're ready to fire cmds */
4484         status = be_cmd_fw_init(adapter);
4485         if (status)
4486                 return status;
4487
4488         be_setup(adapter);
4489         if (netif_running(netdev)) {
4490                 rtnl_lock();
4491                 be_open(netdev);
4492                 rtnl_unlock();
4493         }
4494
4495         schedule_delayed_work(&adapter->func_recovery_work,
4496                               msecs_to_jiffies(1000));
4497         netif_device_attach(netdev);
4498
4499         if (adapter->wol)
4500                 be_setup_wol(adapter, false);
4501
4502         return 0;
4503 }
4504
4505 /*
4506  * An FLR will stop BE from DMAing any data.
4507  */
4508 static void be_shutdown(struct pci_dev *pdev)
4509 {
4510         struct be_adapter *adapter = pci_get_drvdata(pdev);
4511
4512         if (!adapter)
4513                 return;
4514
4515         cancel_delayed_work_sync(&adapter->work);
4516         cancel_delayed_work_sync(&adapter->func_recovery_work);
4517
4518         netif_device_detach(adapter->netdev);
4519
4520         be_cmd_reset_function(adapter);
4521
4522         pci_disable_device(pdev);
4523 }
4524
4525 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
4526                                 pci_channel_state_t state)
4527 {
4528         struct be_adapter *adapter = pci_get_drvdata(pdev);
4529         struct net_device *netdev =  adapter->netdev;
4530
4531         dev_err(&adapter->pdev->dev, "EEH error detected\n");
4532
4533         if (!adapter->eeh_error) {
4534                 adapter->eeh_error = true;
4535
4536                 cancel_delayed_work_sync(&adapter->func_recovery_work);
4537
4538                 rtnl_lock();
4539                 netif_device_detach(netdev);
4540                 if (netif_running(netdev))
4541                         be_close(netdev);
4542                 rtnl_unlock();
4543
4544                 be_clear(adapter);
4545         }
4546
4547         if (state == pci_channel_io_perm_failure)
4548                 return PCI_ERS_RESULT_DISCONNECT;
4549
4550         pci_disable_device(pdev);
4551
4552         /* The error could cause the FW to trigger a flash debug dump.
4553          * Resetting the card while flash dump is in progress
4554          * can cause it not to recover; wait for it to finish.
4555          * Wait only for first function as it is needed only once per
4556          * adapter.
4557          */
4558         if (pdev->devfn == 0)
4559                 ssleep(30);
4560
4561         return PCI_ERS_RESULT_NEED_RESET;
4562 }
4563
4564 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
4565 {
4566         struct be_adapter *adapter = pci_get_drvdata(pdev);
4567         int status;
4568
4569         dev_info(&adapter->pdev->dev, "EEH reset\n");
4570
4571         status = pci_enable_device(pdev);
4572         if (status)
4573                 return PCI_ERS_RESULT_DISCONNECT;
4574
4575         pci_set_master(pdev);
4576         pci_set_power_state(pdev, PCI_D0);
4577         pci_restore_state(pdev);
4578
4579         /* Check if card is ok and fw is ready */
4580         dev_info(&adapter->pdev->dev,
4581                  "Waiting for FW to be ready after EEH reset\n");
4582         status = be_fw_wait_ready(adapter);
4583         if (status)
4584                 return PCI_ERS_RESULT_DISCONNECT;
4585
4586         pci_cleanup_aer_uncorrect_error_status(pdev);
4587         be_clear_all_error(adapter);
4588         return PCI_ERS_RESULT_RECOVERED;
4589 }
4590
4591 static void be_eeh_resume(struct pci_dev *pdev)
4592 {
4593         int status = 0;
4594         struct be_adapter *adapter = pci_get_drvdata(pdev);
4595         struct net_device *netdev =  adapter->netdev;
4596
4597         dev_info(&adapter->pdev->dev, "EEH resume\n");
4598
4599         pci_save_state(pdev);
4600
4601         status = be_cmd_reset_function(adapter);
4602         if (status)
4603                 goto err;
4604
4605         /* tell fw we're ready to fire cmds */
4606         status = be_cmd_fw_init(adapter);
4607         if (status)
4608                 goto err;
4609
4610         status = be_setup(adapter);
4611         if (status)
4612                 goto err;
4613
4614         if (netif_running(netdev)) {
4615                 status = be_open(netdev);
4616                 if (status)
4617                         goto err;
4618         }
4619
4620         schedule_delayed_work(&adapter->func_recovery_work,
4621                               msecs_to_jiffies(1000));
4622         netif_device_attach(netdev);
4623         return;
4624 err:
4625         dev_err(&adapter->pdev->dev, "EEH resume failed\n");
4626 }
4627
4628 static const struct pci_error_handlers be_eeh_handlers = {
4629         .error_detected = be_eeh_err_detected,
4630         .slot_reset = be_eeh_reset,
4631         .resume = be_eeh_resume,
4632 };
4633
4634 static struct pci_driver be_driver = {
4635         .name = DRV_NAME,
4636         .id_table = be_dev_ids,
4637         .probe = be_probe,
4638         .remove = be_remove,
4639         .suspend = be_suspend,
4640         .resume = be_resume,
4641         .shutdown = be_shutdown,
4642         .err_handler = &be_eeh_handlers
4643 };
4644
4645 static int __init be_init_module(void)
4646 {
4647         if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
4648             rx_frag_size != 2048) {
4649                 printk(KERN_WARNING DRV_NAME
4650                         " : Module param rx_frag_size must be 2048/4096/8192."
4651                         " Using 2048\n");
4652                 rx_frag_size = 2048;
4653         }
4654
4655         return pci_register_driver(&be_driver);
4656 }
4657 module_init(be_init_module);
4658
4659 static void __exit be_exit_module(void)
4660 {
4661         pci_unregister_driver(&be_driver);
4662 }
4663 module_exit(be_exit_module);