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

   1 /*
   2  * Copyright (C) 2005 - 2015 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 #include <net/busy_poll.h>
  26 #include <net/vxlan.h>
  27
  28 MODULE_VERSION(DRV_VER);
  29 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
  30 MODULE_AUTHOR("Emulex Corporation");
  31 MODULE_LICENSE("GPL");
  32
  33 /* num_vfs module param is obsolete.
  34  * Use sysfs method to enable/disable VFs.
  35  */
  36 static unsigned int num_vfs;
  37 module_param(num_vfs, uint, S_IRUGO);
  38 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
  39
  40 static ushort rx_frag_size = 2048;
  41 module_param(rx_frag_size, ushort, S_IRUGO);
  42 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
  43
  44 static const struct pci_device_id be_dev_ids[] = {
  45         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
  46         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
  47         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
  48         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
  49         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
  50         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
  51         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
  52         { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
  53         { 0 }
  54 };
  55 MODULE_DEVICE_TABLE(pci, be_dev_ids);
  56 /* UE Status Low CSR */
  57 static const char * const ue_status_low_desc[] = {
  58         "CEV",
  59         "CTX",
  60         "DBUF",
  61         "ERX",
  62         "Host",
  63         "MPU",
  64         "NDMA",
  65         "PTC ",
  66         "RDMA ",
  67         "RXF ",
  68         "RXIPS ",
  69         "RXULP0 ",
  70         "RXULP1 ",
  71         "RXULP2 ",
  72         "TIM ",
  73         "TPOST ",
  74         "TPRE ",
  75         "TXIPS ",
  76         "TXULP0 ",
  77         "TXULP1 ",
  78         "UC ",
  79         "WDMA ",
  80         "TXULP2 ",
  81         "HOST1 ",
  82         "P0_OB_LINK ",
  83         "P1_OB_LINK ",
  84         "HOST_GPIO ",
  85         "MBOX ",
  86         "ERX2 ",
  87         "SPARE ",
  88         "JTAG ",
  89         "MPU_INTPEND "
  90 };
  91
  92 /* UE Status High CSR */
  93 static const char * const ue_status_hi_desc[] = {
  94         "LPCMEMHOST",
  95         "MGMT_MAC",
  96         "PCS0ONLINE",
  97         "MPU_IRAM",
  98         "PCS1ONLINE",
  99         "PCTL0",
 100         "PCTL1",
 101         "PMEM",
 102         "RR",
 103         "TXPB",
 104         "RXPP",
 105         "XAUI",
 106         "TXP",
 107         "ARM",
 108         "IPC",
 109         "HOST2",
 110         "HOST3",
 111         "HOST4",
 112         "HOST5",
 113         "HOST6",
 114         "HOST7",
 115         "ECRC",
 116         "Poison TLP",
 117         "NETC",
 118         "PERIPH",
 119         "LLTXULP",
 120         "D2P",
 121         "RCON",
 122         "LDMA",
 123         "LLTXP",
 124         "LLTXPB",
 125         "Unknown"
 126 };
 127
 128 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
 129 {
 130         struct be_dma_mem *mem = &q->dma_mem;
 131
 132         if (mem->va) {
 133                 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
 134                                   mem->dma);
 135                 mem->va = NULL;
 136         }
 137 }
 138
 139 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
 140                           u16 len, u16 entry_size)
 141 {
 142         struct be_dma_mem *mem = &q->dma_mem;
 143
 144         memset(q, 0, sizeof(*q));
 145         q->len = len;
 146         q->entry_size = entry_size;
 147         mem->size = len * entry_size;
 148         mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
 149                                       GFP_KERNEL);
 150         if (!mem->va)
 151                 return -ENOMEM;
 152         return 0;
 153 }
 154
 155 static void be_reg_intr_set(struct be_adapter *adapter, bool enable)
 156 {
 157         u32 reg, enabled;
 158
 159         pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
 160                               &reg);
 161         enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 162
 163         if (!enabled && enable)
 164                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 165         else if (enabled && !enable)
 166                 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
 167         else
 168                 return;
 169
 170         pci_write_config_dword(adapter->pdev,
 171                                PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
 172 }
 173
 174 static void be_intr_set(struct be_adapter *adapter, bool enable)
 175 {
 176         int status = 0;
 177
 178         /* On lancer interrupts can't be controlled via this register */
 179         if (lancer_chip(adapter))
 180                 return;
 181
 182         if (be_check_error(adapter, BE_ERROR_EEH))
 183                 return;
 184
 185         status = be_cmd_intr_set(adapter, enable);
 186         if (status)
 187                 be_reg_intr_set(adapter, enable);
 188 }
 189
 190 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
 191 {
 192         u32 val = 0;
 193
 194         if (be_check_error(adapter, BE_ERROR_HW))
 195                 return;
 196
 197         val |= qid & DB_RQ_RING_ID_MASK;
 198         val |= posted << DB_RQ_NUM_POSTED_SHIFT;
 199
 200         wmb();
 201         iowrite32(val, adapter->db + DB_RQ_OFFSET);
 202 }
 203
 204 static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
 205                           u16 posted)
 206 {
 207         u32 val = 0;
 208
 209         if (be_check_error(adapter, BE_ERROR_HW))
 210                 return;
 211
 212         val |= txo->q.id & DB_TXULP_RING_ID_MASK;
 213         val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
 214
 215         wmb();
 216         iowrite32(val, adapter->db + txo->db_offset);
 217 }
 218
 219 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
 220                          bool arm, bool clear_int, u16 num_popped,
 221                          u32 eq_delay_mult_enc)
 222 {
 223         u32 val = 0;
 224
 225         val |= qid & DB_EQ_RING_ID_MASK;
 226         val |= ((qid & DB_EQ_RING_ID_EXT_MASK) << DB_EQ_RING_ID_EXT_MASK_SHIFT);
 227
 228         if (be_check_error(adapter, BE_ERROR_HW))
 229                 return;
 230
 231         if (arm)
 232                 val |= 1 << DB_EQ_REARM_SHIFT;
 233         if (clear_int)
 234                 val |= 1 << DB_EQ_CLR_SHIFT;
 235         val |= 1 << DB_EQ_EVNT_SHIFT;
 236         val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
 237         val |= eq_delay_mult_enc << DB_EQ_R2I_DLY_SHIFT;
 238         iowrite32(val, adapter->db + DB_EQ_OFFSET);
 239 }
 240
 241 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
 242 {
 243         u32 val = 0;
 244
 245         val |= qid & DB_CQ_RING_ID_MASK;
 246         val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
 247                         DB_CQ_RING_ID_EXT_MASK_SHIFT);
 248
 249         if (be_check_error(adapter, BE_ERROR_HW))
 250                 return;
 251
 252         if (arm)
 253                 val |= 1 << DB_CQ_REARM_SHIFT;
 254         val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
 255         iowrite32(val, adapter->db + DB_CQ_OFFSET);
 256 }
 257
 258 static int be_mac_addr_set(struct net_device *netdev, void *p)
 259 {
 260         struct be_adapter *adapter = netdev_priv(netdev);
 261         struct device *dev = &adapter->pdev->dev;
 262         struct sockaddr *addr = p;
 263         int status;
 264         u8 mac[ETH_ALEN];
 265         u32 old_pmac_id = adapter->pmac_id[0], curr_pmac_id = 0;
 266
 267         if (!is_valid_ether_addr(addr->sa_data))
 268                 return -EADDRNOTAVAIL;
 269
 270         /* Proceed further only if, User provided MAC is different
 271          * from active MAC
 272          */
 273         if (ether_addr_equal(addr->sa_data, netdev->dev_addr))
 274                 return 0;
 275
 276         /* if device is not running, copy MAC to netdev->dev_addr */
 277         if (!netif_running(netdev))
 278                 goto done;
 279
 280         /* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT
 281          * privilege or if PF did not provision the new MAC address.
 282          * On BE3, this cmd will always fail if the VF doesn't have the
 283          * FILTMGMT privilege. This failure is OK, only if the PF programmed
 284          * the MAC for the VF.
 285          */
 286         status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
 287                                  adapter->if_handle, &adapter->pmac_id[0], 0);
 288         if (!status) {
 289                 curr_pmac_id = adapter->pmac_id[0];
 290
 291                 /* Delete the old programmed MAC. This call may fail if the
 292                  * old MAC was already deleted by the PF driver.
 293                  */
 294                 if (adapter->pmac_id[0] != old_pmac_id)
 295                         be_cmd_pmac_del(adapter, adapter->if_handle,
 296                                         old_pmac_id, 0);
 297         }
 298
 299         /* Decide if the new MAC is successfully activated only after
 300          * querying the FW
 301          */
 302         status = be_cmd_get_active_mac(adapter, curr_pmac_id, mac,
 303                                        adapter->if_handle, true, 0);
 304         if (status)
 305                 goto err;
 306
 307         /* The MAC change did not happen, either due to lack of privilege
 308          * or PF didn't pre-provision.
 309          */
 310         if (!ether_addr_equal(addr->sa_data, mac)) {
 311                 status = -EPERM;
 312                 goto err;
 313         }
 314 done:
 315         ether_addr_copy(netdev->dev_addr, addr->sa_data);
 316         dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
 317         return 0;
 318 err:
 319         dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data);
 320         return status;
 321 }
 322
 323 /* BE2 supports only v0 cmd */
 324 static void *hw_stats_from_cmd(struct be_adapter *adapter)
 325 {
 326         if (BE2_chip(adapter)) {
 327                 struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
 328
 329                 return &cmd->hw_stats;
 330         } else if (BE3_chip(adapter)) {
 331                 struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
 332
 333                 return &cmd->hw_stats;
 334         } else {
 335                 struct be_cmd_resp_get_stats_v2 *cmd = adapter->stats_cmd.va;
 336
 337                 return &cmd->hw_stats;
 338         }
 339 }
 340
 341 /* BE2 supports only v0 cmd */
 342 static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
 343 {
 344         if (BE2_chip(adapter)) {
 345                 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
 346
 347                 return &hw_stats->erx;
 348         } else if (BE3_chip(adapter)) {
 349                 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
 350
 351                 return &hw_stats->erx;
 352         } else {
 353                 struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
 354
 355                 return &hw_stats->erx;
 356         }
 357 }
 358
 359 static void populate_be_v0_stats(struct be_adapter *adapter)
 360 {
 361         struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
 362         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
 363         struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
 364         struct be_port_rxf_stats_v0 *port_stats =
 365                                         &rxf_stats->port[adapter->port_num];
 366         struct be_drv_stats *drvs = &adapter->drv_stats;
 367
 368         be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
 369         drvs->rx_pause_frames = port_stats->rx_pause_frames;
 370         drvs->rx_crc_errors = port_stats->rx_crc_errors;
 371         drvs->rx_control_frames = port_stats->rx_control_frames;
 372         drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
 373         drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
 374         drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
 375         drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
 376         drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
 377         drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
 378         drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
 379         drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
 380         drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
 381         drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
 382         drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
 383         drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
 384         drvs->rx_dropped_header_too_small =
 385                 port_stats->rx_dropped_header_too_small;
 386         drvs->rx_address_filtered =
 387                                         port_stats->rx_address_filtered +
 388                                         port_stats->rx_vlan_filtered;
 389         drvs->rx_alignment_symbol_errors =
 390                 port_stats->rx_alignment_symbol_errors;
 391
 392         drvs->tx_pauseframes = port_stats->tx_pauseframes;
 393         drvs->tx_controlframes = port_stats->tx_controlframes;
 394
 395         if (adapter->port_num)
 396                 drvs->jabber_events = rxf_stats->port1_jabber_events;
 397         else
 398                 drvs->jabber_events = rxf_stats->port0_jabber_events;
 399         drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
 400         drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
 401         drvs->forwarded_packets = rxf_stats->forwarded_packets;
 402         drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
 403         drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
 404         drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
 405         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 406 }
 407
 408 static void populate_be_v1_stats(struct be_adapter *adapter)
 409 {
 410         struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
 411         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
 412         struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
 413         struct be_port_rxf_stats_v1 *port_stats =
 414                                         &rxf_stats->port[adapter->port_num];
 415         struct be_drv_stats *drvs = &adapter->drv_stats;
 416
 417         be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
 418         drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
 419         drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
 420         drvs->rx_pause_frames = port_stats->rx_pause_frames;
 421         drvs->rx_crc_errors = port_stats->rx_crc_errors;
 422         drvs->rx_control_frames = port_stats->rx_control_frames;
 423         drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
 424         drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
 425         drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
 426         drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
 427         drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
 428         drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
 429         drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
 430         drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
 431         drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
 432         drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
 433         drvs->rx_dropped_header_too_small =
 434                 port_stats->rx_dropped_header_too_small;
 435         drvs->rx_input_fifo_overflow_drop =
 436                 port_stats->rx_input_fifo_overflow_drop;
 437         drvs->rx_address_filtered = port_stats->rx_address_filtered;
 438         drvs->rx_alignment_symbol_errors =
 439                 port_stats->rx_alignment_symbol_errors;
 440         drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
 441         drvs->tx_pauseframes = port_stats->tx_pauseframes;
 442         drvs->tx_controlframes = port_stats->tx_controlframes;
 443         drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
 444         drvs->jabber_events = port_stats->jabber_events;
 445         drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
 446         drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
 447         drvs->forwarded_packets = rxf_stats->forwarded_packets;
 448         drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
 449         drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
 450         drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
 451         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 452 }
 453
 454 static void populate_be_v2_stats(struct be_adapter *adapter)
 455 {
 456         struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
 457         struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
 458         struct be_rxf_stats_v2 *rxf_stats = &hw_stats->rxf;
 459         struct be_port_rxf_stats_v2 *port_stats =
 460                                         &rxf_stats->port[adapter->port_num];
 461         struct be_drv_stats *drvs = &adapter->drv_stats;
 462
 463         be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
 464         drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
 465         drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
 466         drvs->rx_pause_frames = port_stats->rx_pause_frames;
 467         drvs->rx_crc_errors = port_stats->rx_crc_errors;
 468         drvs->rx_control_frames = port_stats->rx_control_frames;
 469         drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
 470         drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
 471         drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
 472         drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
 473         drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
 474         drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
 475         drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
 476         drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
 477         drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
 478         drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
 479         drvs->rx_dropped_header_too_small =
 480                 port_stats->rx_dropped_header_too_small;
 481         drvs->rx_input_fifo_overflow_drop =
 482                 port_stats->rx_input_fifo_overflow_drop;
 483         drvs->rx_address_filtered = port_stats->rx_address_filtered;
 484         drvs->rx_alignment_symbol_errors =
 485                 port_stats->rx_alignment_symbol_errors;
 486         drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
 487         drvs->tx_pauseframes = port_stats->tx_pauseframes;
 488         drvs->tx_controlframes = port_stats->tx_controlframes;
 489         drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
 490         drvs->jabber_events = port_stats->jabber_events;
 491         drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
 492         drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
 493         drvs->forwarded_packets = rxf_stats->forwarded_packets;
 494         drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
 495         drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
 496         drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
 497         adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
 498         if (be_roce_supported(adapter)) {
 499                 drvs->rx_roce_bytes_lsd = port_stats->roce_bytes_received_lsd;
 500                 drvs->rx_roce_bytes_msd = port_stats->roce_bytes_received_msd;
 501                 drvs->rx_roce_frames = port_stats->roce_frames_received;
 502                 drvs->roce_drops_crc = port_stats->roce_drops_crc;
 503                 drvs->roce_drops_payload_len =
 504                         port_stats->roce_drops_payload_len;
 505         }
 506 }
 507
 508 static void populate_lancer_stats(struct be_adapter *adapter)
 509 {
 510         struct be_drv_stats *drvs = &adapter->drv_stats;
 511         struct lancer_pport_stats *pport_stats = pport_stats_from_cmd(adapter);
 512
 513         be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
 514         drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
 515         drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
 516         drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
 517         drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
 518         drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
 519         drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
 520         drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
 521         drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
 522         drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
 523         drvs->rx_dropped_tcp_length =
 524                                 pport_stats->rx_dropped_invalid_tcp_length;
 525         drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
 526         drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
 527         drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
 528         drvs->rx_dropped_header_too_small =
 529                                 pport_stats->rx_dropped_header_too_small;
 530         drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
 531         drvs->rx_address_filtered =
 532                                         pport_stats->rx_address_filtered +
 533                                         pport_stats->rx_vlan_filtered;
 534         drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
 535         drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
 536         drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
 537         drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
 538         drvs->jabber_events = pport_stats->rx_jabbers;
 539         drvs->forwarded_packets = pport_stats->num_forwards_lo;
 540         drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
 541         drvs->rx_drops_too_many_frags =
 542                                 pport_stats->rx_drops_too_many_frags_lo;
 543 }
 544
 545 static void accumulate_16bit_val(u32 *acc, u16 val)
 546 {
 547 #define lo(x)                   (x & 0xFFFF)
 548 #define hi(x)                   (x & 0xFFFF0000)
 549         bool wrapped = val < lo(*acc);
 550         u32 newacc = hi(*acc) + val;
 551
 552         if (wrapped)
 553                 newacc += 65536;
 554         ACCESS_ONCE(*acc) = newacc;
 555 }
 556
 557 static void populate_erx_stats(struct be_adapter *adapter,
 558                                struct be_rx_obj *rxo, u32 erx_stat)
 559 {
 560         if (!BEx_chip(adapter))
 561                 rx_stats(rxo)->rx_drops_no_frags = erx_stat;
 562         else
 563                 /* below erx HW counter can actually wrap around after
 564                  * 65535. Driver accumulates a 32-bit value
 565                  */
 566                 accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
 567                                      (u16)erx_stat);
 568 }
 569
 570 void be_parse_stats(struct be_adapter *adapter)
 571 {
 572         struct be_erx_stats_v2 *erx = be_erx_stats_from_cmd(adapter);
 573         struct be_rx_obj *rxo;
 574         int i;
 575         u32 erx_stat;
 576
 577         if (lancer_chip(adapter)) {
 578                 populate_lancer_stats(adapter);
 579         } else {
 580                 if (BE2_chip(adapter))
 581                         populate_be_v0_stats(adapter);
 582                 else if (BE3_chip(adapter))
 583                         /* for BE3 */
 584                         populate_be_v1_stats(adapter);
 585                 else
 586                         populate_be_v2_stats(adapter);
 587
 588                 /* erx_v2 is longer than v0, v1. use v2 for v0, v1 access */
 589                 for_all_rx_queues(adapter, rxo, i) {
 590                         erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
 591                         populate_erx_stats(adapter, rxo, erx_stat);
 592                 }
 593         }
 594 }
 595
 596 static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
 597                                                 struct rtnl_link_stats64 *stats)
 598 {
 599         struct be_adapter *adapter = netdev_priv(netdev);
 600         struct be_drv_stats *drvs = &adapter->drv_stats;
 601         struct be_rx_obj *rxo;
 602         struct be_tx_obj *txo;
 603         u64 pkts, bytes;
 604         unsigned int start;
 605         int i;
 606
 607         for_all_rx_queues(adapter, rxo, i) {
 608                 const struct be_rx_stats *rx_stats = rx_stats(rxo);
 609
 610                 do {
 611                         start = u64_stats_fetch_begin_irq(&rx_stats->sync);
 612                         pkts = rx_stats(rxo)->rx_pkts;
 613                         bytes = rx_stats(rxo)->rx_bytes;
 614                 } while (u64_stats_fetch_retry_irq(&rx_stats->sync, start));
 615                 stats->rx_packets += pkts;
 616                 stats->rx_bytes += bytes;
 617                 stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
 618                 stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
 619                                         rx_stats(rxo)->rx_drops_no_frags;
 620         }
 621
 622         for_all_tx_queues(adapter, txo, i) {
 623                 const struct be_tx_stats *tx_stats = tx_stats(txo);
 624
 625                 do {
 626                         start = u64_stats_fetch_begin_irq(&tx_stats->sync);
 627                         pkts = tx_stats(txo)->tx_pkts;
 628                         bytes = tx_stats(txo)->tx_bytes;
 629                 } while (u64_stats_fetch_retry_irq(&tx_stats->sync, start));
 630                 stats->tx_packets += pkts;
 631                 stats->tx_bytes += bytes;
 632         }
 633
 634         /* bad pkts received */
 635         stats->rx_errors = drvs->rx_crc_errors +
 636                 drvs->rx_alignment_symbol_errors +
 637                 drvs->rx_in_range_errors +
 638                 drvs->rx_out_range_errors +
 639                 drvs->rx_frame_too_long +
 640                 drvs->rx_dropped_too_small +
 641                 drvs->rx_dropped_too_short +
 642                 drvs->rx_dropped_header_too_small +
 643                 drvs->rx_dropped_tcp_length +
 644                 drvs->rx_dropped_runt;
 645
 646         /* detailed rx errors */
 647         stats->rx_length_errors = drvs->rx_in_range_errors +
 648                 drvs->rx_out_range_errors +
 649                 drvs->rx_frame_too_long;
 650
 651         stats->rx_crc_errors = drvs->rx_crc_errors;
 652
 653         /* frame alignment errors */
 654         stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
 655
 656         /* receiver fifo overrun */
 657         /* drops_no_pbuf is no per i/f, it's per BE card */
 658         stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
 659                                 drvs->rx_input_fifo_overflow_drop +
 660                                 drvs->rx_drops_no_pbuf;
 661         return stats;
 662 }
 663
 664 void be_link_status_update(struct be_adapter *adapter, u8 link_status)
 665 {
 666         struct net_device *netdev = adapter->netdev;
 667
 668         if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
 669                 netif_carrier_off(netdev);
 670                 adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
 671         }
 672
 673         if (link_status)
 674                 netif_carrier_on(netdev);
 675         else
 676                 netif_carrier_off(netdev);
 677
 678         netdev_info(netdev, "Link is %s\n", link_status ? "Up" : "Down");
 679 }
 680
 681 static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb)
 682 {
 683         struct be_tx_stats *stats = tx_stats(txo);
 684         u64 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1;
 685
 686         u64_stats_update_begin(&stats->sync);
 687         stats->tx_reqs++;
 688         stats->tx_bytes += skb->len;
 689         stats->tx_pkts += tx_pkts;
 690         if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL)
 691                 stats->tx_vxlan_offload_pkts += tx_pkts;
 692         u64_stats_update_end(&stats->sync);
 693 }
 694
 695 /* Returns number of WRBs needed for the skb */
 696 static u32 skb_wrb_cnt(struct sk_buff *skb)
 697 {
 698         /* +1 for the header wrb */
 699         return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags;
 700 }
 701
 702 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
 703 {
 704         wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr));
 705         wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr));
 706         wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK);
 707         wrb->rsvd0 = 0;
 708 }
 709
 710 /* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb
 711  * to avoid the swap and shift/mask operations in wrb_fill().
 712  */
 713 static inline void wrb_fill_dummy(struct be_eth_wrb *wrb)
 714 {
 715         wrb->frag_pa_hi = 0;
 716         wrb->frag_pa_lo = 0;
 717         wrb->frag_len = 0;
 718         wrb->rsvd0 = 0;
 719 }
 720
 721 static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
 722                                      struct sk_buff *skb)
 723 {
 724         u8 vlan_prio;
 725         u16 vlan_tag;
 726
 727         vlan_tag = skb_vlan_tag_get(skb);
 728         vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
 729         /* If vlan priority provided by OS is NOT in available bmap */
 730         if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
 731                 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
 732                                 adapter->recommended_prio;
 733
 734         return vlan_tag;
 735 }
 736
 737 /* Used only for IP tunnel packets */
 738 static u16 skb_inner_ip_proto(struct sk_buff *skb)
 739 {
 740         return (inner_ip_hdr(skb)->version == 4) ?
 741                 inner_ip_hdr(skb)->protocol : inner_ipv6_hdr(skb)->nexthdr;
 742 }
 743
 744 static u16 skb_ip_proto(struct sk_buff *skb)
 745 {
 746         return (ip_hdr(skb)->version == 4) ?
 747                 ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr;
 748 }
 749
 750 static inline bool be_is_txq_full(struct be_tx_obj *txo)
 751 {
 752         return atomic_read(&txo->q.used) + BE_MAX_TX_FRAG_COUNT >= txo->q.len;
 753 }
 754
 755 static inline bool be_can_txq_wake(struct be_tx_obj *txo)
 756 {
 757         return atomic_read(&txo->q.used) < txo->q.len / 2;
 758 }
 759
 760 static inline bool be_is_tx_compl_pending(struct be_tx_obj *txo)
 761 {
 762         return atomic_read(&txo->q.used) > txo->pend_wrb_cnt;
 763 }
 764
 765 static void be_get_wrb_params_from_skb(struct be_adapter *adapter,
 766                                        struct sk_buff *skb,
 767                                        struct be_wrb_params *wrb_params)
 768 {
 769         u16 proto;
 770
 771         if (skb_is_gso(skb)) {
 772                 BE_WRB_F_SET(wrb_params->features, LSO, 1);
 773                 wrb_params->lso_mss = skb_shinfo(skb)->gso_size;
 774                 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
 775                         BE_WRB_F_SET(wrb_params->features, LSO6, 1);
 776         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 777                 if (skb->encapsulation) {
 778                         BE_WRB_F_SET(wrb_params->features, IPCS, 1);
 779                         proto = skb_inner_ip_proto(skb);
 780                 } else {
 781                         proto = skb_ip_proto(skb);
 782                 }
 783                 if (proto == IPPROTO_TCP)
 784                         BE_WRB_F_SET(wrb_params->features, TCPCS, 1);
 785                 else if (proto == IPPROTO_UDP)
 786                         BE_WRB_F_SET(wrb_params->features, UDPCS, 1);
 787         }
 788
 789         if (skb_vlan_tag_present(skb)) {
 790                 BE_WRB_F_SET(wrb_params->features, VLAN, 1);
 791                 wrb_params->vlan_tag = be_get_tx_vlan_tag(adapter, skb);
 792         }
 793
 794         BE_WRB_F_SET(wrb_params->features, CRC, 1);
 795 }
 796
 797 static void wrb_fill_hdr(struct be_adapter *adapter,
 798                          struct be_eth_hdr_wrb *hdr,
 799                          struct be_wrb_params *wrb_params,
 800                          struct sk_buff *skb)
 801 {
 802         memset(hdr, 0, sizeof(*hdr));
 803
 804         SET_TX_WRB_HDR_BITS(crc, hdr,
 805                             BE_WRB_F_GET(wrb_params->features, CRC));
 806         SET_TX_WRB_HDR_BITS(ipcs, hdr,
 807                             BE_WRB_F_GET(wrb_params->features, IPCS));
 808         SET_TX_WRB_HDR_BITS(tcpcs, hdr,
 809                             BE_WRB_F_GET(wrb_params->features, TCPCS));
 810         SET_TX_WRB_HDR_BITS(udpcs, hdr,
 811                             BE_WRB_F_GET(wrb_params->features, UDPCS));
 812
 813         SET_TX_WRB_HDR_BITS(lso, hdr,
 814                             BE_WRB_F_GET(wrb_params->features, LSO));
 815         SET_TX_WRB_HDR_BITS(lso6, hdr,
 816                             BE_WRB_F_GET(wrb_params->features, LSO6));
 817         SET_TX_WRB_HDR_BITS(lso_mss, hdr, wrb_params->lso_mss);
 818
 819         /* Hack to skip HW VLAN tagging needs evt = 1, compl = 0. When this
 820          * hack is not needed, the evt bit is set while ringing DB.
 821          */
 822         SET_TX_WRB_HDR_BITS(event, hdr,
 823                             BE_WRB_F_GET(wrb_params->features, VLAN_SKIP_HW));
 824         SET_TX_WRB_HDR_BITS(vlan, hdr,
 825                             BE_WRB_F_GET(wrb_params->features, VLAN));
 826         SET_TX_WRB_HDR_BITS(vlan_tag, hdr, wrb_params->vlan_tag);
 827
 828         SET_TX_WRB_HDR_BITS(num_wrb, hdr, skb_wrb_cnt(skb));
 829         SET_TX_WRB_HDR_BITS(len, hdr, skb->len);
 830         SET_TX_WRB_HDR_BITS(mgmt, hdr,
 831                             BE_WRB_F_GET(wrb_params->features, OS2BMC));
 832 }
 833
 834 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
 835                           bool unmap_single)
 836 {
 837         dma_addr_t dma;
 838         u32 frag_len = le32_to_cpu(wrb->frag_len);
 839
 840
 841         dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 |
 842                 (u64)le32_to_cpu(wrb->frag_pa_lo);
 843         if (frag_len) {
 844                 if (unmap_single)
 845                         dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE);
 846                 else
 847                         dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE);
 848         }
 849 }
 850
 851 /* Grab a WRB header for xmit */
 852 static u16 be_tx_get_wrb_hdr(struct be_tx_obj *txo)
 853 {
 854         u16 head = txo->q.head;
 855
 856         queue_head_inc(&txo->q);
 857         return head;
 858 }
 859
 860 /* Set up the WRB header for xmit */
 861 static void be_tx_setup_wrb_hdr(struct be_adapter *adapter,
 862                                 struct be_tx_obj *txo,
 863                                 struct be_wrb_params *wrb_params,
 864                                 struct sk_buff *skb, u16 head)
 865 {
 866         u32 num_frags = skb_wrb_cnt(skb);
 867         struct be_queue_info *txq = &txo->q;
 868         struct be_eth_hdr_wrb *hdr = queue_index_node(txq, head);
 869
 870         wrb_fill_hdr(adapter, hdr, wrb_params, skb);
 871         be_dws_cpu_to_le(hdr, sizeof(*hdr));
 872
 873         BUG_ON(txo->sent_skb_list[head]);
 874         txo->sent_skb_list[head] = skb;
 875         txo->last_req_hdr = head;
 876         atomic_add(num_frags, &txq->used);
 877         txo->last_req_wrb_cnt = num_frags;
 878         txo->pend_wrb_cnt += num_frags;
 879 }
 880
 881 /* Setup a WRB fragment (buffer descriptor) for xmit */
 882 static void be_tx_setup_wrb_frag(struct be_tx_obj *txo, dma_addr_t busaddr,
 883                                  int len)
 884 {
 885         struct be_eth_wrb *wrb;
 886         struct be_queue_info *txq = &txo->q;
 887
 888         wrb = queue_head_node(txq);
 889         wrb_fill(wrb, busaddr, len);
 890         queue_head_inc(txq);
 891 }
 892
 893 /* Bring the queue back to the state it was in before be_xmit_enqueue() routine
 894  * was invoked. The producer index is restored to the previous packet and the
 895  * WRBs of the current packet are unmapped. Invoked to handle tx setup errors.
 896  */
 897 static void be_xmit_restore(struct be_adapter *adapter,
 898                             struct be_tx_obj *txo, u16 head, bool map_single,
 899                             u32 copied)
 900 {
 901         struct device *dev;
 902         struct be_eth_wrb *wrb;
 903         struct be_queue_info *txq = &txo->q;
 904
 905         dev = &adapter->pdev->dev;
 906         txq->head = head;
 907
 908         /* skip the first wrb (hdr); it's not mapped */
 909         queue_head_inc(txq);
 910         while (copied) {
 911                 wrb = queue_head_node(txq);
 912                 unmap_tx_frag(dev, wrb, map_single);
 913                 map_single = false;
 914                 copied -= le32_to_cpu(wrb->frag_len);
 915                 queue_head_inc(txq);
 916         }
 917
 918         txq->head = head;
 919 }
 920
 921 /* Enqueue the given packet for transmit. This routine allocates WRBs for the
 922  * packet, dma maps the packet buffers and sets up the WRBs. Returns the number
 923  * of WRBs used up by the packet.
 924  */
 925 static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo,
 926                            struct sk_buff *skb,
 927                            struct be_wrb_params *wrb_params)
 928 {
 929         u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb);
 930         struct device *dev = &adapter->pdev->dev;
 931         struct be_queue_info *txq = &txo->q;
 932         bool map_single = false;
 933         u16 head = txq->head;
 934         dma_addr_t busaddr;
 935         int len;
 936
 937         head = be_tx_get_wrb_hdr(txo);
 938
 939         if (skb->len > skb->data_len) {
 940                 len = skb_headlen(skb);
 941
 942                 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
 943                 if (dma_mapping_error(dev, busaddr))
 944                         goto dma_err;
 945                 map_single = true;
 946                 be_tx_setup_wrb_frag(txo, busaddr, len);
 947                 copied += len;
 948         }
 949
 950         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 951                 const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
 952                 len = skb_frag_size(frag);
 953
 954                 busaddr = skb_frag_dma_map(dev, frag, 0, len, DMA_TO_DEVICE);
 955                 if (dma_mapping_error(dev, busaddr))
 956                         goto dma_err;
 957                 be_tx_setup_wrb_frag(txo, busaddr, len);
 958                 copied += len;
 959         }
 960
 961         be_tx_setup_wrb_hdr(adapter, txo, wrb_params, skb, head);
 962
 963         be_tx_stats_update(txo, skb);
 964         return wrb_cnt;
 965
 966 dma_err:
 967         adapter->drv_stats.dma_map_errors++;
 968         be_xmit_restore(adapter, txo, head, map_single, copied);
 969         return 0;
 970 }
 971
 972 static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
 973 {
 974         return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
 975 }
 976
 977 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
 978                                              struct sk_buff *skb,
 979                                              struct be_wrb_params
 980                                              *wrb_params)
 981 {
 982         u16 vlan_tag = 0;
 983
 984         skb = skb_share_check(skb, GFP_ATOMIC);
 985         if (unlikely(!skb))
 986                 return skb;
 987
 988         if (skb_vlan_tag_present(skb))
 989                 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
 990
 991         if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
 992                 if (!vlan_tag)
 993                         vlan_tag = adapter->pvid;
 994                 /* f/w workaround to set skip_hw_vlan = 1, informs the F/W to
 995                  * skip VLAN insertion
 996                  */
 997                 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
 998         }
 999
1000         if (vlan_tag) {
1001                 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
1002                                                 vlan_tag);
1003                 if (unlikely(!skb))
1004                         return skb;
1005                 skb->vlan_tci = 0;
1006         }
1007
1008         /* Insert the outer VLAN, if any */
1009         if (adapter->qnq_vid) {
1010                 vlan_tag = adapter->qnq_vid;
1011                 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
1012                                                 vlan_tag);
1013                 if (unlikely(!skb))
1014                         return skb;
1015                 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1016         }
1017
1018         return skb;
1019 }
1020
1021 static bool be_ipv6_exthdr_check(struct sk_buff *skb)
1022 {
1023         struct ethhdr *eh = (struct ethhdr *)skb->data;
1024         u16 offset = ETH_HLEN;
1025
1026         if (eh->h_proto == htons(ETH_P_IPV6)) {
1027                 struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);
1028
1029                 offset += sizeof(struct ipv6hdr);
1030                 if (ip6h->nexthdr != NEXTHDR_TCP &&
1031                     ip6h->nexthdr != NEXTHDR_UDP) {
1032                         struct ipv6_opt_hdr *ehdr =
1033                                 (struct ipv6_opt_hdr *)(skb->data + offset);
1034
1035                         /* offending pkt: 2nd byte following IPv6 hdr is 0xff */
1036                         if (ehdr->hdrlen == 0xff)
1037                                 return true;
1038                 }
1039         }
1040         return false;
1041 }
1042
1043 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
1044 {
1045         return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
1046 }
1047
1048 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
1049 {
1050         return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
1051 }
1052
1053 static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
1054                                                   struct sk_buff *skb,
1055                                                   struct be_wrb_params
1056                                                   *wrb_params)
1057 {
1058         struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1059         unsigned int eth_hdr_len;
1060         struct iphdr *ip;
1061
1062         /* For padded packets, BE HW modifies tot_len field in IP header
1063          * incorrecly when VLAN tag is inserted by HW.
1064          * For padded packets, Lancer computes incorrect checksum.
1065          */
1066         eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
1067                                                 VLAN_ETH_HLEN : ETH_HLEN;
1068         if (skb->len <= 60 &&
1069             (lancer_chip(adapter) || skb_vlan_tag_present(skb)) &&
1070             is_ipv4_pkt(skb)) {
1071                 ip = (struct iphdr *)ip_hdr(skb);
1072                 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
1073         }
1074
1075         /* If vlan tag is already inlined in the packet, skip HW VLAN
1076          * tagging in pvid-tagging mode
1077          */
1078         if (be_pvid_tagging_enabled(adapter) &&
1079             veh->h_vlan_proto == htons(ETH_P_8021Q))
1080                 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1081
1082         /* HW has a bug wherein it will calculate CSUM for VLAN
1083          * pkts even though it is disabled.
1084          * Manually insert VLAN in pkt.
1085          */
1086         if (skb->ip_summed != CHECKSUM_PARTIAL &&
1087             skb_vlan_tag_present(skb)) {
1088                 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1089                 if (unlikely(!skb))
1090                         goto err;
1091         }
1092
1093         /* HW may lockup when VLAN HW tagging is requested on
1094          * certain ipv6 packets. Drop such pkts if the HW workaround to
1095          * skip HW tagging is not enabled by FW.
1096          */
1097         if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
1098                      (adapter->pvid || adapter->qnq_vid) &&
1099                      !qnq_async_evt_rcvd(adapter)))
1100                 goto tx_drop;
1101
1102         /* Manual VLAN tag insertion to prevent:
1103          * ASIC lockup when the ASIC inserts VLAN tag into
1104          * certain ipv6 packets. Insert VLAN tags in driver,
1105          * and set event, completion, vlan bits accordingly
1106          * in the Tx WRB.
1107          */
1108         if (be_ipv6_tx_stall_chk(adapter, skb) &&
1109             be_vlan_tag_tx_chk(adapter, skb)) {
1110                 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1111                 if (unlikely(!skb))
1112                         goto err;
1113         }
1114
1115         return skb;
1116 tx_drop:
1117         dev_kfree_skb_any(skb);
1118 err:
1119         return NULL;
1120 }
1121
1122 static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
1123                                            struct sk_buff *skb,
1124                                            struct be_wrb_params *wrb_params)
1125 {
1126         /* Lancer, SH and BE3 in SRIOV mode have a bug wherein
1127          * packets that are 32b or less may cause a transmit stall
1128          * on that port. The workaround is to pad such packets
1129          * (len <= 32 bytes) to a minimum length of 36b.
1130          */
1131         if (skb->len <= 32) {
1132                 if (skb_put_padto(skb, 36))
1133                         return NULL;
1134         }
1135
1136         if (BEx_chip(adapter) || lancer_chip(adapter)) {
1137                 skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params);
1138                 if (!skb)
1139                         return NULL;
1140         }
1141
1142         return skb;
1143 }
1144
1145 static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo)
1146 {
1147         struct be_queue_info *txq = &txo->q;
1148         struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr);
1149
1150         /* Mark the last request eventable if it hasn't been marked already */
1151         if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT)))
1152                 hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL);
1153
1154         /* compose a dummy wrb if there are odd set of wrbs to notify */
1155         if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) {
1156                 wrb_fill_dummy(queue_head_node(txq));
1157                 queue_head_inc(txq);
1158                 atomic_inc(&txq->used);
1159                 txo->pend_wrb_cnt++;
1160                 hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK <<
1161                                            TX_HDR_WRB_NUM_SHIFT);
1162                 hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) <<
1163                                           TX_HDR_WRB_NUM_SHIFT);
1164         }
1165         be_txq_notify(adapter, txo, txo->pend_wrb_cnt);
1166         txo->pend_wrb_cnt = 0;
1167 }
1168
1169 /* OS2BMC related */
1170
1171 #define DHCP_CLIENT_PORT        68
1172 #define DHCP_SERVER_PORT        67
1173 #define NET_BIOS_PORT1          137
1174 #define NET_BIOS_PORT2          138
1175 #define DHCPV6_RAS_PORT         547
1176
1177 #define is_mc_allowed_on_bmc(adapter, eh)       \
1178         (!is_multicast_filt_enabled(adapter) && \
1179          is_multicast_ether_addr(eh->h_dest) && \
1180          !is_broadcast_ether_addr(eh->h_dest))
1181
1182 #define is_bc_allowed_on_bmc(adapter, eh)       \
1183         (!is_broadcast_filt_enabled(adapter) && \
1184          is_broadcast_ether_addr(eh->h_dest))
1185
1186 #define is_arp_allowed_on_bmc(adapter, skb)     \
1187         (is_arp(skb) && is_arp_filt_enabled(adapter))
1188
1189 #define is_broadcast_packet(eh, adapter)        \
1190                 (is_multicast_ether_addr(eh->h_dest) && \
1191                 !compare_ether_addr(eh->h_dest, adapter->netdev->broadcast))
1192
1193 #define is_arp(skb)     (skb->protocol == htons(ETH_P_ARP))
1194
1195 #define is_arp_filt_enabled(adapter)    \
1196                 (adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP))
1197
1198 #define is_dhcp_client_filt_enabled(adapter)    \
1199                 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT)
1200
1201 #define is_dhcp_srvr_filt_enabled(adapter)      \
1202                 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER)
1203
1204 #define is_nbios_filt_enabled(adapter)  \
1205                 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS)
1206
1207 #define is_ipv6_na_filt_enabled(adapter)        \
1208                 (adapter->bmc_filt_mask &       \
1209                         BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER)
1210
1211 #define is_ipv6_ra_filt_enabled(adapter)        \
1212                 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA)
1213
1214 #define is_ipv6_ras_filt_enabled(adapter)       \
1215                 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS)
1216
1217 #define is_broadcast_filt_enabled(adapter)      \
1218                 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST)
1219
1220 #define is_multicast_filt_enabled(adapter)      \
1221                 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST)
1222
1223 static bool be_send_pkt_to_bmc(struct be_adapter *adapter,
1224                                struct sk_buff **skb)
1225 {
1226         struct ethhdr *eh = (struct ethhdr *)(*skb)->data;
1227         bool os2bmc = false;
1228
1229         if (!be_is_os2bmc_enabled(adapter))
1230                 goto done;
1231
1232         if (!is_multicast_ether_addr(eh->h_dest))
1233                 goto done;
1234
1235         if (is_mc_allowed_on_bmc(adapter, eh) ||
1236             is_bc_allowed_on_bmc(adapter, eh) ||
1237             is_arp_allowed_on_bmc(adapter, (*skb))) {
1238                 os2bmc = true;
1239                 goto done;
1240         }
1241
1242         if ((*skb)->protocol == htons(ETH_P_IPV6)) {
1243                 struct ipv6hdr *hdr = ipv6_hdr((*skb));
1244                 u8 nexthdr = hdr->nexthdr;
1245
1246                 if (nexthdr == IPPROTO_ICMPV6) {
1247                         struct icmp6hdr *icmp6 = icmp6_hdr((*skb));
1248
1249                         switch (icmp6->icmp6_type) {
1250                         case NDISC_ROUTER_ADVERTISEMENT:
1251                                 os2bmc = is_ipv6_ra_filt_enabled(adapter);
1252                                 goto done;
1253                         case NDISC_NEIGHBOUR_ADVERTISEMENT:
1254                                 os2bmc = is_ipv6_na_filt_enabled(adapter);
1255                                 goto done;
1256                         default:
1257                                 break;
1258                         }
1259                 }
1260         }
1261
1262         if (is_udp_pkt((*skb))) {
1263                 struct udphdr *udp = udp_hdr((*skb));
1264
1265                 switch (ntohs(udp->dest)) {
1266                 case DHCP_CLIENT_PORT:
1267                         os2bmc = is_dhcp_client_filt_enabled(adapter);
1268                         goto done;
1269                 case DHCP_SERVER_PORT:
1270                         os2bmc = is_dhcp_srvr_filt_enabled(adapter);
1271                         goto done;
1272                 case NET_BIOS_PORT1:
1273                 case NET_BIOS_PORT2:
1274                         os2bmc = is_nbios_filt_enabled(adapter);
1275                         goto done;
1276                 case DHCPV6_RAS_PORT:
1277                         os2bmc = is_ipv6_ras_filt_enabled(adapter);
1278                         goto done;
1279                 default:
1280                         break;
1281                 }
1282         }
1283 done:
1284         /* For packets over a vlan, which are destined
1285          * to BMC, asic expects the vlan to be inline in the packet.
1286          */
1287         if (os2bmc)
1288                 *skb = be_insert_vlan_in_pkt(adapter, *skb, NULL);
1289
1290         return os2bmc;
1291 }
1292
1293 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
1294 {
1295         struct be_adapter *adapter = netdev_priv(netdev);
1296         u16 q_idx = skb_get_queue_mapping(skb);
1297         struct be_tx_obj *txo = &adapter->tx_obj[q_idx];
1298         struct be_wrb_params wrb_params = { 0 };
1299         bool flush = !skb->xmit_more;
1300         u16 wrb_cnt;
1301
1302         skb = be_xmit_workarounds(adapter, skb, &wrb_params);
1303         if (unlikely(!skb))
1304                 goto drop;
1305
1306         be_get_wrb_params_from_skb(adapter, skb, &wrb_params);
1307
1308         wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1309         if (unlikely(!wrb_cnt)) {
1310                 dev_kfree_skb_any(skb);
1311                 goto drop;
1312         }
1313
1314         /* if os2bmc is enabled and if the pkt is destined to bmc,
1315          * enqueue the pkt a 2nd time with mgmt bit set.
1316          */
1317         if (be_send_pkt_to_bmc(adapter, &skb)) {
1318                 BE_WRB_F_SET(wrb_params.features, OS2BMC, 1);
1319                 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1320                 if (unlikely(!wrb_cnt))
1321                         goto drop;
1322                 else
1323                         skb_get(skb);
1324         }
1325
1326         if (be_is_txq_full(txo)) {
1327                 netif_stop_subqueue(netdev, q_idx);
1328                 tx_stats(txo)->tx_stops++;
1329         }
1330
1331         if (flush || __netif_subqueue_stopped(netdev, q_idx))
1332                 be_xmit_flush(adapter, txo);
1333
1334         return NETDEV_TX_OK;
1335 drop:
1336         tx_stats(txo)->tx_drv_drops++;
1337         /* Flush the already enqueued tx requests */
1338         if (flush && txo->pend_wrb_cnt)
1339                 be_xmit_flush(adapter, txo);
1340
1341         return NETDEV_TX_OK;
1342 }
1343
1344 static int be_change_mtu(struct net_device *netdev, int new_mtu)
1345 {
1346         struct be_adapter *adapter = netdev_priv(netdev);
1347         struct device *dev = &adapter->pdev->dev;
1348
1349         if (new_mtu < BE_MIN_MTU || new_mtu > BE_MAX_MTU) {
1350                 dev_info(dev, "MTU must be between %d and %d bytes\n",
1351                          BE_MIN_MTU, BE_MAX_MTU);
1352                 return -EINVAL;
1353         }
1354
1355         dev_info(dev, "MTU changed from %d to %d bytes\n",
1356                  netdev->mtu, new_mtu);
1357         netdev->mtu = new_mtu;
1358         return 0;
1359 }
1360
1361 static inline bool be_in_all_promisc(struct be_adapter *adapter)
1362 {
1363         return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) ==
1364                         BE_IF_FLAGS_ALL_PROMISCUOUS;
1365 }
1366
1367 static int be_set_vlan_promisc(struct be_adapter *adapter)
1368 {
1369         struct device *dev = &adapter->pdev->dev;
1370         int status;
1371
1372         if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS)
1373                 return 0;
1374
1375         status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON);
1376         if (!status) {
1377                 dev_info(dev, "Enabled VLAN promiscuous mode\n");
1378                 adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS;
1379         } else {
1380                 dev_err(dev, "Failed to enable VLAN promiscuous mode\n");
1381         }
1382         return status;
1383 }
1384
1385 static int be_clear_vlan_promisc(struct be_adapter *adapter)
1386 {
1387         struct device *dev = &adapter->pdev->dev;
1388         int status;
1389
1390         status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF);
1391         if (!status) {
1392                 dev_info(dev, "Disabling VLAN promiscuous mode\n");
1393                 adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
1394         }
1395         return status;
1396 }
1397
1398 /*
1399  * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
1400  * If the user configures more, place BE in vlan promiscuous mode.
1401  */
1402 static int be_vid_config(struct be_adapter *adapter)
1403 {
1404         struct device *dev = &adapter->pdev->dev;
1405         u16 vids[BE_NUM_VLANS_SUPPORTED];
1406         u16 num = 0, i = 0;
1407         int status = 0;
1408
1409         /* No need to further configure vids if in promiscuous mode */
1410         if (be_in_all_promisc(adapter))
1411                 return 0;
1412
1413         if (adapter->vlans_added > be_max_vlans(adapter))
1414                 return be_set_vlan_promisc(adapter);
1415
1416         /* Construct VLAN Table to give to HW */
1417         for_each_set_bit(i, adapter->vids, VLAN_N_VID)
1418                 vids[num++] = cpu_to_le16(i);
1419
1420         status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0);
1421         if (status) {
1422                 dev_err(dev, "Setting HW VLAN filtering failed\n");
1423                 /* Set to VLAN promisc mode as setting VLAN filter failed */
1424                 if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS ||
1425                     addl_status(status) ==
1426                                 MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES)
1427                         return be_set_vlan_promisc(adapter);
1428         } else if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
1429                 status = be_clear_vlan_promisc(adapter);
1430         }
1431         return status;
1432 }
1433
1434 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
1435 {
1436         struct be_adapter *adapter = netdev_priv(netdev);
1437         int status = 0;
1438
1439         /* Packets with VID 0 are always received by Lancer by default */
1440         if (lancer_chip(adapter) && vid == 0)
1441                 return status;
1442
1443         if (test_bit(vid, adapter->vids))
1444                 return status;
1445
1446         set_bit(vid, adapter->vids);
1447         adapter->vlans_added++;
1448
1449         status = be_vid_config(adapter);
1450         if (status) {
1451                 adapter->vlans_added--;
1452                 clear_bit(vid, adapter->vids);
1453         }
1454
1455         return status;
1456 }
1457
1458 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
1459 {
1460         struct be_adapter *adapter = netdev_priv(netdev);
1461
1462         /* Packets with VID 0 are always received by Lancer by default */
1463         if (lancer_chip(adapter) && vid == 0)
1464                 return 0;
1465
1466         clear_bit(vid, adapter->vids);
1467         adapter->vlans_added--;
1468
1469         return be_vid_config(adapter);
1470 }
1471
1472 static void be_clear_all_promisc(struct be_adapter *adapter)
1473 {
1474         be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, OFF);
1475         adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS;
1476 }
1477
1478 static void be_set_all_promisc(struct be_adapter *adapter)
1479 {
1480         be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON);
1481         adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS;
1482 }
1483
1484 static void be_set_mc_promisc(struct be_adapter *adapter)
1485 {
1486         int status;
1487
1488         if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS)
1489                 return;
1490
1491         status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON);
1492         if (!status)
1493                 adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS;
1494 }
1495
1496 static void be_set_mc_list(struct be_adapter *adapter)
1497 {
1498         int status;
1499
1500         status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON);
1501         if (!status)
1502                 adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS;
1503         else
1504                 be_set_mc_promisc(adapter);
1505 }
1506
1507 static void be_set_uc_list(struct be_adapter *adapter)
1508 {
1509         struct netdev_hw_addr *ha;
1510         int i = 1; /* First slot is claimed by the Primary MAC */
1511
1512         for (; adapter->uc_macs > 0; adapter->uc_macs--, i++)
1513                 be_cmd_pmac_del(adapter, adapter->if_handle,
1514                                 adapter->pmac_id[i], 0);
1515
1516         if (netdev_uc_count(adapter->netdev) > be_max_uc(adapter)) {
1517                 be_set_all_promisc(adapter);
1518                 return;
1519         }
1520
1521         netdev_for_each_uc_addr(ha, adapter->netdev) {
1522                 adapter->uc_macs++; /* First slot is for Primary MAC */
1523                 be_cmd_pmac_add(adapter, (u8 *)ha->addr, adapter->if_handle,
1524                                 &adapter->pmac_id[adapter->uc_macs], 0);
1525         }
1526 }
1527
1528 static void be_clear_uc_list(struct be_adapter *adapter)
1529 {
1530         int i;
1531
1532         for (i = 1; i < (adapter->uc_macs + 1); i++)
1533                 be_cmd_pmac_del(adapter, adapter->if_handle,
1534                                 adapter->pmac_id[i], 0);
1535         adapter->uc_macs = 0;
1536 }
1537
1538 static void be_set_rx_mode(struct net_device *netdev)
1539 {
1540         struct be_adapter *adapter = netdev_priv(netdev);
1541
1542         if (netdev->flags & IFF_PROMISC) {
1543                 be_set_all_promisc(adapter);
1544                 return;
1545         }
1546
1547         /* Interface was previously in promiscuous mode; disable it */
1548         if (be_in_all_promisc(adapter)) {
1549                 be_clear_all_promisc(adapter);
1550                 if (adapter->vlans_added)
1551                         be_vid_config(adapter);
1552         }
1553
1554         /* Enable multicast promisc if num configured exceeds what we support */
1555         if (netdev->flags & IFF_ALLMULTI ||
1556             netdev_mc_count(netdev) > be_max_mc(adapter)) {
1557                 be_set_mc_promisc(adapter);
1558                 return;
1559         }
1560
1561         if (netdev_uc_count(netdev) != adapter->uc_macs)
1562                 be_set_uc_list(adapter);
1563
1564         be_set_mc_list(adapter);
1565 }
1566
1567 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1568 {
1569         struct be_adapter *adapter = netdev_priv(netdev);
1570         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1571         int status;
1572
1573         if (!sriov_enabled(adapter))
1574                 return -EPERM;
1575
1576         if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
1577                 return -EINVAL;
1578
1579         /* Proceed further only if user provided MAC is different
1580          * from active MAC
1581          */
1582         if (ether_addr_equal(mac, vf_cfg->mac_addr))
1583                 return 0;
1584
1585         if (BEx_chip(adapter)) {
1586                 be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id,
1587                                 vf + 1);
1588
1589                 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
1590                                          &vf_cfg->pmac_id, vf + 1);
1591         } else {
1592                 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
1593                                         vf + 1);
1594         }
1595
1596         if (status) {
1597                 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x",
1598                         mac, vf, status);
1599                 return be_cmd_status(status);
1600         }
1601
1602         ether_addr_copy(vf_cfg->mac_addr, mac);
1603
1604         return 0;
1605 }
1606
1607 static int be_get_vf_config(struct net_device *netdev, int vf,
1608                             struct ifla_vf_info *vi)
1609 {
1610         struct be_adapter *adapter = netdev_priv(netdev);
1611         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1612
1613         if (!sriov_enabled(adapter))
1614                 return -EPERM;
1615
1616         if (vf >= adapter->num_vfs)
1617                 return -EINVAL;
1618
1619         vi->vf = vf;
1620         vi->max_tx_rate = vf_cfg->tx_rate;
1621         vi->min_tx_rate = 0;
1622         vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK;
1623         vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT;
1624         memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
1625         vi->linkstate = adapter->vf_cfg[vf].plink_tracking;
1626         vi->spoofchk = adapter->vf_cfg[vf].spoofchk;
1627
1628         return 0;
1629 }
1630
1631 static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan)
1632 {
1633         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1634         u16 vids[BE_NUM_VLANS_SUPPORTED];
1635         int vf_if_id = vf_cfg->if_handle;
1636         int status;
1637
1638         /* Enable Transparent VLAN Tagging */
1639         status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0);
1640         if (status)
1641                 return status;
1642
1643         /* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */
1644         vids[0] = 0;
1645         status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1);
1646         if (!status)
1647                 dev_info(&adapter->pdev->dev,
1648                          "Cleared guest VLANs on VF%d", vf);
1649
1650         /* After TVT is enabled, disallow VFs to program VLAN filters */
1651         if (vf_cfg->privileges & BE_PRIV_FILTMGMT) {
1652                 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges &
1653                                                   ~BE_PRIV_FILTMGMT, vf + 1);
1654                 if (!status)
1655                         vf_cfg->privileges &= ~BE_PRIV_FILTMGMT;
1656         }
1657         return 0;
1658 }
1659
1660 static int be_clear_vf_tvt(struct be_adapter *adapter, int vf)
1661 {
1662         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1663         struct device *dev = &adapter->pdev->dev;
1664         int status;
1665
1666         /* Reset Transparent VLAN Tagging. */
1667         status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1,
1668                                        vf_cfg->if_handle, 0, 0);
1669         if (status)
1670                 return status;
1671
1672         /* Allow VFs to program VLAN filtering */
1673         if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
1674                 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges |
1675                                                   BE_PRIV_FILTMGMT, vf + 1);
1676                 if (!status) {
1677                         vf_cfg->privileges |= BE_PRIV_FILTMGMT;
1678                         dev_info(dev, "VF%d: FILTMGMT priv enabled", vf);
1679                 }
1680         }
1681
1682         dev_info(dev,
1683                  "Disable/re-enable i/f in VM to clear Transparent VLAN tag");
1684         return 0;
1685 }
1686
1687 static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
1688 {
1689         struct be_adapter *adapter = netdev_priv(netdev);
1690         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1691         int status;
1692
1693         if (!sriov_enabled(adapter))
1694                 return -EPERM;
1695
1696         if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7)
1697                 return -EINVAL;
1698
1699         if (vlan || qos) {
1700                 vlan |= qos << VLAN_PRIO_SHIFT;
1701                 status = be_set_vf_tvt(adapter, vf, vlan);
1702         } else {
1703                 status = be_clear_vf_tvt(adapter, vf);
1704         }
1705
1706         if (status) {
1707                 dev_err(&adapter->pdev->dev,
1708                         "VLAN %d config on VF %d failed : %#x\n", vlan, vf,
1709                         status);
1710                 return be_cmd_status(status);
1711         }
1712
1713         vf_cfg->vlan_tag = vlan;
1714         return 0;
1715 }
1716
1717 static int be_set_vf_tx_rate(struct net_device *netdev, int vf,
1718                              int min_tx_rate, int max_tx_rate)
1719 {
1720         struct be_adapter *adapter = netdev_priv(netdev);
1721         struct device *dev = &adapter->pdev->dev;
1722         int percent_rate, status = 0;
1723         u16 link_speed = 0;
1724         u8 link_status;
1725
1726         if (!sriov_enabled(adapter))
1727                 return -EPERM;
1728
1729         if (vf >= adapter->num_vfs)
1730                 return -EINVAL;
1731
1732         if (min_tx_rate)
1733                 return -EINVAL;
1734
1735         if (!max_tx_rate)
1736                 goto config_qos;
1737
1738         status = be_cmd_link_status_query(adapter, &link_speed,
1739                                           &link_status, 0);
1740         if (status)
1741                 goto err;
1742
1743         if (!link_status) {
1744                 dev_err(dev, "TX-rate setting not allowed when link is down\n");
1745                 status = -ENETDOWN;
1746                 goto err;
1747         }
1748
1749         if (max_tx_rate < 100 || max_tx_rate > link_speed) {
1750                 dev_err(dev, "TX-rate must be between 100 and %d Mbps\n",
1751                         link_speed);
1752                 status = -EINVAL;
1753                 goto err;
1754         }
1755
1756         /* On Skyhawk the QOS setting must be done only as a % value */
1757         percent_rate = link_speed / 100;
1758         if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) {
1759                 dev_err(dev, "TX-rate must be a multiple of %d Mbps\n",
1760                         percent_rate);
1761                 status = -EINVAL;
1762                 goto err;
1763         }
1764
1765 config_qos:
1766         status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1);
1767         if (status)
1768                 goto err;
1769
1770         adapter->vf_cfg[vf].tx_rate = max_tx_rate;
1771         return 0;
1772
1773 err:
1774         dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n",
1775                 max_tx_rate, vf);
1776         return be_cmd_status(status);
1777 }
1778
1779 static int be_set_vf_link_state(struct net_device *netdev, int vf,
1780                                 int link_state)
1781 {
1782         struct be_adapter *adapter = netdev_priv(netdev);
1783         int status;
1784
1785         if (!sriov_enabled(adapter))
1786                 return -EPERM;
1787
1788         if (vf >= adapter->num_vfs)
1789                 return -EINVAL;
1790
1791         status = be_cmd_set_logical_link_config(adapter, link_state, vf+1);
1792         if (status) {
1793                 dev_err(&adapter->pdev->dev,
1794                         "Link state change on VF %d failed: %#x\n", vf, status);
1795                 return be_cmd_status(status);
1796         }
1797
1798         adapter->vf_cfg[vf].plink_tracking = link_state;
1799
1800         return 0;
1801 }
1802
1803 static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable)
1804 {
1805         struct be_adapter *adapter = netdev_priv(netdev);
1806         struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1807         u8 spoofchk;
1808         int status;
1809
1810         if (!sriov_enabled(adapter))
1811                 return -EPERM;
1812
1813         if (vf >= adapter->num_vfs)
1814                 return -EINVAL;
1815
1816         if (BEx_chip(adapter))
1817                 return -EOPNOTSUPP;
1818
1819         if (enable == vf_cfg->spoofchk)
1820                 return 0;
1821
1822         spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK;
1823
1824         status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle,
1825                                        0, spoofchk);
1826         if (status) {
1827                 dev_err(&adapter->pdev->dev,
1828                         "Spoofchk change on VF %d failed: %#x\n", vf, status);
1829                 return be_cmd_status(status);
1830         }
1831
1832         vf_cfg->spoofchk = enable;
1833         return 0;
1834 }
1835
1836 static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts,
1837                           ulong now)
1838 {
1839         aic->rx_pkts_prev = rx_pkts;
1840         aic->tx_reqs_prev = tx_pkts;
1841         aic->jiffies = now;
1842 }
1843
1844 static int be_get_new_eqd(struct be_eq_obj *eqo)
1845 {
1846         struct be_adapter *adapter = eqo->adapter;
1847         int eqd, start;
1848         struct be_aic_obj *aic;
1849         struct be_rx_obj *rxo;
1850         struct be_tx_obj *txo;
1851         u64 rx_pkts = 0, tx_pkts = 0;
1852         ulong now;
1853         u32 pps, delta;
1854         int i;
1855
1856         aic = &adapter->aic_obj[eqo->idx];
1857         if (!aic->enable) {
1858                 if (aic->jiffies)
1859                         aic->jiffies = 0;
1860                 eqd = aic->et_eqd;
1861                 return eqd;
1862         }
1863
1864         for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
1865                 do {
1866                         start = u64_stats_fetch_begin_irq(&rxo->stats.sync);
1867                         rx_pkts += rxo->stats.rx_pkts;
1868                 } while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start));
1869         }
1870
1871         for_all_tx_queues_on_eq(adapter, eqo, txo, i) {
1872                 do {
1873                         start = u64_stats_fetch_begin_irq(&txo->stats.sync);
1874                         tx_pkts += txo->stats.tx_reqs;
1875                 } while (u64_stats_fetch_retry_irq(&txo->stats.sync, start));
1876         }
1877
1878         /* Skip, if wrapped around or first calculation */
1879         now = jiffies;
1880         if (!aic->jiffies || time_before(now, aic->jiffies) ||
1881             rx_pkts < aic->rx_pkts_prev ||
1882             tx_pkts < aic->tx_reqs_prev) {
1883                 be_aic_update(aic, rx_pkts, tx_pkts, now);
1884                 return aic->prev_eqd;
1885         }
1886
1887         delta = jiffies_to_msecs(now - aic->jiffies);
1888         if (delta == 0)
1889                 return aic->prev_eqd;
1890
1891         pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) +
1892                 (((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta);
1893         eqd = (pps / 15000) << 2;
1894
1895         if (eqd < 8)
1896                 eqd = 0;
1897         eqd = min_t(u32, eqd, aic->max_eqd);
1898         eqd = max_t(u32, eqd, aic->min_eqd);
1899
1900         be_aic_update(aic, rx_pkts, tx_pkts, now);
1901
1902         return eqd;
1903 }
1904
1905 /* For Skyhawk-R only */
1906 static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo)
1907 {
1908         struct be_adapter *adapter = eqo->adapter;
1909         struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx];
1910         ulong now = jiffies;
1911         int eqd;
1912         u32 mult_enc;
1913
1914         if (!aic->enable)
1915                 return 0;
1916
1917         if (time_before_eq(now, aic->jiffies) ||
1918             jiffies_to_msecs(now - aic->jiffies) < 1)
1919                 eqd = aic->prev_eqd;
1920         else
1921                 eqd = be_get_new_eqd(eqo);
1922
1923         if (eqd > 100)
1924                 mult_enc = R2I_DLY_ENC_1;
1925         else if (eqd > 60)
1926                 mult_enc = R2I_DLY_ENC_2;
1927         else if (eqd > 20)
1928                 mult_enc = R2I_DLY_ENC_3;
1929         else
1930                 mult_enc = R2I_DLY_ENC_0;
1931
1932         aic->prev_eqd = eqd;
1933
1934         return mult_enc;
1935 }
1936
1937 void be_eqd_update(struct be_adapter *adapter, bool force_update)
1938 {
1939         struct be_set_eqd set_eqd[MAX_EVT_QS];
1940         struct be_aic_obj *aic;
1941         struct be_eq_obj *eqo;
1942         int i, num = 0, eqd;
1943
1944         for_all_evt_queues(adapter, eqo, i) {
1945                 aic = &adapter->aic_obj[eqo->idx];
1946                 eqd = be_get_new_eqd(eqo);
1947                 if (force_update || eqd != aic->prev_eqd) {
1948                         set_eqd[num].delay_multiplier = (eqd * 65)/100;
1949                         set_eqd[num].eq_id = eqo->q.id;
1950                         aic->prev_eqd = eqd;
1951                         num++;
1952                 }
1953         }
1954
1955         if (num)
1956                 be_cmd_modify_eqd(adapter, set_eqd, num);
1957 }
1958
1959 static void be_rx_stats_update(struct be_rx_obj *rxo,
1960                                struct be_rx_compl_info *rxcp)
1961 {
1962         struct be_rx_stats *stats = rx_stats(rxo);
1963
1964         u64_stats_update_begin(&stats->sync);
1965         stats->rx_compl++;
1966         stats->rx_bytes += rxcp->pkt_size;
1967         stats->rx_pkts++;
1968         if (rxcp->tunneled)
1969                 stats->rx_vxlan_offload_pkts++;
1970         if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1971                 stats->rx_mcast_pkts++;
1972         if (rxcp->err)
1973                 stats->rx_compl_err++;
1974         u64_stats_update_end(&stats->sync);
1975 }
1976
1977 static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1978 {
1979         /* L4 checksum is not reliable for non TCP/UDP packets.
1980          * Also ignore ipcksm for ipv6 pkts
1981          */
1982         return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
1983                 (rxcp->ip_csum || rxcp->ipv6) && !rxcp->err;
1984 }
1985
1986 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo)
1987 {
1988         struct be_adapter *adapter = rxo->adapter;
1989         struct be_rx_page_info *rx_page_info;
1990         struct be_queue_info *rxq = &rxo->q;
1991         u16 frag_idx = rxq->tail;
1992
1993         rx_page_info = &rxo->page_info_tbl[frag_idx];
1994         BUG_ON(!rx_page_info->page);
1995
1996         if (rx_page_info->last_frag) {
1997                 dma_unmap_page(&adapter->pdev->dev,
1998                                dma_unmap_addr(rx_page_info, bus),
1999                                adapter->big_page_size, DMA_FROM_DEVICE);
2000                 rx_page_info->last_frag = false;
2001         } else {
2002                 dma_sync_single_for_cpu(&adapter->pdev->dev,
2003                                         dma_unmap_addr(rx_page_info, bus),
2004                                         rx_frag_size, DMA_FROM_DEVICE);
2005         }
2006
2007         queue_tail_inc(rxq);
2008         atomic_dec(&rxq->used);
2009         return rx_page_info;
2010 }
2011
2012 /* Throwaway the data in the Rx completion */
2013 static void be_rx_compl_discard(struct be_rx_obj *rxo,
2014                                 struct be_rx_compl_info *rxcp)
2015 {
2016         struct be_rx_page_info *page_info;
2017         u16 i, num_rcvd = rxcp->num_rcvd;
2018
2019         for (i = 0; i < num_rcvd; i++) {
2020                 page_info = get_rx_page_info(rxo);
2021                 put_page(page_info->page);
2022                 memset(page_info, 0, sizeof(*page_info));
2023         }
2024 }
2025
2026 /*
2027  * skb_fill_rx_data forms a complete skb for an ether frame
2028  * indicated by rxcp.
2029  */
2030 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
2031                              struct be_rx_compl_info *rxcp)
2032 {
2033         struct be_rx_page_info *page_info;
2034         u16 i, j;
2035         u16 hdr_len, curr_frag_len, remaining;
2036         u8 *start;
2037
2038         page_info = get_rx_page_info(rxo);
2039         start = page_address(page_info->page) + page_info->page_offset;
2040         prefetch(start);
2041
2042         /* Copy data in the first descriptor of this completion */
2043         curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
2044
2045         skb->len = curr_frag_len;
2046         if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
2047                 memcpy(skb->data, start, curr_frag_len);
2048                 /* Complete packet has now been moved to data */
2049                 put_page(page_info->page);
2050                 skb->data_len = 0;
2051                 skb->tail += curr_frag_len;
2052         } else {
2053                 hdr_len = ETH_HLEN;
2054                 memcpy(skb->data, start, hdr_len);
2055                 skb_shinfo(skb)->nr_frags = 1;
2056                 skb_frag_set_page(skb, 0, page_info->page);
2057                 skb_shinfo(skb)->frags[0].page_offset =
2058                                         page_info->page_offset + hdr_len;
2059                 skb_frag_size_set(&skb_shinfo(skb)->frags[0],
2060                                   curr_frag_len - hdr_len);
2061                 skb->data_len = curr_frag_len - hdr_len;
2062                 skb->truesize += rx_frag_size;
2063                 skb->tail += hdr_len;
2064         }
2065         page_info->page = NULL;
2066
2067         if (rxcp->pkt_size <= rx_frag_size) {
2068                 BUG_ON(rxcp->num_rcvd != 1);
2069                 return;
2070         }
2071
2072         /* More frags present for this completion */
2073         remaining = rxcp->pkt_size - curr_frag_len;
2074         for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
2075                 page_info = get_rx_page_info(rxo);
2076                 curr_frag_len = min(remaining, rx_frag_size);
2077
2078                 /* Coalesce all frags from the same physical page in one slot */
2079                 if (page_info->page_offset == 0) {
2080                         /* Fresh page */
2081                         j++;
2082                         skb_frag_set_page(skb, j, page_info->page);
2083                         skb_shinfo(skb)->frags[j].page_offset =
2084                                                         page_info->page_offset;
2085                         skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2086                         skb_shinfo(skb)->nr_frags++;
2087                 } else {
2088                         put_page(page_info->page);
2089                 }
2090
2091                 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
2092                 skb->len += curr_frag_len;
2093                 skb->data_len += curr_frag_len;
2094                 skb->truesize += rx_frag_size;
2095                 remaining -= curr_frag_len;
2096                 page_info->page = NULL;
2097         }
2098         BUG_ON(j > MAX_SKB_FRAGS);
2099 }
2100
2101 /* Process the RX completion indicated by rxcp when GRO is disabled */
2102 static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi,
2103                                 struct be_rx_compl_info *rxcp)
2104 {
2105         struct be_adapter *adapter = rxo->adapter;
2106         struct net_device *netdev = adapter->netdev;
2107         struct sk_buff *skb;
2108
2109         skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
2110         if (unlikely(!skb)) {
2111                 rx_stats(rxo)->rx_drops_no_skbs++;
2112                 be_rx_compl_discard(rxo, rxcp);
2113                 return;
2114         }
2115
2116         skb_fill_rx_data(rxo, skb, rxcp);
2117
2118         if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
2119                 skb->ip_summed = CHECKSUM_UNNECESSARY;
2120         else
2121                 skb_checksum_none_assert(skb);
2122
2123         skb->protocol = eth_type_trans(skb, netdev);
2124         skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
2125         if (netdev->features & NETIF_F_RXHASH)
2126                 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2127
2128         skb->csum_level = rxcp->tunneled;
2129         skb_mark_napi_id(skb, napi);
2130
2131         if (rxcp->vlanf)
2132                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
2133
2134         netif_receive_skb(skb);
2135 }
2136
2137 /* Process the RX completion indicated by rxcp when GRO is enabled */
2138 static void be_rx_compl_process_gro(struct be_rx_obj *rxo,
2139                                     struct napi_struct *napi,
2140                                     struct be_rx_compl_info *rxcp)
2141 {
2142         struct be_adapter *adapter = rxo->adapter;
2143         struct be_rx_page_info *page_info;
2144         struct sk_buff *skb = NULL;
2145         u16 remaining, curr_frag_len;
2146         u16 i, j;
2147
2148         skb = napi_get_frags(napi);
2149         if (!skb) {
2150                 be_rx_compl_discard(rxo, rxcp);
2151                 return;
2152         }
2153
2154         remaining = rxcp->pkt_size;
2155         for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
2156                 page_info = get_rx_page_info(rxo);
2157
2158                 curr_frag_len = min(remaining, rx_frag_size);
2159
2160                 /* Coalesce all frags from the same physical page in one slot */
2161                 if (i == 0 || page_info->page_offset == 0) {
2162                         /* First frag or Fresh page */
2163                         j++;
2164                         skb_frag_set_page(skb, j, page_info->page);
2165                         skb_shinfo(skb)->frags[j].page_offset =
2166                                                         page_info->page_offset;
2167                         skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2168                 } else {
2169                         put_page(page_info->page);
2170                 }
2171                 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
2172                 skb->truesize += rx_frag_size;
2173                 remaining -= curr_frag_len;
2174                 memset(page_info, 0, sizeof(*page_info));
2175         }
2176         BUG_ON(j > MAX_SKB_FRAGS);
2177
2178         skb_shinfo(skb)->nr_frags = j + 1;
2179         skb->len = rxcp->pkt_size;
2180         skb->data_len = rxcp->pkt_size;
2181         skb->ip_summed = CHECKSUM_UNNECESSARY;
2182         skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
2183         if (adapter->netdev->features & NETIF_F_RXHASH)
2184                 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2185
2186         skb->csum_level = rxcp->tunneled;
2187
2188         if (rxcp->vlanf)
2189                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
2190
2191         napi_gro_frags(napi);
2192 }
2193
2194 static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
2195                                  struct be_rx_compl_info *rxcp)
2196 {
2197         rxcp->pkt_size = GET_RX_COMPL_V1_BITS(pktsize, compl);
2198         rxcp->vlanf = GET_RX_COMPL_V1_BITS(vtp, compl);
2199         rxcp->err = GET_RX_COMPL_V1_BITS(err, compl);
2200         rxcp->tcpf = GET_RX_COMPL_V1_BITS(tcpf, compl);
2201         rxcp->udpf = GET_RX_COMPL_V1_BITS(udpf, compl);
2202         rxcp->ip_csum = GET_RX_COMPL_V1_BITS(ipcksm, compl);
2203         rxcp->l4_csum = GET_RX_COMPL_V1_BITS(l4_cksm, compl);
2204         rxcp->ipv6 = GET_RX_COMPL_V1_BITS(ip_version, compl);
2205         rxcp->num_rcvd = GET_RX_COMPL_V1_BITS(numfrags, compl);
2206         rxcp->pkt_type = GET_RX_COMPL_V1_BITS(cast_enc, compl);
2207         rxcp->rss_hash = GET_RX_COMPL_V1_BITS(rsshash, compl);
2208         if (rxcp->vlanf) {
2209                 rxcp->qnq = GET_RX_COMPL_V1_BITS(qnq, compl);
2210                 rxcp->vlan_tag = GET_RX_COMPL_V1_BITS(vlan_tag, compl);
2211         }
2212         rxcp->port = GET_RX_COMPL_V1_BITS(port, compl);
2213         rxcp->tunneled =
2214                 GET_RX_COMPL_V1_BITS(tunneled, compl);
2215 }
2216
2217 static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
2218                                  struct be_rx_compl_info *rxcp)
2219 {
2220         rxcp->pkt_size = GET_RX_COMPL_V0_BITS(pktsize, compl);
2221         rxcp->vlanf = GET_RX_COMPL_V0_BITS(vtp, compl);
2222         rxcp->err = GET_RX_COMPL_V0_BITS(err, compl);
2223         rxcp->tcpf = GET_RX_COMPL_V0_BITS(tcpf, compl);
2224         rxcp->udpf = GET_RX_COMPL_V0_BITS(udpf, compl);
2225         rxcp->ip_csum = GET_RX_COMPL_V0_BITS(ipcksm, compl);
2226         rxcp->l4_csum = GET_RX_COMPL_V0_BITS(l4_cksm, compl);
2227         rxcp->ipv6 = GET_RX_COMPL_V0_BITS(ip_version, compl);
2228         rxcp->num_rcvd = GET_RX_COMPL_V0_BITS(numfrags, compl);
2229         rxcp->pkt_type = GET_RX_COMPL_V0_BITS(cast_enc, compl);
2230         rxcp->rss_hash = GET_RX_COMPL_V0_BITS(rsshash, compl);
2231         if (rxcp->vlanf) {
2232                 rxcp->qnq = GET_RX_COMPL_V0_BITS(qnq, compl);
2233                 rxcp->vlan_tag = GET_RX_COMPL_V0_BITS(vlan_tag, compl);
2234         }
2235         rxcp->port = GET_RX_COMPL_V0_BITS(port, compl);
2236         rxcp->ip_frag = GET_RX_COMPL_V0_BITS(ip_frag, compl);
2237 }
2238
2239 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
2240 {
2241         struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
2242         struct be_rx_compl_info *rxcp = &rxo->rxcp;
2243         struct be_adapter *adapter = rxo->adapter;
2244
2245         /* For checking the valid bit it is Ok to use either definition as the
2246          * valid bit is at the same position in both v0 and v1 Rx compl */
2247         if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
2248                 return NULL;
2249
2250         rmb();
2251         be_dws_le_to_cpu(compl, sizeof(*compl));
2252
2253         if (adapter->be3_native)
2254                 be_parse_rx_compl_v1(compl, rxcp);
2255         else
2256                 be_parse_rx_compl_v0(compl, rxcp);
2257
2258         if (rxcp->ip_frag)
2259                 rxcp->l4_csum = 0;
2260
2261         if (rxcp->vlanf) {
2262                 /* In QNQ modes, if qnq bit is not set, then the packet was
2263                  * tagged only with the transparent outer vlan-tag and must
2264                  * not be treated as a vlan packet by host
2265                  */
2266                 if (be_is_qnq_mode(adapter) && !rxcp->qnq)
2267                         rxcp->vlanf = 0;
2268
2269                 if (!lancer_chip(adapter))
2270                         rxcp->vlan_tag = swab16(rxcp->vlan_tag);
2271
2272                 if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
2273                     !test_bit(rxcp->vlan_tag, adapter->vids))
2274                         rxcp->vlanf = 0;
2275         }
2276
2277         /* As the compl has been parsed, reset it; we wont touch it again */
2278         compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
2279
2280         queue_tail_inc(&rxo->cq);
2281         return rxcp;
2282 }
2283
2284 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
2285 {
2286         u32 order = get_order(size);
2287
2288         if (order > 0)
2289                 gfp |= __GFP_COMP;
2290         return  alloc_pages(gfp, order);
2291 }
2292
2293 /*
2294  * Allocate a page, split it to fragments of size rx_frag_size and post as
2295  * receive buffers to BE
2296  */
2297 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp, u32 frags_needed)
2298 {
2299         struct be_adapter *adapter = rxo->adapter;
2300         struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
2301         struct be_queue_info *rxq = &rxo->q;
2302         struct page *pagep = NULL;
2303         struct device *dev = &adapter->pdev->dev;
2304         struct be_eth_rx_d *rxd;
2305         u64 page_dmaaddr = 0, frag_dmaaddr;
2306         u32 posted, page_offset = 0, notify = 0;
2307
2308         page_info = &rxo->page_info_tbl[rxq->head];
2309         for (posted = 0; posted < frags_needed && !page_info->page; posted++) {
2310                 if (!pagep) {
2311                         pagep = be_alloc_pages(adapter->big_page_size, gfp);
2312                         if (unlikely(!pagep)) {
2313                                 rx_stats(rxo)->rx_post_fail++;
2314                                 break;
2315                         }
2316                         page_dmaaddr = dma_map_page(dev, pagep, 0,
2317                                                     adapter->big_page_size,
2318                                                     DMA_FROM_DEVICE);
2319                         if (dma_mapping_error(dev, page_dmaaddr)) {
2320                                 put_page(pagep);
2321                                 pagep = NULL;
2322                                 adapter->drv_stats.dma_map_errors++;
2323                                 break;
2324                         }
2325                         page_offset = 0;
2326                 } else {
2327                         get_page(pagep);
2328                         page_offset += rx_frag_size;
2329                 }
2330                 page_info->page_offset = page_offset;
2331                 page_info->page = pagep;
2332
2333                 rxd = queue_head_node(rxq);
2334                 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
2335                 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
2336                 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
2337
2338                 /* Any space left in the current big page for another frag? */
2339                 if ((page_offset + rx_frag_size + rx_frag_size) >
2340                                         adapter->big_page_size) {
2341                         pagep = NULL;
2342                         page_info->last_frag = true;
2343                         dma_unmap_addr_set(page_info, bus, page_dmaaddr);
2344                 } else {
2345                         dma_unmap_addr_set(page_info, bus, frag_dmaaddr);
2346                 }
2347
2348                 prev_page_info = page_info;
2349                 queue_head_inc(rxq);
2350                 page_info = &rxo->page_info_tbl[rxq->head];
2351         }
2352
2353         /* Mark the last frag of a page when we break out of the above loop
2354          * with no more slots available in the RXQ
2355          */
2356         if (pagep) {
2357                 prev_page_info->last_frag = true;
2358                 dma_unmap_addr_set(prev_page_info, bus, page_dmaaddr);
2359         }
2360
2361         if (posted) {
2362                 atomic_add(posted, &rxq->used);
2363                 if (rxo->rx_post_starved)
2364                         rxo->rx_post_starved = false;
2365                 do {
2366                         notify = min(MAX_NUM_POST_ERX_DB, posted);
2367                         be_rxq_notify(adapter, rxq->id, notify);
2368                         posted -= notify;
2369                 } while (posted);
2370         } else if (atomic_read(&rxq->used) == 0) {
2371                 /* Let be_worker replenish when memory is available */
2372                 rxo->rx_post_starved = true;
2373         }
2374 }
2375
2376 static struct be_tx_compl_info *be_tx_compl_get(struct be_tx_obj *txo)
2377 {
2378         struct be_queue_info *tx_cq = &txo->cq;
2379         struct be_tx_compl_info *txcp = &txo->txcp;
2380         struct be_eth_tx_compl *compl = queue_tail_node(tx_cq);
2381
2382         if (compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
2383                 return NULL;
2384
2385         /* Ensure load ordering of valid bit dword and other dwords below */
2386         rmb();
2387         be_dws_le_to_cpu(compl, sizeof(*compl));
2388
2389         txcp->status = GET_TX_COMPL_BITS(status, compl);
2390         txcp->end_index = GET_TX_COMPL_BITS(wrb_index, compl);
2391
2392         compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
2393         queue_tail_inc(tx_cq);
2394         return txcp;
2395 }
2396
2397 static u16 be_tx_compl_process(struct be_adapter *adapter,
2398                                struct be_tx_obj *txo, u16 last_index)
2399 {
2400         struct sk_buff **sent_skbs = txo->sent_skb_list;
2401         struct be_queue_info *txq = &txo->q;
2402         u16 frag_index, num_wrbs = 0;
2403         struct sk_buff *skb = NULL;
2404         bool unmap_skb_hdr = false;
2405         struct be_eth_wrb *wrb;
2406
2407         do {
2408                 if (sent_skbs[txq->tail]) {
2409                         /* Free skb from prev req */
2410                         if (skb)
2411                                 dev_consume_skb_any(skb);
2412                         skb = sent_skbs[txq->tail];
2413                         sent_skbs[txq->tail] = NULL;
2414                         queue_tail_inc(txq);  /* skip hdr wrb */
2415                         num_wrbs++;
2416                         unmap_skb_hdr = true;
2417                 }
2418                 wrb = queue_tail_node(txq);
2419                 frag_index = txq->tail;
2420                 unmap_tx_frag(&adapter->pdev->dev, wrb,
2421                               (unmap_skb_hdr && skb_headlen(skb)));
2422                 unmap_skb_hdr = false;
2423                 queue_tail_inc(txq);
2424                 num_wrbs++;
2425         } while (frag_index != last_index);
2426         dev_consume_skb_any(skb);
2427
2428         return num_wrbs;
2429 }
2430
2431 /* Return the number of events in the event queue */
2432 static inline int events_get(struct be_eq_obj *eqo)
2433 {
2434         struct be_eq_entry *eqe;
2435         int num = 0;
2436
2437         do {
2438                 eqe = queue_tail_node(&eqo->q);
2439                 if (eqe->evt == 0)
2440                         break;
2441
2442                 rmb();
2443                 eqe->evt = 0;
2444                 num++;
2445                 queue_tail_inc(&eqo->q);
2446         } while (true);
2447
2448         return num;
2449 }
2450
2451 /* Leaves the EQ is disarmed state */
2452 static void be_eq_clean(struct be_eq_obj *eqo)
2453 {
2454         int num = events_get(eqo);
2455
2456         be_eq_notify(eqo->adapter, eqo->q.id, false, true, num, 0);
2457 }
2458
2459 /* Free posted rx buffers that were not used */
2460 static void be_rxq_clean(struct be_rx_obj *rxo)
2461 {
2462         struct be_queue_info *rxq = &rxo->q;
2463         struct be_rx_page_info *page_info;
2464
2465         while (atomic_read(&rxq->used) > 0) {
2466                 page_info = get_rx_page_info(rxo);
2467                 put_page(page_info->page);
2468                 memset(page_info, 0, sizeof(*page_info));
2469         }
2470         BUG_ON(atomic_read(&rxq->used));
2471         rxq->tail = 0;
2472         rxq->head = 0;
2473 }
2474
2475 static void be_rx_cq_clean(struct be_rx_obj *rxo)
2476 {
2477         struct be_queue_info *rx_cq = &rxo->cq;
2478         struct be_rx_compl_info *rxcp;
2479         struct be_adapter *adapter = rxo->adapter;
2480         int flush_wait = 0;
2481
2482         /* Consume pending rx completions.
2483          * Wait for the flush completion (identified by zero num_rcvd)
2484          * to arrive. Notify CQ even when there are no more CQ entries
2485          * for HW to flush partially coalesced CQ entries.
2486          * In Lancer, there is no need to wait for flush compl.
2487          */
2488         for (;;) {
2489                 rxcp = be_rx_compl_get(rxo);
2490                 if (!rxcp) {
2491                         if (lancer_chip(adapter))
2492                                 break;
2493
2494                         if (flush_wait++ > 50 ||
2495                             be_check_error(adapter,
2496                                            BE_ERROR_HW)) {
2497                                 dev_warn(&adapter->pdev->dev,
2498                                          "did not receive flush compl\n");
2499                                 break;
2500                         }
2501                         be_cq_notify(adapter, rx_cq->id, true, 0);
2502                         mdelay(1);
2503                 } else {
2504                         be_rx_compl_discard(rxo, rxcp);
2505                         be_cq_notify(adapter, rx_cq->id, false, 1);
2506                         if (rxcp->num_rcvd == 0)
2507                                 break;
2508                 }
2509         }
2510
2511         /* After cleanup, leave the CQ in unarmed state */
2512         be_cq_notify(adapter, rx_cq->id, false, 0);
2513 }
2514
2515 static void be_tx_compl_clean(struct be_adapter *adapter)
2516 {
2517         u16 end_idx, notified_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
2518         struct device *dev = &adapter->pdev->dev;
2519         struct be_tx_compl_info *txcp;
2520         struct be_queue_info *txq;
2521         struct be_tx_obj *txo;
2522         int i, pending_txqs;
2523
2524         /* Stop polling for compls when HW has been silent for 10ms */
2525         do {
2526                 pending_txqs = adapter->num_tx_qs;
2527
2528                 for_all_tx_queues(adapter, txo, i) {
2529                         cmpl = 0;
2530                         num_wrbs = 0;
2531                         txq = &txo->q;
2532                         while ((txcp = be_tx_compl_get(txo))) {
2533                                 num_wrbs +=
2534                                         be_tx_compl_process(adapter, txo,
2535                                                             txcp->end_index);
2536                                 cmpl++;
2537                         }
2538                         if (cmpl) {
2539                                 be_cq_notify(adapter, txo->cq.id, false, cmpl);
2540                                 atomic_sub(num_wrbs, &txq->used);
2541                                 timeo = 0;
2542                         }
2543                         if (!be_is_tx_compl_pending(txo))
2544                                 pending_txqs--;
2545                 }
2546
2547                 if (pending_txqs == 0 || ++timeo > 10 ||
2548                     be_check_error(adapter, BE_ERROR_HW))
2549                         break;
2550
2551                 mdelay(1);
2552         } while (true);
2553
2554         /* Free enqueued TX that was never notified to HW */
2555         for_all_tx_queues(adapter, txo, i) {
2556                 txq = &txo->q;
2557
2558                 if (atomic_read(&txq->used)) {
2559                         dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n",
2560                                  i, atomic_read(&txq->used));
2561                         notified_idx = txq->tail;
2562                         end_idx = txq->tail;
2563                         index_adv(&end_idx, atomic_read(&txq->used) - 1,
2564                                   txq->len);
2565                         /* Use the tx-compl process logic to handle requests
2566                          * that were not sent to the HW.
2567                          */
2568                         num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
2569                         atomic_sub(num_wrbs, &txq->used);
2570                         BUG_ON(atomic_read(&txq->used));
2571                         txo->pend_wrb_cnt = 0;
2572                         /* Since hw was never notified of these requests,
2573                          * reset TXQ indices
2574                          */
2575                         txq->head = notified_idx;
2576                         txq->tail = notified_idx;
2577                 }
2578         }
2579 }
2580
2581 static void be_evt_queues_destroy(struct be_adapter *adapter)
2582 {
2583         struct be_eq_obj *eqo;
2584         int i;
2585
2586         for_all_evt_queues(adapter, eqo, i) {
2587                 if (eqo->q.created) {
2588                         be_eq_clean(eqo);
2589                         be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
2590                         napi_hash_del(&eqo->napi);
2591                         netif_napi_del(&eqo->napi);
2592                         free_cpumask_var(eqo->affinity_mask);
2593                 }
2594                 be_queue_free(adapter, &eqo->q);
2595         }
2596 }
2597
2598 static int be_evt_queues_create(struct be_adapter *adapter)
2599 {
2600         struct be_queue_info *eq;
2601         struct be_eq_obj *eqo;
2602         struct be_aic_obj *aic;
2603         int i, rc;
2604
2605         adapter->num_evt_qs = min_t(u16, num_irqs(adapter),
2606                                     adapter->cfg_num_qs);
2607
2608         for_all_evt_queues(adapter, eqo, i) {
2609                 int numa_node = dev_to_node(&adapter->pdev->dev);
2610
2611                 aic = &adapter->aic_obj[i];
2612                 eqo->adapter = adapter;
2613                 eqo->idx = i;
2614                 aic->max_eqd = BE_MAX_EQD;
2615                 aic->enable = true;
2616
2617                 eq = &eqo->q;
2618                 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
2619                                     sizeof(struct be_eq_entry));
2620                 if (rc)
2621                         return rc;
2622
2623                 rc = be_cmd_eq_create(adapter, eqo);
2624                 if (rc)
2625                         return rc;
2626
2627                 if (!zalloc_cpumask_var(&eqo->affinity_mask, GFP_KERNEL))
2628                         return -ENOMEM;
2629                 cpumask_set_cpu(cpumask_local_spread(i, numa_node),
2630                                 eqo->affinity_mask);
2631                 netif_napi_add(adapter->netdev, &eqo->napi, be_poll,
2632                                BE_NAPI_WEIGHT);
2633         }
2634         return 0;
2635 }
2636
2637 static void be_mcc_queues_destroy(struct be_adapter *adapter)
2638 {
2639         struct be_queue_info *q;
2640
2641         q = &adapter->mcc_obj.q;
2642         if (q->created)
2643                 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
2644         be_queue_free(adapter, q);
2645
2646         q = &adapter->mcc_obj.cq;
2647         if (q->created)
2648                 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2649         be_queue_free(adapter, q);
2650 }
2651
2652 /* Must be called only after TX qs are created as MCC shares TX EQ */
2653 static int be_mcc_queues_create(struct be_adapter *adapter)
2654 {
2655         struct be_queue_info *q, *cq;
2656
2657         cq = &adapter->mcc_obj.cq;
2658         if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
2659                            sizeof(struct be_mcc_compl)))
2660                 goto err;
2661
2662         /* Use the default EQ for MCC completions */
2663         if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
2664                 goto mcc_cq_free;
2665
2666         q = &adapter->mcc_obj.q;
2667         if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
2668                 goto mcc_cq_destroy;
2669
2670         if (be_cmd_mccq_create(adapter, q, cq))
2671                 goto mcc_q_free;
2672
2673         return 0;
2674
2675 mcc_q_free:
2676         be_queue_free(adapter, q);
2677 mcc_cq_destroy:
2678         be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
2679 mcc_cq_free:
2680         be_queue_free(adapter, cq);
2681 err:
2682         return -1;
2683 }
2684
2685 static void be_tx_queues_destroy(struct be_adapter *adapter)
2686 {
2687         struct be_queue_info *q;
2688         struct be_tx_obj *txo;
2689         u8 i;
2690
2691         for_all_tx_queues(adapter, txo, i) {
2692                 q = &txo->q;
2693                 if (q->created)
2694                         be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
2695                 be_queue_free(adapter, q);
2696
2697                 q = &txo->cq;
2698                 if (q->created)
2699                         be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2700                 be_queue_free(adapter, q);
2701         }
2702 }
2703
2704 static int be_tx_qs_create(struct be_adapter *adapter)
2705 {
2706         struct be_queue_info *cq;
2707         struct be_tx_obj *txo;
2708         struct be_eq_obj *eqo;
2709         int status, i;
2710
2711         adapter->num_tx_qs = min(adapter->num_evt_qs, be_max_txqs(adapter));
2712
2713         for_all_tx_queues(adapter, txo, i) {
2714                 cq = &txo->cq;
2715                 status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
2716                                         sizeof(struct be_eth_tx_compl));
2717                 if (status)
2718                         return status;
2719
2720                 u64_stats_init(&txo->stats.sync);
2721                 u64_stats_init(&txo->stats.sync_compl);
2722
2723                 /* If num_evt_qs is less than num_tx_qs, then more than
2724                  * one txq share an eq
2725                  */
2726                 eqo = &adapter->eq_obj[i % adapter->num_evt_qs];
2727                 status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3);
2728                 if (status)
2729                         return status;
2730
2731                 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
2732                                         sizeof(struct be_eth_wrb));
2733                 if (status)
2734                         return status;
2735
2736                 status = be_cmd_txq_create(adapter, txo);
2737                 if (status)
2738                         return status;
2739
2740                 netif_set_xps_queue(adapter->netdev, eqo->affinity_mask,
2741                                     eqo->idx);
2742         }
2743
2744         dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
2745                  adapter->num_tx_qs);
2746         return 0;
2747 }
2748
2749 static void be_rx_cqs_destroy(struct be_adapter *adapter)
2750 {
2751         struct be_queue_info *q;
2752         struct be_rx_obj *rxo;
2753         int i;
2754
2755         for_all_rx_queues(adapter, rxo, i) {
2756                 q = &rxo->cq;
2757                 if (q->created)
2758                         be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2759                 be_queue_free(adapter, q);
2760         }
2761 }
2762
2763 static int be_rx_cqs_create(struct be_adapter *adapter)
2764 {
2765         struct be_queue_info *eq, *cq;
2766         struct be_rx_obj *rxo;
2767         int rc, i;
2768
2769         /* We can create as many RSS rings as there are EQs. */
2770         adapter->num_rss_qs = adapter->num_evt_qs;
2771
2772         /* We'll use RSS only if atleast 2 RSS rings are supported. */
2773         if (adapter->num_rss_qs <= 1)
2774                 adapter->num_rss_qs = 0;
2775
2776         adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq;
2777
2778         /* When the interface is not capable of RSS rings (and there is no
2779          * need to create a default RXQ) we'll still need one RXQ
2780          */
2781         if (adapter->num_rx_qs == 0)
2782                 adapter->num_rx_qs = 1;
2783
2784         adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
2785         for_all_rx_queues(adapter, rxo, i) {
2786                 rxo->adapter = adapter;
2787                 cq = &rxo->cq;
2788                 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
2789                                     sizeof(struct be_eth_rx_compl));
2790                 if (rc)
2791                         return rc;
2792
2793                 u64_stats_init(&rxo->stats.sync);
2794                 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2795                 rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
2796                 if (rc)
2797                         return rc;
2798         }
2799
2800         dev_info(&adapter->pdev->dev,
2801                  "created %d RX queue(s)\n", adapter->num_rx_qs);
2802         return 0;
2803 }
2804
2805 static irqreturn_t be_intx(int irq, void *dev)
2806 {
2807         struct be_eq_obj *eqo = dev;
2808         struct be_adapter *adapter = eqo->adapter;
2809         int num_evts = 0;
2810
2811         /* IRQ is not expected when NAPI is scheduled as the EQ
2812          * will not be armed.
2813          * But, this can happen on Lancer INTx where it takes
2814          * a while to de-assert INTx or in BE2 where occasionaly
2815          * an interrupt may be raised even when EQ is unarmed.
2816          * If NAPI is already scheduled, then counting & notifying
2817          * events will orphan them.
2818          */
2819         if (napi_schedule_prep(&eqo->napi)) {
2820                 num_evts = events_get(eqo);
2821                 __napi_schedule(&eqo->napi);
2822                 if (num_evts)
2823                         eqo->spurious_intr = 0;
2824         }
2825         be_eq_notify(adapter, eqo->q.id, false, true, num_evts, 0);
2826
2827         /* Return IRQ_HANDLED only for the the first spurious intr
2828          * after a valid intr to stop the kernel from branding
2829          * this irq as a bad one!
2830          */
2831         if (num_evts || eqo->spurious_intr++ == 0)
2832                 return IRQ_HANDLED;
2833         else
2834                 return IRQ_NONE;
2835 }
2836
2837 static irqreturn_t be_msix(int irq, void *dev)
2838 {
2839         struct be_eq_obj *eqo = dev;
2840
2841         be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
2842         napi_schedule(&eqo->napi);
2843         return IRQ_HANDLED;
2844 }
2845
2846 static inline bool do_gro(struct be_rx_compl_info *rxcp)
2847 {
2848         return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false;
2849 }
2850
2851 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
2852                          int budget, int polling)
2853 {
2854         struct be_adapter *adapter = rxo->adapter;
2855         struct be_queue_info *rx_cq = &rxo->cq;
2856         struct be_rx_compl_info *rxcp;
2857         u32 work_done;
2858         u32 frags_consumed = 0;
2859
2860         for (work_done = 0; work_done < budget; work_done++) {
2861                 rxcp = be_rx_compl_get(rxo);
2862                 if (!rxcp)
2863                         break;
2864
2865                 /* Is it a flush compl that has no data */
2866                 if (unlikely(rxcp->num_rcvd == 0))
2867                         goto loop_continue;
2868
2869                 /* Discard compl with partial DMA Lancer B0 */
2870                 if (unlikely(!rxcp->pkt_size)) {
2871                         be_rx_compl_discard(rxo, rxcp);
2872                         goto loop_continue;
2873                 }
2874
2875                 /* On BE drop pkts that arrive due to imperfect filtering in
2876                  * promiscuous mode on some skews
2877                  */
2878                 if (unlikely(rxcp->port != adapter->port_num &&
2879                              !lancer_chip(adapter))) {
2880                         be_rx_compl_discard(rxo, rxcp);
2881                         goto loop_continue;
2882                 }
2883
2884                 /* Don't do gro when we're busy_polling */
2885                 if (do_gro(rxcp) && polling != BUSY_POLLING)
2886                         be_rx_compl_process_gro(rxo, napi, rxcp);
2887                 else
2888                         be_rx_compl_process(rxo, napi, rxcp);
2889
2890 loop_continue:
2891                 frags_consumed += rxcp->num_rcvd;
2892                 be_rx_stats_update(rxo, rxcp);
2893         }
2894
2895         if (work_done) {
2896                 be_cq_notify(adapter, rx_cq->id, true, work_done);
2897
2898                 /* When an rx-obj gets into post_starved state, just
2899                  * let be_worker do the posting.
2900                  */
2901                 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM &&
2902                     !rxo->rx_post_starved)
2903                         be_post_rx_frags(rxo, GFP_ATOMIC,
2904                                          max_t(u32, MAX_RX_POST,
2905                                                frags_consumed));
2906         }
2907
2908         return work_done;
2909 }
2910
2911 static inline void be_update_tx_err(struct be_tx_obj *txo, u8 status)
2912 {
2913         switch (status) {
2914         case BE_TX_COMP_HDR_PARSE_ERR:
2915                 tx_stats(txo)->tx_hdr_parse_err++;
2916                 break;
2917         case BE_TX_COMP_NDMA_ERR:
2918                 tx_stats(txo)->tx_dma_err++;
2919                 break;
2920         case BE_TX_COMP_ACL_ERR:
2921                 tx_stats(txo)->tx_spoof_check_err++;
2922                 break;
2923         }
2924 }
2925
2926 static inline void lancer_update_tx_err(struct be_tx_obj *txo, u8 status)
2927 {
2928         switch (status) {
2929         case LANCER_TX_COMP_LSO_ERR:
2930                 tx_stats(txo)->tx_tso_err++;
2931                 break;
2932         case LANCER_TX_COMP_HSW_DROP_MAC_ERR:
2933         case LANCER_TX_COMP_HSW_DROP_VLAN_ERR:
2934                 tx_stats(txo)->tx_spoof_check_err++;
2935                 break;
2936         case LANCER_TX_COMP_QINQ_ERR:
2937                 tx_stats(txo)->tx_qinq_err++;
2938                 break;
2939         case LANCER_TX_COMP_PARITY_ERR:
2940                 tx_stats(txo)->tx_internal_parity_err++;
2941                 break;
2942         case LANCER_TX_COMP_DMA_ERR:
2943                 tx_stats(txo)->tx_dma_err++;
2944                 break;
2945         }
2946 }
2947
2948 static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
2949                           int idx)
2950 {
2951         int num_wrbs = 0, work_done = 0;
2952         struct be_tx_compl_info *txcp;
2953
2954         while ((txcp = be_tx_compl_get(txo))) {
2955                 num_wrbs += be_tx_compl_process(adapter, txo, txcp->end_index);
2956                 work_done++;
2957
2958                 if (txcp->status) {
2959                         if (lancer_chip(adapter))
2960                                 lancer_update_tx_err(txo, txcp->status);
2961                         else
2962                                 be_update_tx_err(txo, txcp->status);
2963                 }
2964         }
2965
2966         if (work_done) {
2967                 be_cq_notify(adapter, txo->cq.id, true, work_done);
2968                 atomic_sub(num_wrbs, &txo->q.used);
2969
2970                 /* As Tx wrbs have been freed up, wake up netdev queue
2971                  * if it was stopped due to lack of tx wrbs.  */
2972                 if (__netif_subqueue_stopped(adapter->netdev, idx) &&
2973                     be_can_txq_wake(txo)) {
2974                         netif_wake_subqueue(adapter->netdev, idx);
2975                 }
2976
2977                 u64_stats_update_begin(&tx_stats(txo)->sync_compl);
2978                 tx_stats(txo)->tx_compl += work_done;
2979                 u64_stats_update_end(&tx_stats(txo)->sync_compl);
2980         }
2981 }
2982
2983 #ifdef CONFIG_NET_RX_BUSY_POLL
2984 static inline bool be_lock_napi(struct be_eq_obj *eqo)
2985 {
2986         bool status = true;
2987
2988         spin_lock(&eqo->lock); /* BH is already disabled */
2989         if (eqo->state & BE_EQ_LOCKED) {
2990                 WARN_ON(eqo->state & BE_EQ_NAPI);
2991                 eqo->state |= BE_EQ_NAPI_YIELD;
2992                 status = false;
2993         } else {
2994                 eqo->state = BE_EQ_NAPI;
2995         }
2996         spin_unlock(&eqo->lock);
2997         return status;
2998 }
2999
3000 static inline void be_unlock_napi(struct be_eq_obj *eqo)
3001 {
3002         spin_lock(&eqo->lock); /* BH is already disabled */
3003
3004         WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));
3005         eqo->state = BE_EQ_IDLE;
3006
3007         spin_unlock(&eqo->lock);
3008 }
3009
3010 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
3011 {
3012         bool status = true;
3013
3014         spin_lock_bh(&eqo->lock);
3015         if (eqo->state & BE_EQ_LOCKED) {
3016                 eqo->state |= BE_EQ_POLL_YIELD;
3017                 status = false;
3018         } else {
3019                 eqo->state |= BE_EQ_POLL;
3020         }
3021         spin_unlock_bh(&eqo->lock);
3022         return status;
3023 }
3024
3025 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
3026 {
3027         spin_lock_bh(&eqo->lock);
3028
3029         WARN_ON(eqo->state & (BE_EQ_NAPI));
3030         eqo->state = BE_EQ_IDLE;
3031
3032         spin_unlock_bh(&eqo->lock);
3033 }
3034
3035 static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
3036 {
3037         spin_lock_init(&eqo->lock);
3038         eqo->state = BE_EQ_IDLE;
3039 }
3040
3041 static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
3042 {
3043         local_bh_disable();
3044
3045         /* It's enough to just acquire napi lock on the eqo to stop
3046          * be_busy_poll() from processing any queueus.
3047          */
3048         while (!be_lock_napi(eqo))
3049                 mdelay(1);
3050
3051         local_bh_enable();
3052 }
3053
3054 #else /* CONFIG_NET_RX_BUSY_POLL */
3055
3056 static inline bool be_lock_napi(struct be_eq_obj *eqo)
3057 {
3058         return true;
3059 }
3060
3061 static inline void be_unlock_napi(struct be_eq_obj *eqo)
3062 {
3063 }
3064
3065 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
3066 {
3067         return false;
3068 }
3069
3070 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
3071 {
3072 }
3073
3074 static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
3075 {
3076 }
3077
3078 static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
3079 {
3080 }
3081 #endif /* CONFIG_NET_RX_BUSY_POLL */
3082
3083 int be_poll(struct napi_struct *napi, int budget)
3084 {
3085         struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
3086         struct be_adapter *adapter = eqo->adapter;
3087         int max_work = 0, work, i, num_evts;
3088         struct be_rx_obj *rxo;
3089         struct be_tx_obj *txo;
3090         u32 mult_enc = 0;
3091
3092         num_evts = events_get(eqo);
3093
3094         for_all_tx_queues_on_eq(adapter, eqo, txo, i)
3095                 be_process_tx(adapter, txo, i);
3096
3097         if (be_lock_napi(eqo)) {
3098                 /* This loop will iterate twice for EQ0 in which
3099                  * completions of the last RXQ (default one) are also processed
3100                  * For other EQs the loop iterates only once
3101                  */
3102                 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
3103                         work = be_process_rx(rxo, napi, budget, NAPI_POLLING);
3104                         max_work = max(work, max_work);
3105                 }
3106                 be_unlock_napi(eqo);
3107         } else {
3108                 max_work = budget;
3109         }
3110
3111         if (is_mcc_eqo(eqo))
3112                 be_process_mcc(adapter);
3113
3114         if (max_work < budget) {
3115                 napi_complete(napi);
3116
3117                 /* Skyhawk EQ_DB has a provision to set the rearm to interrupt
3118                  * delay via a delay multiplier encoding value
3119                  */
3120                 if (skyhawk_chip(adapter))
3121                         mult_enc = be_get_eq_delay_mult_enc(eqo);
3122
3123                 be_eq_notify(adapter, eqo->q.id, true, false, num_evts,
3124                              mult_enc);
3125         } else {
3126                 /* As we'll continue in polling mode, count and clear events */
3127                 be_eq_notify(adapter, eqo->q.id, false, false, num_evts, 0);
3128         }
3129         return max_work;
3130 }
3131
3132 #ifdef CONFIG_NET_RX_BUSY_POLL
3133 static int be_busy_poll(struct napi_struct *napi)
3134 {
3135         struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
3136         struct be_adapter *adapter = eqo->adapter;
3137         struct be_rx_obj *rxo;
3138         int i, work = 0;
3139
3140         if (!be_lock_busy_poll(eqo))
3141                 return LL_FLUSH_BUSY;
3142
3143         for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
3144                 work = be_process_rx(rxo, napi, 4, BUSY_POLLING);
3145                 if (work)
3146                         break;
3147         }
3148
3149         be_unlock_busy_poll(eqo);
3150         return work;
3151 }
3152 #endif
3153
3154 void be_detect_error(struct be_adapter *adapter)
3155 {
3156         u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
3157         u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
3158         u32 i;
3159         struct device *dev = &adapter->pdev->dev;
3160
3161         if (be_check_error(adapter, BE_ERROR_HW))
3162                 return;
3163
3164         if (lancer_chip(adapter)) {
3165                 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
3166                 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
3167                         be_set_error(adapter, BE_ERROR_UE);
3168                         sliport_err1 = ioread32(adapter->db +
3169                                                 SLIPORT_ERROR1_OFFSET);
3170                         sliport_err2 = ioread32(adapter->db +
3171                                                 SLIPORT_ERROR2_OFFSET);
3172                         /* Do not log error messages if its a FW reset */
3173                         if (sliport_err1 == SLIPORT_ERROR_FW_RESET1 &&
3174                             sliport_err2 == SLIPORT_ERROR_FW_RESET2) {
3175                                 dev_info(dev, "Firmware update in progress\n");
3176                         } else {
3177                                 dev_err(dev, "Error detected in the card\n");
3178                                 dev_err(dev, "ERR: sliport status 0x%x\n",
3179                                         sliport_status);
3180                                 dev_err(dev, "ERR: sliport error1 0x%x\n",
3181                                         sliport_err1);
3182                                 dev_err(dev, "ERR: sliport error2 0x%x\n",
3183                                         sliport_err2);
3184                         }
3185                 }
3186         } else {
3187                 ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW);
3188                 ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH);
3189                 ue_lo_mask = ioread32(adapter->pcicfg +
3190                                       PCICFG_UE_STATUS_LOW_MASK);
3191                 ue_hi_mask = ioread32(adapter->pcicfg +
3192                                       PCICFG_UE_STATUS_HI_MASK);
3193
3194                 ue_lo = (ue_lo & ~ue_lo_mask);
3195                 ue_hi = (ue_hi & ~ue_hi_mask);
3196
3197                 /* On certain platforms BE hardware can indicate spurious UEs.
3198                  * Allow HW to stop working completely in case of a real UE.
3199                  * Hence not setting the hw_error for UE detection.
3200                  */
3201
3202                 if (ue_lo || ue_hi) {
3203                         dev_err(dev,
3204                                 "Unrecoverable Error detected in the adapter");
3205                         dev_err(dev, "Please reboot server to recover");
3206                         if (skyhawk_chip(adapter))
3207                                 be_set_error(adapter, BE_ERROR_UE);
3208
3209                         for (i = 0; ue_lo; ue_lo >>= 1, i++) {
3210                                 if (ue_lo & 1)
3211                                         dev_err(dev, "UE: %s bit set\n",
3212                                                 ue_status_low_desc[i]);
3213                         }
3214                         for (i = 0; ue_hi; ue_hi >>= 1, i++) {
3215                                 if (ue_hi & 1)
3216                                         dev_err(dev, "UE: %s bit set\n",
3217                                                 ue_status_hi_desc[i]);
3218                         }
3219                 }
3220         }
3221 }
3222
3223 static void be_msix_disable(struct be_adapter *adapter)
3224 {
3225         if (msix_enabled(adapter)) {
3226                 pci_disable_msix(adapter->pdev);
3227                 adapter->num_msix_vec = 0;
3228                 adapter->num_msix_roce_vec = 0;
3229         }
3230 }
3231
3232 static int be_msix_enable(struct be_adapter *adapter)
3233 {
3234         int i, num_vec;
3235         struct device *dev = &adapter->pdev->dev;
3236
3237         /* If RoCE is supported, program the max number of NIC vectors that
3238          * may be configured via set-channels, along with vectors needed for
3239          * RoCe. Else, just program the number we'll use initially.
3240          */
3241         if (be_roce_supported(adapter))
3242                 num_vec = min_t(int, 2 * be_max_eqs(adapter),
3243                                 2 * num_online_cpus());
3244         else
3245                 num_vec = adapter->cfg_num_qs;
3246
3247         for (i = 0; i < num_vec; i++)
3248                 adapter->msix_entries[i].entry = i;
3249
3250         num_vec = pci_enable_msix_range(adapter->pdev, adapter->msix_entries,
3251                                         MIN_MSIX_VECTORS, num_vec);
3252         if (num_vec < 0)
3253                 goto fail;
3254
3255         if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) {
3256                 adapter->num_msix_roce_vec = num_vec / 2;
3257                 dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n",
3258                          adapter->num_msix_roce_vec);
3259         }
3260
3261         adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec;
3262
3263         dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n",
3264                  adapter->num_msix_vec);
3265         return 0;
3266
3267 fail:
3268         dev_warn(dev, "MSIx enable failed\n");
3269
3270         /* INTx is not supported in VFs, so fail probe if enable_msix fails */
3271         if (be_virtfn(adapter))
3272                 return num_vec;
3273         return 0;
3274 }
3275
3276 static inline int be_msix_vec_get(struct be_adapter *adapter,
3277                                   struct be_eq_obj *eqo)
3278 {
3279         return adapter->msix_entries[eqo->msix_idx].vector;
3280 }
3281
3282 static int be_msix_register(struct be_adapter *adapter)
3283 {
3284         struct net_device *netdev = adapter->netdev;
3285         struct be_eq_obj *eqo;
3286         int status, i, vec;
3287
3288         for_all_evt_queues(adapter, eqo, i) {
3289                 sprintf(eqo->desc, "%s-q%d", netdev->name, i);
3290                 vec = be_msix_vec_get(adapter, eqo);
3291                 status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
3292                 if (status)
3293                         goto err_msix;
3294
3295                 irq_set_affinity_hint(vec, eqo->affinity_mask);
3296         }
3297
3298         return 0;
3299 err_msix:
3300         for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
3301                 free_irq(be_msix_vec_get(adapter, eqo), eqo);
3302         dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
3303                  status);
3304         be_msix_disable(adapter);
3305         return status;
3306 }
3307
3308 static int be_irq_register(struct be_adapter *adapter)
3309 {
3310         struct net_device *netdev = adapter->netdev;
3311         int status;
3312
3313         if (msix_enabled(adapter)) {
3314                 status = be_msix_register(adapter);
3315                 if (status == 0)
3316                         goto done;
3317                 /* INTx is not supported for VF */
3318                 if (be_virtfn(adapter))
3319                         return status;
3320         }
3321
3322         /* INTx: only the first EQ is used */
3323         netdev->irq = adapter->pdev->irq;
3324         status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
3325                              &adapter->eq_obj[0]);
3326         if (status) {
3327                 dev_err(&adapter->pdev->dev,
3328                         "INTx request IRQ failed - err %d\n", status);
3329                 return status;
3330         }
3331 done:
3332         adapter->isr_registered = true;
3333         return 0;
3334 }
3335
3336 static void be_irq_unregister(struct be_adapter *adapter)
3337 {
3338         struct net_device *netdev = adapter->netdev;
3339         struct be_eq_obj *eqo;
3340         int i, vec;
3341
3342         if (!adapter->isr_registered)
3343                 return;
3344
3345         /* INTx */
3346         if (!msix_enabled(adapter)) {
3347                 free_irq(netdev->irq, &adapter->eq_obj[0]);
3348                 goto done;
3349         }
3350
3351         /* MSIx */
3352         for_all_evt_queues(adapter, eqo, i) {
3353                 vec = be_msix_vec_get(adapter, eqo);
3354                 irq_set_affinity_hint(vec, NULL);
3355                 free_irq(vec, eqo);
3356         }
3357
3358 done:
3359         adapter->isr_registered = false;
3360 }
3361
3362 static void be_rx_qs_destroy(struct be_adapter *adapter)
3363 {
3364         struct be_queue_info *q;
3365         struct be_rx_obj *rxo;
3366         int i;
3367
3368         for_all_rx_queues(adapter, rxo, i) {
3369                 q = &rxo->q;
3370                 if (q->created) {
3371                         /* If RXQs are destroyed while in an "out of buffer"
3372                          * state, there is a possibility of an HW stall on
3373                          * Lancer. So, post 64 buffers to each queue to relieve
3374                          * the "out of buffer" condition.
3375                          * Make sure there's space in the RXQ before posting.
3376                          */
3377                         if (lancer_chip(adapter)) {
3378                                 be_rx_cq_clean(rxo);
3379                                 if (atomic_read(&q->used) == 0)
3380                                         be_post_rx_frags(rxo, GFP_KERNEL,
3381                                                          MAX_RX_POST);
3382                         }
3383
3384                         be_cmd_rxq_destroy(adapter, q);
3385                         be_rx_cq_clean(rxo);
3386                         be_rxq_clean(rxo);
3387                 }
3388                 be_queue_free(adapter, q);
3389         }
3390 }
3391
3392 static void be_disable_if_filters(struct be_adapter *adapter)
3393 {
3394         be_cmd_pmac_del(adapter, adapter->if_handle,
3395                         adapter->pmac_id[0], 0);
3396
3397         be_clear_uc_list(adapter);
3398
3399         /* The IFACE flags are enabled in the open path and cleared
3400          * in the close path. When a VF gets detached from the host and
3401          * assigned to a VM the following happens:
3402          *      - VF's IFACE flags get cleared in the detach path
3403          *      - IFACE create is issued by the VF in the attach path
3404          * Due to a bug in the BE3/Skyhawk-R FW
3405          * (Lancer FW doesn't have the bug), the IFACE capability flags
3406          * specified along with the IFACE create cmd issued by a VF are not
3407          * honoured by FW.  As a consequence, if a *new* driver
3408          * (that enables/disables IFACE flags in open/close)
3409          * is loaded in the host and an *old* driver is * used by a VM/VF,
3410          * the IFACE gets created *without* the needed flags.
3411          * To avoid this, disable RX-filter flags only for Lancer.
3412          */
3413         if (lancer_chip(adapter)) {
3414                 be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF);
3415                 adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS;
3416         }
3417 }
3418
3419 static int be_close(struct net_device *netdev)
3420 {
3421         struct be_adapter *adapter = netdev_priv(netdev);
3422         struct be_eq_obj *eqo;
3423         int i;
3424
3425         /* This protection is needed as be_close() may be called even when the
3426          * adapter is in cleared state (after eeh perm failure)
3427          */
3428         if (!(adapter->flags & BE_FLAGS_SETUP_DONE))
3429                 return 0;
3430
3431         be_disable_if_filters(adapter);
3432
3433         be_roce_dev_close(adapter);
3434
3435         if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
3436                 for_all_evt_queues(adapter, eqo, i) {
3437                         napi_disable(&eqo->napi);
3438                         be_disable_busy_poll(eqo);
3439                 }
3440                 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED;
3441         }
3442
3443         be_async_mcc_disable(adapter);
3444
3445         /* Wait for all pending tx completions to arrive so that
3446          * all tx skbs are freed.
3447          */
3448         netif_tx_disable(netdev);
3449         be_tx_compl_clean(adapter);
3450
3451         be_rx_qs_destroy(adapter);
3452
3453         for_all_evt_queues(adapter, eqo, i) {
3454                 if (msix_enabled(adapter))
3455                         synchronize_irq(be_msix_vec_get(adapter, eqo));
3456                 else
3457                         synchronize_irq(netdev->irq);
3458                 be_eq_clean(eqo);
3459         }
3460
3461         be_irq_unregister(adapter);
3462
3463         return 0;
3464 }
3465
3466 static int be_rx_qs_create(struct be_adapter *adapter)
3467 {
3468         struct rss_info *rss = &adapter->rss_info;
3469         u8 rss_key[RSS_HASH_KEY_LEN];
3470         struct be_rx_obj *rxo;
3471         int rc, i, j;
3472
3473         for_all_rx_queues(adapter, rxo, i) {
3474                 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
3475                                     sizeof(struct be_eth_rx_d));
3476                 if (rc)
3477                         return rc;
3478         }
3479
3480         if (adapter->need_def_rxq || !adapter->num_rss_qs) {
3481                 rxo = default_rxo(adapter);
3482                 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
3483                                        rx_frag_size, adapter->if_handle,
3484                                        false, &rxo->rss_id);
3485                 if (rc)
3486                         return rc;
3487         }
3488
3489         for_all_rss_queues(adapter, rxo, i) {
3490                 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
3491                                        rx_frag_size, adapter->if_handle,
3492                                        true, &rxo->rss_id);
3493                 if (rc)
3494                         return rc;
3495         }
3496
3497         if (be_multi_rxq(adapter)) {
3498                 for (j = 0; j < RSS_INDIR_TABLE_LEN; j += adapter->num_rss_qs) {
3499                         for_all_rss_queues(adapter, rxo, i) {
3500                                 if ((j + i) >= RSS_INDIR_TABLE_LEN)
3501                                         break;
3502                                 rss->rsstable[j + i] = rxo->rss_id;
3503                                 rss->rss_queue[j + i] = i;
3504                         }
3505                 }
3506                 rss->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 |
3507                         RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6;
3508
3509                 if (!BEx_chip(adapter))
3510                         rss->rss_flags |= RSS_ENABLE_UDP_IPV4 |
3511                                 RSS_ENABLE_UDP_IPV6;
3512         } else {
3513                 /* Disable RSS, if only default RX Q is created */
3514                 rss->rss_flags = RSS_ENABLE_NONE;
3515         }
3516
3517         netdev_rss_key_fill(rss_key, RSS_HASH_KEY_LEN);
3518         rc = be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags,
3519                                RSS_INDIR_TABLE_LEN, rss_key);
3520         if (rc) {
3521                 rss->rss_flags = RSS_ENABLE_NONE;
3522                 return rc;
3523         }
3524
3525         memcpy(rss->rss_hkey, rss_key, RSS_HASH_KEY_LEN);
3526
3527         /* Post 1 less than RXQ-len to avoid head being equal to tail,
3528          * which is a queue empty condition
3529          */
3530         for_all_rx_queues(adapter, rxo, i)
3531                 be_post_rx_frags(rxo, GFP_KERNEL, RX_Q_LEN - 1);
3532
3533         return 0;
3534 }
3535
3536 static int be_enable_if_filters(struct be_adapter *adapter)
3537 {
3538         int status;
3539
3540         status = be_cmd_rx_filter(adapter, BE_IF_EN_FLAGS, ON);
3541         if (status)
3542                 return status;
3543
3544         /* For BE3 VFs, the PF programs the initial MAC address */
3545         if (!(BEx_chip(adapter) && be_virtfn(adapter))) {
3546                 status = be_cmd_pmac_add(adapter, adapter->netdev->dev_addr,
3547                                          adapter->if_handle,
3548                                          &adapter->pmac_id[0], 0);
3549                 if (status)
3550                         return status;
3551         }
3552
3553         if (adapter->vlans_added)
3554                 be_vid_config(adapter);
3555
3556         be_set_rx_mode(adapter->netdev);
3557
3558         return 0;
3559 }
3560
3561 static int be_open(struct net_device *netdev)
3562 {
3563         struct be_adapter *adapter = netdev_priv(netdev);
3564         struct be_eq_obj *eqo;
3565         struct be_rx_obj *rxo;
3566         struct be_tx_obj *txo;
3567         u8 link_status;
3568         int status, i;
3569
3570         status = be_rx_qs_create(adapter);
3571         if (status)
3572                 goto err;
3573
3574         status = be_enable_if_filters(adapter);
3575         if (status)
3576                 goto err;
3577
3578         status = be_irq_register(adapter);
3579         if (status)
3580                 goto err;
3581
3582         for_all_rx_queues(adapter, rxo, i)
3583                 be_cq_notify(adapter, rxo->cq.id, true, 0);
3584
3585         for_all_tx_queues(adapter, txo, i)
3586                 be_cq_notify(adapter, txo->cq.id, true, 0);
3587
3588         be_async_mcc_enable(adapter);
3589
3590         for_all_evt_queues(adapter, eqo, i) {
3591                 napi_enable(&eqo->napi);
3592                 be_enable_busy_poll(eqo);
3593                 be_eq_notify(adapter, eqo->q.id, true, true, 0, 0);
3594         }
3595         adapter->flags |= BE_FLAGS_NAPI_ENABLED;
3596
3597         status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
3598         if (!status)
3599                 be_link_status_update(adapter, link_status);
3600
3601         netif_tx_start_all_queues(netdev);
3602         be_roce_dev_open(adapter);
3603
3604 #ifdef CONFIG_BE2NET_VXLAN
3605         if (skyhawk_chip(adapter))
3606                 vxlan_get_rx_port(netdev);
3607 #endif
3608
3609         return 0;
3610 err:
3611         be_close(adapter->netdev);
3612         return -EIO;
3613 }
3614
3615 static int be_setup_wol(struct be_adapter *adapter, bool enable)
3616 {
3617         struct device *dev = &adapter->pdev->dev;
3618         struct be_dma_mem cmd;
3619         u8 mac[ETH_ALEN];
3620         int status;
3621
3622         eth_zero_addr(mac);
3623
3624         cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
3625         cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
3626         if (!cmd.va)
3627                 return -ENOMEM;
3628
3629         if (enable) {
3630                 status = pci_write_config_dword(adapter->pdev,
3631                                                 PCICFG_PM_CONTROL_OFFSET,
3632                                                 PCICFG_PM_CONTROL_MASK);
3633                 if (status) {
3634                         dev_err(dev, "Could not enable Wake-on-lan\n");
3635                         goto err;
3636                 }
3637         } else {
3638                 ether_addr_copy(mac, adapter->netdev->dev_addr);
3639         }
3640
3641         status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
3642         pci_enable_wake(adapter->pdev, PCI_D3hot, enable);
3643         pci_enable_wake(adapter->pdev, PCI_D3cold, enable);
3644 err:
3645         dma_free_coherent(dev, cmd.size, cmd.va, cmd.dma);
3646         return status;
3647 }
3648
3649 static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
3650 {
3651         u32 addr;
3652
3653         addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);
3654
3655         mac[5] = (u8)(addr & 0xFF);
3656         mac[4] = (u8)((addr >> 8) & 0xFF);
3657         mac[3] = (u8)((addr >> 16) & 0xFF);
3658         /* Use the OUI from the current MAC address */
3659         memcpy(mac, adapter->netdev->dev_addr, 3);
3660 }
3661
3662 /*
3663  * Generate a seed MAC address from the PF MAC Address using jhash.
3664  * MAC Address for VFs are assigned incrementally starting from the seed.
3665  * These addresses are programmed in the ASIC by the PF and the VF driver
3666  * queries for the MAC address during its probe.
3667  */
3668 static int be_vf_eth_addr_config(struct be_adapter *adapter)
3669 {
3670         u32 vf;
3671         int status = 0;
3672         u8 mac[ETH_ALEN];
3673         struct be_vf_cfg *vf_cfg;
3674
3675         be_vf_eth_addr_generate(adapter, mac);
3676
3677         for_all_vfs(adapter, vf_cfg, vf) {
3678                 if (BEx_chip(adapter))
3679                         status = be_cmd_pmac_add(adapter, mac,
3680                                                  vf_cfg->if_handle,
3681                                                  &vf_cfg->pmac_id, vf + 1);
3682                 else
3683                         status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
3684                                                 vf + 1);
3685
3686                 if (status)
3687                         dev_err(&adapter->pdev->dev,
3688                                 "Mac address assignment failed for VF %d\n",
3689                                 vf);
3690                 else
3691                         memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3692
3693                 mac[5] += 1;
3694         }
3695         return status;
3696 }
3697
3698 static int be_vfs_mac_query(struct be_adapter *adapter)
3699 {
3700         int status, vf;
3701         u8 mac[ETH_ALEN];
3702         struct be_vf_cfg *vf_cfg;
3703
3704         for_all_vfs(adapter, vf_cfg, vf) {
3705                 status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id,
3706                                                mac, vf_cfg->if_handle,
3707                                                false, vf+1);
3708                 if (status)
3709                         return status;
3710                 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3711         }
3712         return 0;
3713 }
3714
3715 static void be_vf_clear(struct be_adapter *adapter)
3716 {
3717         struct be_vf_cfg *vf_cfg;
3718         u32 vf;
3719
3720         if (pci_vfs_assigned(adapter->pdev)) {
3721                 dev_warn(&adapter->pdev->dev,
3722                          "VFs are assigned to VMs: not disabling VFs\n");
3723                 goto done;
3724         }
3725
3726         pci_disable_sriov(adapter->pdev);
3727
3728         for_all_vfs(adapter, vf_cfg, vf) {
3729                 if (BEx_chip(adapter))
3730                         be_cmd_pmac_del(adapter, vf_cfg->if_handle,
3731                                         vf_cfg->pmac_id, vf + 1);
3732                 else
3733                         be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle,
3734                                        vf + 1);
3735
3736                 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
3737         }
3738 done:
3739         kfree(adapter->vf_cfg);
3740         adapter->num_vfs = 0;
3741         adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED;
3742 }
3743
3744 static void be_clear_queues(struct be_adapter *adapter)
3745 {
3746         be_mcc_queues_destroy(adapter);
3747         be_rx_cqs_destroy(adapter);
3748         be_tx_queues_destroy(adapter);
3749         be_evt_queues_destroy(adapter);
3750 }
3751
3752 static void be_cancel_worker(struct be_adapter *adapter)
3753 {
3754         if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
3755                 cancel_delayed_work_sync(&adapter->work);
3756                 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
3757         }
3758 }
3759
3760 static void be_cancel_err_detection(struct be_adapter *adapter)
3761 {
3762         if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) {
3763                 cancel_delayed_work_sync(&adapter->be_err_detection_work);
3764                 adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED;
3765         }
3766 }
3767
3768 #ifdef CONFIG_BE2NET_VXLAN
3769 static void be_disable_vxlan_offloads(struct be_adapter *adapter)
3770 {
3771         struct net_device *netdev = adapter->netdev;
3772
3773         if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)
3774                 be_cmd_manage_iface(adapter, adapter->if_handle,
3775                                     OP_CONVERT_TUNNEL_TO_NORMAL);
3776
3777         if (adapter->vxlan_port)
3778                 be_cmd_set_vxlan_port(adapter, 0);
3779
3780         adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS;
3781         adapter->vxlan_port = 0;
3782
3783         netdev->hw_enc_features = 0;
3784         netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3785         netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3786 }
3787 #endif
3788
3789 static u16 be_calculate_vf_qs(struct be_adapter *adapter, u16 num_vfs)
3790 {
3791         struct be_resources res = adapter->pool_res;
3792         u16 num_vf_qs = 1;
3793
3794         /* Distribute the queue resources equally among the PF and it's VFs
3795          * Do not distribute queue resources in multi-channel configuration.
3796          */
3797         if (num_vfs && !be_is_mc(adapter)) {
3798                 /* If number of VFs requested is 8 less than max supported,
3799                  * assign 8 queue pairs to the PF and divide the remaining
3800                  * resources evenly among the VFs
3801                  */
3802                 if (num_vfs < (be_max_vfs(adapter) - 8))
3803                         num_vf_qs = (res.max_rss_qs - 8) / num_vfs;
3804                 else
3805                         num_vf_qs = res.max_rss_qs / num_vfs;
3806
3807                 /* Skyhawk-R chip supports only MAX_RSS_IFACES RSS capable
3808                  * interfaces per port. Provide RSS on VFs, only if number
3809                  * of VFs requested is less than MAX_RSS_IFACES limit.
3810                  */
3811                 if (num_vfs >= MAX_RSS_IFACES)
3812                         num_vf_qs = 1;
3813         }
3814         return num_vf_qs;
3815 }
3816
3817 static int be_clear(struct be_adapter *adapter)
3818 {
3819         struct pci_dev *pdev = adapter->pdev;
3820         u16 num_vf_qs;
3821
3822         be_cancel_worker(adapter);
3823
3824         if (sriov_enabled(adapter))
3825                 be_vf_clear(adapter);
3826
3827         /* Re-configure FW to distribute resources evenly across max-supported
3828          * number of VFs, only when VFs are not already enabled.
3829          */
3830         if (skyhawk_chip(adapter) && be_physfn(adapter) &&
3831             !pci_vfs_assigned(pdev)) {
3832                 num_vf_qs = be_calculate_vf_qs(adapter,
3833                                                pci_sriov_get_totalvfs(pdev));
3834                 be_cmd_set_sriov_config(adapter, adapter->pool_res,
3835                                         pci_sriov_get_totalvfs(pdev),
3836                                         num_vf_qs);
3837         }
3838
3839 #ifdef CONFIG_BE2NET_VXLAN
3840         be_disable_vxlan_offloads(adapter);
3841 #endif
3842         kfree(adapter->pmac_id);
3843         adapter->pmac_id = NULL;
3844
3845         be_cmd_if_destroy(adapter, adapter->if_handle,  0);
3846
3847         be_clear_queues(adapter);
3848
3849         be_msix_disable(adapter);
3850         adapter->flags &= ~BE_FLAGS_SETUP_DONE;
3851         return 0;
3852 }
3853
3854 static int be_vfs_if_create(struct be_adapter *adapter)
3855 {
3856         struct be_resources res = {0};
3857         u32 cap_flags, en_flags, vf;
3858         struct be_vf_cfg *vf_cfg;
3859         int status;
3860
3861         /* If a FW profile exists, then cap_flags are updated */
3862         cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3863                     BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3864
3865         for_all_vfs(adapter, vf_cfg, vf) {
3866                 if (!BE3_chip(adapter)) {
3867                         status = be_cmd_get_profile_config(adapter, &res,
3868                                                            RESOURCE_LIMITS,
3869                                                            vf + 1);
3870                         if (!status) {
3871                                 cap_flags = res.if_cap_flags;
3872                                 /* Prevent VFs from enabling VLAN promiscuous
3873                                  * mode
3874                                  */
3875                                 cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
3876                         }
3877                 }
3878
3879                 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
3880                                         BE_IF_FLAGS_BROADCAST |
3881                                         BE_IF_FLAGS_MULTICAST |
3882                                         BE_IF_FLAGS_PASS_L3L4_ERRORS);
3883                 status = be_cmd_if_create(adapter, cap_flags, en_flags,
3884                                           &vf_cfg->if_handle, vf + 1);
3885                 if (status)
3886                         return status;
3887         }
3888
3889         return 0;
3890 }
3891
3892 static int be_vf_setup_init(struct be_adapter *adapter)
3893 {
3894         struct be_vf_cfg *vf_cfg;
3895         int vf;
3896
3897         adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
3898                                   GFP_KERNEL);
3899         if (!adapter->vf_cfg)
3900                 return -ENOMEM;
3901
3902         for_all_vfs(adapter, vf_cfg, vf) {
3903                 vf_cfg->if_handle = -1;
3904                 vf_cfg->pmac_id = -1;
3905         }
3906         return 0;
3907 }
3908
3909 static int be_vf_setup(struct be_adapter *adapter)
3910 {
3911         struct device *dev = &adapter->pdev->dev;
3912         struct be_vf_cfg *vf_cfg;
3913         int status, old_vfs, vf;
3914         bool spoofchk;
3915
3916         old_vfs = pci_num_vf(adapter->pdev);
3917
3918         status = be_vf_setup_init(adapter);
3919         if (status)
3920                 goto err;
3921
3922         if (old_vfs) {
3923                 for_all_vfs(adapter, vf_cfg, vf) {
3924                         status = be_cmd_get_if_id(adapter, vf_cfg, vf);
3925                         if (status)
3926                                 goto err;
3927                 }
3928
3929                 status = be_vfs_mac_query(adapter);
3930                 if (status)
3931                         goto err;
3932         } else {
3933                 status = be_vfs_if_create(adapter);
3934                 if (status)
3935                         goto err;
3936
3937                 status = be_vf_eth_addr_config(adapter);
3938                 if (status)
3939                         goto err;
3940         }
3941
3942         for_all_vfs(adapter, vf_cfg, vf) {
3943                 /* Allow VFs to programs MAC/VLAN filters */
3944                 status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges,
3945                                                   vf + 1);
3946                 if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
3947                         status = be_cmd_set_fn_privileges(adapter,
3948                                                           vf_cfg->privileges |
3949                                                           BE_PRIV_FILTMGMT,
3950                                                           vf + 1);
3951                         if (!status) {
3952                                 vf_cfg->privileges |= BE_PRIV_FILTMGMT;
3953                                 dev_info(dev, "VF%d has FILTMGMT privilege\n",
3954                                          vf);
3955                         }
3956                 }
3957
3958                 /* Allow full available bandwidth */
3959                 if (!old_vfs)
3960                         be_cmd_config_qos(adapter, 0, 0, vf + 1);
3961
3962                 status = be_cmd_get_hsw_config(adapter, NULL, vf + 1,
3963                                                vf_cfg->if_handle, NULL,
3964                                                &spoofchk);
3965                 if (!status)
3966                         vf_cfg->spoofchk = spoofchk;
3967
3968                 if (!old_vfs) {
3969                         be_cmd_enable_vf(adapter, vf + 1);
3970                         be_cmd_set_logical_link_config(adapter,
3971                                                        IFLA_VF_LINK_STATE_AUTO,
3972                                                        vf+1);
3973                 }
3974         }
3975
3976         if (!old_vfs) {
3977                 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
3978                 if (status) {
3979                         dev_err(dev, "SRIOV enable failed\n");
3980                         adapter->num_vfs = 0;
3981                         goto err;
3982                 }
3983         }
3984
3985         adapter->flags |= BE_FLAGS_SRIOV_ENABLED;
3986         return 0;
3987 err:
3988         dev_err(dev, "VF setup failed\n");
3989         be_vf_clear(adapter);
3990         return status;
3991 }
3992
3993 /* Converting function_mode bits on BE3 to SH mc_type enums */
3994
3995 static u8 be_convert_mc_type(u32 function_mode)
3996 {
3997         if (function_mode & VNIC_MODE && function_mode & QNQ_MODE)
3998                 return vNIC1;
3999         else if (function_mode & QNQ_MODE)
4000                 return FLEX10;
4001         else if (function_mode & VNIC_MODE)
4002                 return vNIC2;
4003         else if (function_mode & UMC_ENABLED)
4004                 return UMC;
4005         else
4006                 return MC_NONE;
4007 }
4008
4009 /* On BE2/BE3 FW does not suggest the supported limits */
4010 static void BEx_get_resources(struct be_adapter *adapter,
4011                               struct be_resources *res)
4012 {
4013         bool use_sriov = adapter->num_vfs ? 1 : 0;
4014
4015         if (be_physfn(adapter))
4016                 res->max_uc_mac = BE_UC_PMAC_COUNT;
4017         else
4018                 res->max_uc_mac = BE_VF_UC_PMAC_COUNT;
4019
4020         adapter->mc_type = be_convert_mc_type(adapter->function_mode);
4021
4022         if (be_is_mc(adapter)) {
4023                 /* Assuming that there are 4 channels per port,
4024                  * when multi-channel is enabled
4025                  */
4026                 if (be_is_qnq_mode(adapter))
4027                         res->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
4028                 else
4029                         /* In a non-qnq multichannel mode, the pvid
4030                          * takes up one vlan entry
4031                          */
4032                         res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1;
4033         } else {
4034                 res->max_vlans = BE_NUM_VLANS_SUPPORTED;
4035         }
4036
4037         res->max_mcast_mac = BE_MAX_MC;
4038
4039         /* 1) For BE3 1Gb ports, FW does not support multiple TXQs
4040          * 2) Create multiple TX rings on a BE3-R multi-channel interface
4041          *    *only* if it is RSS-capable.
4042          */
4043         if (BE2_chip(adapter) || use_sriov ||  (adapter->port_num > 1) ||
4044             be_virtfn(adapter) ||
4045             (be_is_mc(adapter) &&
4046              !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) {
4047                 res->max_tx_qs = 1;
4048         } else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) {
4049                 struct be_resources super_nic_res = {0};
4050
4051                 /* On a SuperNIC profile, the driver needs to use the
4052                  * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits
4053                  */
4054                 be_cmd_get_profile_config(adapter, &super_nic_res,
4055                                           RESOURCE_LIMITS, 0);
4056                 /* Some old versions of BE3 FW don't report max_tx_qs value */
4057                 res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS;
4058         } else {
4059                 res->max_tx_qs = BE3_MAX_TX_QS;
4060         }
4061
4062         if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
4063             !use_sriov && be_physfn(adapter))
4064                 res->max_rss_qs = (adapter->be3_native) ?
4065                                            BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
4066         res->max_rx_qs = res->max_rss_qs + 1;
4067
4068         if (be_physfn(adapter))
4069                 res->max_evt_qs = (be_max_vfs(adapter) > 0) ?
4070                                         BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS;
4071         else
4072                 res->max_evt_qs = 1;
4073
4074         res->if_cap_flags = BE_IF_CAP_FLAGS_WANT;
4075         res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS;
4076         if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS))
4077                 res->if_cap_flags &= ~BE_IF_FLAGS_RSS;
4078 }
4079
4080 static void be_setup_init(struct be_adapter *adapter)
4081 {
4082         adapter->vlan_prio_bmap = 0xff;
4083         adapter->phy.link_speed = -1;
4084         adapter->if_handle = -1;
4085         adapter->be3_native = false;
4086         adapter->if_flags = 0;
4087         if (be_physfn(adapter))
4088                 adapter->cmd_privileges = MAX_PRIVILEGES;
4089         else
4090                 adapter->cmd_privileges = MIN_PRIVILEGES;
4091 }
4092
4093 static int be_get_sriov_config(struct be_adapter *adapter)
4094 {
4095         struct be_resources res = {0};
4096         int max_vfs, old_vfs;
4097
4098         be_cmd_get_profile_config(adapter, &res, RESOURCE_LIMITS, 0);
4099
4100         /* Some old versions of BE3 FW don't report max_vfs value */
4101         if (BE3_chip(adapter) && !res.max_vfs) {
4102                 max_vfs = pci_sriov_get_totalvfs(adapter->pdev);
4103                 res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0;
4104         }
4105
4106         adapter->pool_res = res;
4107
4108         /* If during previous unload of the driver, the VFs were not disabled,
4109          * then we cannot rely on the PF POOL limits for the TotalVFs value.
4110          * Instead use the TotalVFs value stored in the pci-dev struct.
4111          */
4112         old_vfs = pci_num_vf(adapter->pdev);
4113         if (old_vfs) {
4114                 dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n",
4115                          old_vfs);
4116
4117                 adapter->pool_res.max_vfs =
4118                         pci_sriov_get_totalvfs(adapter->pdev);
4119                 adapter->num_vfs = old_vfs;
4120         }
4121
4122         return 0;
4123 }
4124
4125 static void be_alloc_sriov_res(struct be_adapter *adapter)
4126 {
4127         int old_vfs = pci_num_vf(adapter->pdev);
4128         u16 num_vf_qs;
4129         int status;
4130
4131         be_get_sriov_config(adapter);
4132
4133         if (!old_vfs)
4134                 pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter));
4135
4136         /* When the HW is in SRIOV capable configuration, the PF-pool
4137          * resources are given to PF during driver load, if there are no
4138          * old VFs. This facility is not available in BE3 FW.
4139          * Also, this is done by FW in Lancer chip.
4140          */
4141         if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) {
4142                 num_vf_qs = be_calculate_vf_qs(adapter, 0);
4143                 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0,
4144                                                  num_vf_qs);
4145                 if (status)
4146                         dev_err(&adapter->pdev->dev,
4147                                 "Failed to optimize SRIOV resources\n");
4148         }
4149 }
4150
4151 static int be_get_resources(struct be_adapter *adapter)
4152 {
4153         struct device *dev = &adapter->pdev->dev;
4154         struct be_resources res = {0};
4155         int status;
4156
4157         if (BEx_chip(adapter)) {
4158                 BEx_get_resources(adapter, &res);
4159                 adapter->res = res;
4160         }
4161
4162         /* For Lancer, SH etc read per-function resource limits from FW.
4163          * GET_FUNC_CONFIG returns per function guaranteed limits.
4164          * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits
4165          */
4166         if (!BEx_chip(adapter)) {
4167                 status = be_cmd_get_func_config(adapter, &res);
4168                 if (status)
4169                         return status;
4170
4171                 /* If a deafault RXQ must be created, we'll use up one RSSQ*/
4172                 if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs &&
4173                     !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS))
4174                         res.max_rss_qs -= 1;
4175
4176                 /* If RoCE may be enabled stash away half the EQs for RoCE */
4177                 if (be_roce_supported(adapter))
4178                         res.max_evt_qs /= 2;
4179                 adapter->res = res;
4180         }
4181
4182         /* If FW supports RSS default queue, then skip creating non-RSS
4183          * queue for non-IP traffic.
4184          */
4185         adapter->need_def_rxq = (be_if_cap_flags(adapter) &
4186                                  BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1;
4187
4188         dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n",
4189                  be_max_txqs(adapter), be_max_rxqs(adapter),
4190                  be_max_rss(adapter), be_max_eqs(adapter),
4191                  be_max_vfs(adapter));
4192         dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n",
4193                  be_max_uc(adapter), be_max_mc(adapter),
4194                  be_max_vlans(adapter));
4195
4196         /* Sanitize cfg_num_qs based on HW and platform limits */
4197         adapter->cfg_num_qs = min_t(u16, netif_get_num_default_rss_queues(),
4198                                     be_max_qs(adapter));
4199         return 0;
4200 }
4201
4202 static int be_get_config(struct be_adapter *adapter)
4203 {
4204         int status, level;
4205         u16 profile_id;
4206
4207         status = be_cmd_query_fw_cfg(adapter);
4208         if (status)
4209                 return status;
4210
4211         if (BEx_chip(adapter)) {
4212                 level = be_cmd_get_fw_log_level(adapter);
4213                 adapter->msg_enable =
4214                         level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
4215         }
4216
4217         be_cmd_get_acpi_wol_cap(adapter);
4218
4219         be_cmd_query_port_name(adapter);
4220
4221         if (be_physfn(adapter)) {
4222                 status = be_cmd_get_active_profile(adapter, &profile_id);
4223                 if (!status)
4224                         dev_info(&adapter->pdev->dev,
4225                                  "Using profile 0x%x\n", profile_id);
4226         }
4227
4228         status = be_get_resources(adapter);
4229         if (status)
4230                 return status;
4231
4232         adapter->pmac_id = kcalloc(be_max_uc(adapter),
4233                                    sizeof(*adapter->pmac_id), GFP_KERNEL);
4234         if (!adapter->pmac_id)
4235                 return -ENOMEM;
4236
4237         return 0;
4238 }
4239
4240 static int be_mac_setup(struct be_adapter *adapter)
4241 {
4242         u8 mac[ETH_ALEN];
4243         int status;
4244
4245         if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
4246                 status = be_cmd_get_perm_mac(adapter, mac);
4247                 if (status)
4248                         return status;
4249
4250                 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
4251                 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
4252         }
4253
4254         return 0;
4255 }
4256
4257 static void be_schedule_worker(struct be_adapter *adapter)
4258 {
4259         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
4260         adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
4261 }
4262
4263 static void be_schedule_err_detection(struct be_adapter *adapter)
4264 {
4265         schedule_delayed_work(&adapter->be_err_detection_work,
4266                               msecs_to_jiffies(1000));
4267         adapter->flags |= BE_FLAGS_ERR_DETECTION_SCHEDULED;
4268 }
4269
4270 static int be_setup_queues(struct be_adapter *adapter)
4271 {
4272         struct net_device *netdev = adapter->netdev;
4273         int status;
4274
4275         status = be_evt_queues_create(adapter);
4276         if (status)
4277                 goto err;
4278
4279         status = be_tx_qs_create(adapter);
4280         if (status)
4281                 goto err;
4282
4283         status = be_rx_cqs_create(adapter);
4284         if (status)
4285                 goto err;
4286
4287         status = be_mcc_queues_create(adapter);
4288         if (status)
4289                 goto err;
4290
4291         status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs);
4292         if (status)
4293                 goto err;
4294
4295         status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs);
4296         if (status)
4297                 goto err;
4298
4299         return 0;
4300 err:
4301         dev_err(&adapter->pdev->dev, "queue_setup failed\n");
4302         return status;
4303 }
4304
4305 int be_update_queues(struct be_adapter *adapter)
4306 {
4307         struct net_device *netdev = adapter->netdev;
4308         int status;
4309
4310         if (netif_running(netdev))
4311                 be_close(netdev);
4312
4313         be_cancel_worker(adapter);
4314
4315         /* If any vectors have been shared with RoCE we cannot re-program
4316          * the MSIx table.
4317          */
4318         if (!adapter->num_msix_roce_vec)
4319                 be_msix_disable(adapter);
4320
4321         be_clear_queues(adapter);
4322
4323         if (!msix_enabled(adapter)) {
4324                 status = be_msix_enable(adapter);
4325                 if (status)
4326                         return status;
4327         }
4328
4329         status = be_setup_queues(adapter);
4330         if (status)
4331                 return status;
4332
4333         be_schedule_worker(adapter);
4334
4335         if (netif_running(netdev))
4336                 status = be_open(netdev);
4337
4338         return status;
4339 }
4340
4341 static inline int fw_major_num(const char *fw_ver)
4342 {
4343         int fw_major = 0, i;
4344
4345         i = sscanf(fw_ver, "%d.", &fw_major);
4346         if (i != 1)
4347                 return 0;
4348
4349         return fw_major;
4350 }
4351
4352 /* If any VFs are already enabled don't FLR the PF */
4353 static bool be_reset_required(struct be_adapter *adapter)
4354 {
4355         return pci_num_vf(adapter->pdev) ? false : true;
4356 }
4357
4358 /* Wait for the FW to be ready and perform the required initialization */
4359 static int be_func_init(struct be_adapter *adapter)
4360 {
4361         int status;
4362
4363         status = be_fw_wait_ready(adapter);
4364         if (status)
4365                 return status;
4366
4367         if (be_reset_required(adapter)) {
4368                 status = be_cmd_reset_function(adapter);
4369                 if (status)
4370                         return status;
4371
4372                 /* Wait for interrupts to quiesce after an FLR */
4373                 msleep(100);
4374
4375                 /* We can clear all errors when function reset succeeds */
4376                 be_clear_error(adapter, BE_CLEAR_ALL);
4377         }
4378
4379         /* Tell FW we're ready to fire cmds */
4380         status = be_cmd_fw_init(adapter);
4381         if (status)
4382                 return status;
4383
4384         /* Allow interrupts for other ULPs running on NIC function */
4385         be_intr_set(adapter, true);
4386
4387         return 0;
4388 }
4389
4390 static int be_setup(struct be_adapter *adapter)
4391 {
4392         struct device *dev = &adapter->pdev->dev;
4393         u32 en_flags;
4394         int status;
4395
4396         status = be_func_init(adapter);
4397         if (status)
4398                 return status;
4399
4400         be_setup_init(adapter);
4401
4402         if (!lancer_chip(adapter))
4403                 be_cmd_req_native_mode(adapter);
4404
4405         /* Need to invoke this cmd first to get the PCI Function Number */
4406         status = be_cmd_get_cntl_attributes(adapter);
4407         if (status)
4408                 return status;
4409
4410         if (!BE2_chip(adapter) && be_physfn(adapter))
4411                 be_alloc_sriov_res(adapter);
4412
4413         status = be_get_config(adapter);
4414         if (status)
4415                 goto err;
4416
4417         status = be_msix_enable(adapter);
4418         if (status)
4419                 goto err;
4420
4421         /* will enable all the needed filter flags in be_open() */
4422         en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS;
4423         en_flags = en_flags & be_if_cap_flags(adapter);
4424         status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
4425                                   &adapter->if_handle, 0);
4426         if (status)
4427                 goto err;
4428
4429         /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
4430         rtnl_lock();
4431         status = be_setup_queues(adapter);
4432         rtnl_unlock();
4433         if (status)
4434                 goto err;
4435
4436         be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
4437
4438         status = be_mac_setup(adapter);
4439         if (status)
4440                 goto err;
4441
4442         be_cmd_get_fw_ver(adapter);
4443         dev_info(dev, "FW version is %s\n", adapter->fw_ver);
4444
4445         if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) {
4446                 dev_err(dev, "Firmware on card is old(%s), IRQs may not work",
4447                         adapter->fw_ver);
4448                 dev_err(dev, "Please upgrade firmware to version >= 4.0\n");
4449         }
4450
4451         status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
4452                                          adapter->rx_fc);
4453         if (status)
4454                 be_cmd_get_flow_control(adapter, &adapter->tx_fc,
4455                                         &adapter->rx_fc);
4456
4457         dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n",
4458                  adapter->tx_fc, adapter->rx_fc);
4459
4460         if (be_physfn(adapter))
4461                 be_cmd_set_logical_link_config(adapter,
4462                                                IFLA_VF_LINK_STATE_AUTO, 0);
4463
4464         if (adapter->num_vfs)
4465                 be_vf_setup(adapter);
4466
4467         status = be_cmd_get_phy_info(adapter);
4468         if (!status && be_pause_supported(adapter))
4469                 adapter->phy.fc_autoneg = 1;
4470
4471         be_schedule_worker(adapter);
4472         adapter->flags |= BE_FLAGS_SETUP_DONE;
4473         return 0;
4474 err:
4475         be_clear(adapter);
4476         return status;
4477 }
4478
4479 #ifdef CONFIG_NET_POLL_CONTROLLER
4480 static void be_netpoll(struct net_device *netdev)
4481 {
4482         struct be_adapter *adapter = netdev_priv(netdev);
4483         struct be_eq_obj *eqo;
4484         int i;
4485
4486         for_all_evt_queues(adapter, eqo, i) {
4487                 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
4488                 napi_schedule(&eqo->napi);
4489         }
4490 }
4491 #endif
4492
4493 static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
4494
4495 static bool phy_flashing_required(struct be_adapter *adapter)
4496 {
4497         return (adapter->phy.phy_type == PHY_TYPE_TN_8022 &&
4498                 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
4499 }
4500
4501 static bool is_comp_in_ufi(struct be_adapter *adapter,
4502                            struct flash_section_info *fsec, int type)
4503 {
4504         int i = 0, img_type = 0;
4505         struct flash_section_info_g2 *fsec_g2 = NULL;
4506
4507         if (BE2_chip(adapter))
4508                 fsec_g2 = (struct flash_section_info_g2 *)fsec;
4509
4510         for (i = 0; i < MAX_FLASH_COMP; i++) {
4511                 if (fsec_g2)
4512                         img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
4513                 else
4514                         img_type = le32_to_cpu(fsec->fsec_entry[i].type);
4515
4516                 if (img_type == type)
4517                         return true;
4518         }
4519         return false;
4520
4521 }
4522
4523 static struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
4524                                                 int header_size,
4525                                                 const struct firmware *fw)
4526 {
4527         struct flash_section_info *fsec = NULL;
4528         const u8 *p = fw->data;
4529
4530         p += header_size;
4531         while (p < (fw->data + fw->size)) {
4532                 fsec = (struct flash_section_info *)p;
4533                 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
4534                         return fsec;
4535                 p += 32;
4536         }
4537         return NULL;
4538 }
4539
4540 static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
4541                               u32 img_offset, u32 img_size, int hdr_size,
4542                               u16 img_optype, bool *crc_match)
4543 {
4544         u32 crc_offset;
4545         int status;
4546         u8 crc[4];
4547
4548         status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset,
4549                                       img_size - 4);
4550         if (status)
4551                 return status;
4552
4553         crc_offset = hdr_size + img_offset + img_size - 4;
4554
4555         /* Skip flashing, if crc of flashed region matches */
4556         if (!memcmp(crc, p + crc_offset, 4))
4557                 *crc_match = true;
4558         else
4559                 *crc_match = false;
4560
4561         return status;
4562 }
4563
4564 static int be_flash(struct be_adapter *adapter, const u8 *img,
4565                     struct be_dma_mem *flash_cmd, int optype, int img_size,
4566                     u32 img_offset)
4567 {
4568         u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0;
4569         struct be_cmd_write_flashrom *req = flash_cmd->va;
4570         int status;
4571
4572         while (total_bytes) {
4573                 num_bytes = min_t(u32, 32*1024, total_bytes);
4574
4575                 total_bytes -= num_bytes;
4576
4577                 if (!total_bytes) {
4578                         if (optype == OPTYPE_PHY_FW)
4579                                 flash_op = FLASHROM_OPER_PHY_FLASH;
4580                         else
4581                                 flash_op = FLASHROM_OPER_FLASH;
4582                 } else {
4583                         if (optype == OPTYPE_PHY_FW)
4584                                 flash_op = FLASHROM_OPER_PHY_SAVE;
4585                         else
4586                                 flash_op = FLASHROM_OPER_SAVE;
4587                 }
4588
4589                 memcpy(req->data_buf, img, num_bytes);
4590                 img += num_bytes;
4591                 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
4592                                                flash_op, img_offset +
4593                                                bytes_sent, num_bytes);
4594                 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST &&
4595                     optype == OPTYPE_PHY_FW)
4596                         break;
4597                 else if (status)
4598                         return status;
4599
4600                 bytes_sent += num_bytes;
4601         }
4602         return 0;
4603 }
4604
4605 /* For BE2, BE3 and BE3-R */
4606 static int be_flash_BEx(struct be_adapter *adapter,
4607                         const struct firmware *fw,
4608                         struct be_dma_mem *flash_cmd, int num_of_images)
4609 {
4610         int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
4611         struct device *dev = &adapter->pdev->dev;
4612         struct flash_section_info *fsec = NULL;
4613         int status, i, filehdr_size, num_comp;
4614         const struct flash_comp *pflashcomp;
4615         bool crc_match;
4616         const u8 *p;
4617
4618         struct flash_comp gen3_flash_types[] = {
4619                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
4620                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
4621                 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
4622                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
4623                 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
4624                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
4625                 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
4626                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
4627                 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
4628                         FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
4629                 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
4630                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
4631                 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
4632                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
4633                 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
4634                         FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
4635                 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
4636                         FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
4637                 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
4638                         FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
4639         };
4640
4641         struct flash_comp gen2_flash_types[] = {
4642                 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
4643                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
4644                 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
4645                         FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
4646                 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
4647                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
4648                 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
4649                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
4650                 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
4651                         FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
4652                 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
4653                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
4654                 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
4655                         FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
4656                 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
4657                          FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
4658         };
4659
4660         if (BE3_chip(adapter)) {
4661                 pflashcomp = gen3_flash_types;
4662                 filehdr_size = sizeof(struct flash_file_hdr_g3);
4663                 num_comp = ARRAY_SIZE(gen3_flash_types);
4664         } else {
4665                 pflashcomp = gen2_flash_types;
4666                 filehdr_size = sizeof(struct flash_file_hdr_g2);
4667                 num_comp = ARRAY_SIZE(gen2_flash_types);
4668                 img_hdrs_size = 0;
4669         }
4670
4671         /* Get flash section info*/
4672         fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4673         if (!fsec) {
4674                 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4675                 return -1;
4676         }
4677         for (i = 0; i < num_comp; i++) {
4678                 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
4679                         continue;
4680
4681                 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
4682                     memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
4683                         continue;
4684
4685                 if (pflashcomp[i].optype == OPTYPE_PHY_FW  &&
4686                     !phy_flashing_required(adapter))
4687                                 continue;
4688
4689                 if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
4690                         status = be_check_flash_crc(adapter, fw->data,
4691                                                     pflashcomp[i].offset,
4692                                                     pflashcomp[i].size,
4693                                                     filehdr_size +
4694                                                     img_hdrs_size,
4695                                                     OPTYPE_REDBOOT, &crc_match);
4696                         if (status) {
4697                                 dev_err(dev,
4698                                         "Could not get CRC for 0x%x region\n",
4699                                         pflashcomp[i].optype);
4700                                 continue;
4701                         }
4702
4703                         if (crc_match)
4704                                 continue;
4705                 }
4706
4707                 p = fw->data + filehdr_size + pflashcomp[i].offset +
4708                         img_hdrs_size;
4709                 if (p + pflashcomp[i].size > fw->data + fw->size)
4710                         return -1;
4711
4712                 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
4713                                   pflashcomp[i].size, 0);
4714                 if (status) {
4715                         dev_err(dev, "Flashing section type 0x%x failed\n",
4716                                 pflashcomp[i].img_type);
4717                         return status;
4718                 }
4719         }
4720         return 0;
4721 }
4722
4723 static u16 be_get_img_optype(struct flash_section_entry fsec_entry)
4724 {
4725         u32 img_type = le32_to_cpu(fsec_entry.type);
4726         u16 img_optype = le16_to_cpu(fsec_entry.optype);
4727
4728         if (img_optype != 0xFFFF)
4729                 return img_optype;
4730
4731         switch (img_type) {
4732         case IMAGE_FIRMWARE_iSCSI:
4733                 img_optype = OPTYPE_ISCSI_ACTIVE;
4734                 break;
4735         case IMAGE_BOOT_CODE:
4736                 img_optype = OPTYPE_REDBOOT;
4737                 break;
4738         case IMAGE_OPTION_ROM_ISCSI:
4739                 img_optype = OPTYPE_BIOS;
4740                 break;
4741         case IMAGE_OPTION_ROM_PXE:
4742                 img_optype = OPTYPE_PXE_BIOS;
4743                 break;
4744         case IMAGE_OPTION_ROM_FCoE:
4745                 img_optype = OPTYPE_FCOE_BIOS;
4746                 break;
4747         case IMAGE_FIRMWARE_BACKUP_iSCSI:
4748                 img_optype = OPTYPE_ISCSI_BACKUP;
4749                 break;
4750         case IMAGE_NCSI:
4751                 img_optype = OPTYPE_NCSI_FW;
4752                 break;
4753         case IMAGE_FLASHISM_JUMPVECTOR:
4754                 img_optype = OPTYPE_FLASHISM_JUMPVECTOR;
4755                 break;
4756         case IMAGE_FIRMWARE_PHY:
4757                 img_optype = OPTYPE_SH_PHY_FW;
4758                 break;
4759         case IMAGE_REDBOOT_DIR:
4760                 img_optype = OPTYPE_REDBOOT_DIR;
4761                 break;
4762         case IMAGE_REDBOOT_CONFIG:
4763                 img_optype = OPTYPE_REDBOOT_CONFIG;
4764                 break;
4765         case IMAGE_UFI_DIR:
4766                 img_optype = OPTYPE_UFI_DIR;
4767                 break;
4768         default:
4769                 break;
4770         }
4771
4772         return img_optype;
4773 }
4774
4775 static int be_flash_skyhawk(struct be_adapter *adapter,
4776                             const struct firmware *fw,
4777                             struct be_dma_mem *flash_cmd, int num_of_images)
4778 {
4779         int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
4780         bool crc_match, old_fw_img, flash_offset_support = true;
4781         struct device *dev = &adapter->pdev->dev;
4782         struct flash_section_info *fsec = NULL;
4783         u32 img_offset, img_size, img_type;
4784         u16 img_optype, flash_optype;
4785         int status, i, filehdr_size;
4786         const u8 *p;
4787
4788         filehdr_size = sizeof(struct flash_file_hdr_g3);
4789         fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4790         if (!fsec) {
4791                 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4792                 return -EINVAL;
4793         }
4794
4795 retry_flash:
4796         for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
4797                 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
4798                 img_size   = le32_to_cpu(fsec->fsec_entry[i].pad_size);
4799                 img_type   = le32_to_cpu(fsec->fsec_entry[i].type);
4800                 img_optype = be_get_img_optype(fsec->fsec_entry[i]);
4801                 old_fw_img = fsec->fsec_entry[i].optype == 0xFFFF;
4802
4803                 if (img_optype == 0xFFFF)
4804                         continue;
4805
4806                 if (flash_offset_support)
4807                         flash_optype = OPTYPE_OFFSET_SPECIFIED;
4808                 else
4809                         flash_optype = img_optype;
4810
4811                 /* Don't bother verifying CRC if an old FW image is being
4812                  * flashed
4813                  */
4814                 if (old_fw_img)
4815                         goto flash;
4816
4817                 status = be_check_flash_crc(adapter, fw->data, img_offset,
4818                                             img_size, filehdr_size +
4819                                             img_hdrs_size, flash_optype,
4820                                             &crc_match);
4821                 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST ||
4822                     base_status(status) == MCC_STATUS_ILLEGAL_FIELD) {
4823                         /* The current FW image on the card does not support
4824                          * OFFSET based flashing. Retry using older mechanism
4825                          * of OPTYPE based flashing
4826                          */
4827                         if (flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4828                                 flash_offset_support = false;
4829                                 goto retry_flash;
4830                         }
4831
4832                         /* The current FW image on the card does not recognize
4833                          * the new FLASH op_type. The FW download is partially
4834                          * complete. Reboot the server now to enable FW image
4835                          * to recognize the new FLASH op_type. To complete the
4836                          * remaining process, download the same FW again after
4837                          * the reboot.
4838                          */
4839                         dev_err(dev, "Flash incomplete. Reset the server\n");
4840                         dev_err(dev, "Download FW image again after reset\n");
4841                         return -EAGAIN;
4842                 } else if (status) {
4843                         dev_err(dev, "Could not get CRC for 0x%x region\n",
4844                                 img_optype);
4845                         return -EFAULT;
4846                 }
4847
4848                 if (crc_match)
4849                         continue;
4850
4851 flash:
4852                 p = fw->data + filehdr_size + img_offset + img_hdrs_size;
4853                 if (p + img_size > fw->data + fw->size)
4854                         return -1;
4855
4856                 status = be_flash(adapter, p, flash_cmd, flash_optype, img_size,
4857                                   img_offset);
4858
4859                 /* The current FW image on the card does not support OFFSET
4860                  * based flashing. Retry using older mechanism of OPTYPE based
4861                  * flashing
4862                  */
4863                 if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD &&
4864                     flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4865                         flash_offset_support = false;
4866                         goto retry_flash;
4867                 }
4868
4869                 /* For old FW images ignore ILLEGAL_FIELD error or errors on
4870                  * UFI_DIR region
4871                  */
4872                 if (old_fw_img &&
4873                     (base_status(status) == MCC_STATUS_ILLEGAL_FIELD ||
4874                      (img_optype == OPTYPE_UFI_DIR &&
4875                       base_status(status) == MCC_STATUS_FAILED))) {
4876                         continue;
4877                 } else if (status) {
4878                         dev_err(dev, "Flashing section type 0x%x failed\n",
4879                                 img_type);
4880                         return -EFAULT;
4881                 }
4882         }
4883         return 0;
4884 }
4885
4886 static int lancer_fw_download(struct be_adapter *adapter,
4887                               const struct firmware *fw)
4888 {
4889 #define LANCER_FW_DOWNLOAD_CHUNK      (32 * 1024)
4890 #define LANCER_FW_DOWNLOAD_LOCATION   "/prg"
4891         struct device *dev = &adapter->pdev->dev;
4892         struct be_dma_mem flash_cmd;
4893         const u8 *data_ptr = NULL;
4894         u8 *dest_image_ptr = NULL;
4895         size_t image_size = 0;
4896         u32 chunk_size = 0;
4897         u32 data_written = 0;
4898         u32 offset = 0;
4899         int status = 0;
4900         u8 add_status = 0;
4901         u8 change_status;
4902
4903         if (!IS_ALIGNED(fw->size, sizeof(u32))) {
4904                 dev_err(dev, "FW image size should be multiple of 4\n");
4905                 return -EINVAL;
4906         }
4907
4908         flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
4909                                 + LANCER_FW_DOWNLOAD_CHUNK;
4910         flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
4911                                            &flash_cmd.dma, GFP_KERNEL);
4912         if (!flash_cmd.va)
4913                 return -ENOMEM;
4914
4915         dest_image_ptr = flash_cmd.va +
4916                                 sizeof(struct lancer_cmd_req_write_object);
4917         image_size = fw->size;
4918         data_ptr = fw->data;
4919
4920         while (image_size) {
4921                 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
4922
4923                 /* Copy the image chunk content. */
4924                 memcpy(dest_image_ptr, data_ptr, chunk_size);
4925
4926                 status = lancer_cmd_write_object(adapter, &flash_cmd,
4927                                                  chunk_size, offset,
4928                                                  LANCER_FW_DOWNLOAD_LOCATION,
4929                                                  &data_written, &change_status,
4930                                                  &add_status);
4931                 if (status)
4932                         break;
4933
4934                 offset += data_written;
4935                 data_ptr += data_written;
4936                 image_size -= data_written;
4937         }
4938
4939         if (!status) {
4940                 /* Commit the FW written */
4941                 status = lancer_cmd_write_object(adapter, &flash_cmd,
4942                                                  0, offset,
4943                                                  LANCER_FW_DOWNLOAD_LOCATION,
4944                                                  &data_written, &change_status,
4945                                                  &add_status);
4946         }
4947
4948         dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
4949         if (status) {
4950                 dev_err(dev, "Firmware load error\n");
4951                 return be_cmd_status(status);
4952         }
4953
4954         dev_info(dev, "Firmware flashed successfully\n");
4955
4956         if (change_status == LANCER_FW_RESET_NEEDED) {
4957                 dev_info(dev, "Resetting adapter to activate new FW\n");
4958                 status = lancer_physdev_ctrl(adapter,
4959                                              PHYSDEV_CONTROL_FW_RESET_MASK);
4960                 if (status) {
4961                         dev_err(dev, "Adapter busy, could not reset FW\n");
4962                         dev_err(dev, "Reboot server to activate new FW\n");
4963                 }
4964         } else if (change_status != LANCER_NO_RESET_NEEDED) {
4965                 dev_info(dev, "Reboot server to activate new FW\n");
4966         }
4967
4968         return 0;
4969 }
4970
4971 /* Check if the flash image file is compatible with the adapter that
4972  * is being flashed.
4973  */
4974 static bool be_check_ufi_compatibility(struct be_adapter *adapter,
4975                                        struct flash_file_hdr_g3 *fhdr)
4976 {
4977         if (!fhdr) {
4978                 dev_err(&adapter->pdev->dev, "Invalid FW UFI file");
4979                 return false;
4980         }
4981
4982         /* First letter of the build version is used to identify
4983          * which chip this image file is meant for.
4984          */
4985         switch (fhdr->build[0]) {
4986         case BLD_STR_UFI_TYPE_SH:
4987                 if (!skyhawk_chip(adapter))
4988                         return false;
4989                 break;
4990         case BLD_STR_UFI_TYPE_BE3:
4991                 if (!BE3_chip(adapter))
4992                         return false;
4993                 break;
4994         case BLD_STR_UFI_TYPE_BE2:
4995                 if (!BE2_chip(adapter))
4996                         return false;
4997                 break;
4998         default:
4999                 return false;
5000         }
5001
5002         /* In BE3 FW images the "asic_type_rev" field doesn't track the
5003          * asic_rev of the chips it is compatible with.
5004          * When asic_type_rev is 0 the image is compatible only with
5005          * pre-BE3-R chips (asic_rev < 0x10)
5006          */
5007         if (BEx_chip(adapter) && fhdr->asic_type_rev == 0)
5008                 return adapter->asic_rev < 0x10;
5009         else
5010                 return (fhdr->asic_type_rev >= adapter->asic_rev);
5011 }
5012
5013 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
5014 {
5015         struct device *dev = &adapter->pdev->dev;
5016         struct flash_file_hdr_g3 *fhdr3;
5017         struct image_hdr *img_hdr_ptr;
5018         int status = 0, i, num_imgs;
5019         struct be_dma_mem flash_cmd;
5020
5021         fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
5022         if (!be_check_ufi_compatibility(adapter, fhdr3)) {
5023                 dev_err(dev, "Flash image is not compatible with adapter\n");
5024                 return -EINVAL;
5025         }
5026
5027         flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
5028         flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
5029                                            GFP_KERNEL);
5030         if (!flash_cmd.va)
5031                 return -ENOMEM;
5032
5033         num_imgs = le32_to_cpu(fhdr3->num_imgs);
5034         for (i = 0; i < num_imgs; i++) {
5035                 img_hdr_ptr = (struct image_hdr *)(fw->data +
5036                                 (sizeof(struct flash_file_hdr_g3) +
5037                                  i * sizeof(struct image_hdr)));
5038                 if (!BE2_chip(adapter) &&
5039                     le32_to_cpu(img_hdr_ptr->imageid) != 1)
5040                         continue;
5041
5042                 if (skyhawk_chip(adapter))
5043                         status = be_flash_skyhawk(adapter, fw, &flash_cmd,
5044                                                   num_imgs);
5045                 else
5046                         status = be_flash_BEx(adapter, fw, &flash_cmd,
5047                                               num_imgs);
5048         }
5049
5050         dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
5051         if (!status)
5052                 dev_info(dev, "Firmware flashed successfully\n");
5053
5054         return status;
5055 }
5056
5057 int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
5058 {
5059         const struct firmware *fw;
5060         int status;
5061
5062         if (!netif_running(adapter->netdev)) {
5063                 dev_err(&adapter->pdev->dev,
5064                         "Firmware load not allowed (interface is down)\n");
5065                 return -ENETDOWN;
5066         }
5067
5068         status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
5069         if (status)
5070                 goto fw_exit;
5071
5072         dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
5073
5074         if (lancer_chip(adapter))
5075                 status = lancer_fw_download(adapter, fw);
5076         else
5077                 status = be_fw_download(adapter, fw);
5078
5079         if (!status)
5080                 be_cmd_get_fw_ver(adapter);
5081
5082 fw_exit:
5083         release_firmware(fw);
5084         return status;
5085 }
5086
5087 static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
5088                                  u16 flags)
5089 {
5090         struct be_adapter *adapter = netdev_priv(dev);
5091         struct nlattr *attr, *br_spec;
5092         int rem;
5093         int status = 0;
5094         u16 mode = 0;
5095
5096         if (!sriov_enabled(adapter))
5097                 return -EOPNOTSUPP;
5098
5099         br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5100         if (!br_spec)
5101                 return -EINVAL;
5102
5103         nla_for_each_nested(attr, br_spec, rem) {
5104                 if (nla_type(attr) != IFLA_BRIDGE_MODE)
5105                         continue;
5106
5107                 if (nla_len(attr) < sizeof(mode))
5108                         return -EINVAL;
5109
5110                 mode = nla_get_u16(attr);
5111                 if (BE3_chip(adapter) && mode == BRIDGE_MODE_VEPA)
5112                         return -EOPNOTSUPP;
5113
5114                 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
5115                         return -EINVAL;
5116
5117                 status = be_cmd_set_hsw_config(adapter, 0, 0,
5118                                                adapter->if_handle,
5119                                                mode == BRIDGE_MODE_VEPA ?
5120                                                PORT_FWD_TYPE_VEPA :
5121                                                PORT_FWD_TYPE_VEB, 0);
5122                 if (status)
5123                         goto err;
5124
5125                 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n",
5126                          mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5127
5128                 return status;
5129         }
5130 err:
5131         dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n",
5132                 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5133
5134         return status;
5135 }
5136
5137 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
5138                                  struct net_device *dev, u32 filter_mask,
5139                                  int nlflags)
5140 {
5141         struct be_adapter *adapter = netdev_priv(dev);
5142         int status = 0;
5143         u8 hsw_mode;
5144
5145         /* BE and Lancer chips support VEB mode only */
5146         if (BEx_chip(adapter) || lancer_chip(adapter)) {
5147                 hsw_mode = PORT_FWD_TYPE_VEB;
5148         } else {
5149                 status = be_cmd_get_hsw_config(adapter, NULL, 0,
5150                                                adapter->if_handle, &hsw_mode,
5151                                                NULL);
5152                 if (status)
5153                         return 0;
5154
5155                 if (hsw_mode == PORT_FWD_TYPE_PASSTHRU)
5156                         return 0;
5157         }
5158
5159         return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
5160                                        hsw_mode == PORT_FWD_TYPE_VEPA ?
5161                                        BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB,
5162                                        0, 0, nlflags, filter_mask, NULL);
5163 }
5164
5165 #ifdef CONFIG_BE2NET_VXLAN
5166 /* VxLAN offload Notes:
5167  *
5168  * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't
5169  * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload
5170  * is expected to work across all types of IP tunnels once exported. Skyhawk
5171  * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN
5172  * offloads in hw_enc_features only when a VxLAN port is added. If other (non
5173  * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for
5174  * those other tunnels are unexported on the fly through ndo_features_check().
5175  *
5176  * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack
5177  * adds more than one port, disable offloads and don't re-enable them again
5178  * until after all the tunnels are removed.
5179  */
5180 static void be_add_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5181                               __be16 port)
5182 {
5183         struct be_adapter *adapter = netdev_priv(netdev);
5184         struct device *dev = &adapter->pdev->dev;
5185         int status;
5186
5187         if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5188                 return;
5189
5190         if (adapter->vxlan_port == port && adapter->vxlan_port_count) {
5191                 adapter->vxlan_port_aliases++;
5192                 return;
5193         }
5194
5195         if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) {
5196                 dev_info(dev,
5197                          "Only one UDP port supported for VxLAN offloads\n");
5198                 dev_info(dev, "Disabling VxLAN offloads\n");
5199                 adapter->vxlan_port_count++;
5200                 goto err;
5201         }
5202
5203         if (adapter->vxlan_port_count++ >= 1)
5204                 return;
5205
5206         status = be_cmd_manage_iface(adapter, adapter->if_handle,
5207                                      OP_CONVERT_NORMAL_TO_TUNNEL);
5208         if (status) {
5209                 dev_warn(dev, "Failed to convert normal interface to tunnel\n");
5210                 goto err;
5211         }
5212
5213         status = be_cmd_set_vxlan_port(adapter, port);
5214         if (status) {
5215                 dev_warn(dev, "Failed to add VxLAN port\n");
5216                 goto err;
5217         }
5218         adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS;
5219         adapter->vxlan_port = port;
5220
5221         netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
5222                                    NETIF_F_TSO | NETIF_F_TSO6 |
5223                                    NETIF_F_GSO_UDP_TUNNEL;
5224         netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
5225         netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
5226
5227         dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n",
5228                  be16_to_cpu(port));
5229         return;
5230 err:
5231         be_disable_vxlan_offloads(adapter);
5232 }
5233
5234 static void be_del_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5235                               __be16 port)
5236 {
5237         struct be_adapter *adapter = netdev_priv(netdev);
5238
5239         if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5240                 return;
5241
5242         if (adapter->vxlan_port != port)
5243                 goto done;
5244
5245         if (adapter->vxlan_port_aliases) {
5246                 adapter->vxlan_port_aliases--;
5247                 return;
5248         }
5249
5250         be_disable_vxlan_offloads(adapter);
5251
5252         dev_info(&adapter->pdev->dev,
5253                  "Disabled VxLAN offloads for UDP port %d\n",
5254                  be16_to_cpu(port));
5255 done:
5256         adapter->vxlan_port_count--;
5257 }
5258
5259 static netdev_features_t be_features_check(struct sk_buff *skb,
5260                                            struct net_device *dev,
5261                                            netdev_features_t features)
5262 {
5263         struct be_adapter *adapter = netdev_priv(dev);
5264         u8 l4_hdr = 0;
5265
5266         /* The code below restricts offload features for some tunneled packets.
5267          * Offload features for normal (non tunnel) packets are unchanged.
5268          */
5269         if (!skb->encapsulation ||
5270             !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS))
5271                 return features;
5272
5273         /* It's an encapsulated packet and VxLAN offloads are enabled. We
5274          * should disable tunnel offload features if it's not a VxLAN packet,
5275          * as tunnel offloads have been enabled only for VxLAN. This is done to
5276          * allow other tunneled traffic like GRE work fine while VxLAN
5277          * offloads are configured in Skyhawk-R.
5278          */
5279         switch (vlan_get_protocol(skb)) {
5280         case htons(ETH_P_IP):
5281                 l4_hdr = ip_hdr(skb)->protocol;
5282                 break;
5283         case htons(ETH_P_IPV6):
5284                 l4_hdr = ipv6_hdr(skb)->nexthdr;
5285                 break;
5286         default:
5287                 return features;
5288         }
5289
5290         if (l4_hdr != IPPROTO_UDP ||
5291             skb->inner_protocol_type != ENCAP_TYPE_ETHER ||
5292             skb->inner_protocol != htons(ETH_P_TEB) ||
5293             skb_inner_mac_header(skb) - skb_transport_header(skb) !=
5294             sizeof(struct udphdr) + sizeof(struct vxlanhdr))
5295                 return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
5296
5297         return features;
5298 }
5299 #endif
5300
5301 static int be_get_phys_port_id(struct net_device *dev,
5302                                struct netdev_phys_item_id *ppid)
5303 {
5304         int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1;
5305         struct be_adapter *adapter = netdev_priv(dev);
5306         u8 *id;
5307
5308         if (MAX_PHYS_ITEM_ID_LEN < id_len)
5309                 return -ENOSPC;
5310
5311         ppid->id[0] = adapter->hba_port_num + 1;
5312         id = &ppid->id[1];
5313         for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0;
5314              i--, id += CNTL_SERIAL_NUM_WORD_SZ)
5315                 memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ);
5316
5317         ppid->id_len = id_len;
5318
5319         return 0;
5320 }
5321
5322 static const struct net_device_ops be_netdev_ops = {
5323         .ndo_open               = be_open,
5324         .ndo_stop               = be_close,
5325         .ndo_start_xmit         = be_xmit,
5326         .ndo_set_rx_mode        = be_set_rx_mode,
5327         .ndo_set_mac_address    = be_mac_addr_set,
5328         .ndo_change_mtu         = be_change_mtu,
5329         .ndo_get_stats64        = be_get_stats64,
5330         .ndo_validate_addr      = eth_validate_addr,
5331         .ndo_vlan_rx_add_vid    = be_vlan_add_vid,
5332         .ndo_vlan_rx_kill_vid   = be_vlan_rem_vid,
5333         .ndo_set_vf_mac         = be_set_vf_mac,
5334         .ndo_set_vf_vlan        = be_set_vf_vlan,
5335         .ndo_set_vf_rate        = be_set_vf_tx_rate,
5336         .ndo_get_vf_config      = be_get_vf_config,
5337         .ndo_set_vf_link_state  = be_set_vf_link_state,
5338         .ndo_set_vf_spoofchk    = be_set_vf_spoofchk,
5339 #ifdef CONFIG_NET_POLL_CONTROLLER
5340         .ndo_poll_controller    = be_netpoll,
5341 #endif
5342         .ndo_bridge_setlink     = be_ndo_bridge_setlink,
5343         .ndo_bridge_getlink     = be_ndo_bridge_getlink,
5344 #ifdef CONFIG_NET_RX_BUSY_POLL
5345         .ndo_busy_poll          = be_busy_poll,
5346 #endif
5347 #ifdef CONFIG_BE2NET_VXLAN
5348         .ndo_add_vxlan_port     = be_add_vxlan_port,
5349         .ndo_del_vxlan_port     = be_del_vxlan_port,
5350         .ndo_features_check     = be_features_check,
5351 #endif
5352         .ndo_get_phys_port_id   = be_get_phys_port_id,
5353 };
5354
5355 static void be_netdev_init(struct net_device *netdev)
5356 {
5357         struct be_adapter *adapter = netdev_priv(netdev);
5358
5359         netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5360                 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
5361                 NETIF_F_HW_VLAN_CTAG_TX;
5362         if (be_multi_rxq(adapter))
5363                 netdev->hw_features |= NETIF_F_RXHASH;
5364
5365         netdev->features |= netdev->hw_features |
5366                 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
5367
5368         netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5369                 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
5370
5371         netdev->priv_flags |= IFF_UNICAST_FLT;
5372
5373         netdev->flags |= IFF_MULTICAST;
5374
5375         netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
5376
5377         netdev->netdev_ops = &be_netdev_ops;
5378
5379         netdev->ethtool_ops = &be_ethtool_ops;
5380 }
5381
5382 static void be_cleanup(struct be_adapter *adapter)
5383 {
5384         struct net_device *netdev = adapter->netdev;
5385
5386         rtnl_lock();
5387         netif_device_detach(netdev);
5388         if (netif_running(netdev))
5389                 be_close(netdev);
5390         rtnl_unlock();
5391
5392         be_clear(adapter);
5393 }
5394
5395 static int be_resume(struct be_adapter *adapter)
5396 {
5397         struct net_device *netdev = adapter->netdev;
5398         int status;
5399
5400         status = be_setup(adapter);
5401         if (status)
5402                 return status;
5403
5404         if (netif_running(netdev)) {
5405                 status = be_open(netdev);
5406                 if (status)
5407                         return status;
5408         }
5409
5410         netif_device_attach(netdev);
5411
5412         return 0;
5413 }
5414
5415 static int be_err_recover(struct be_adapter *adapter)
5416 {
5417         struct device *dev = &adapter->pdev->dev;
5418         int status;
5419
5420         status = be_resume(adapter);
5421         if (status)
5422                 goto err;
5423
5424         dev_info(dev, "Adapter recovery successful\n");
5425         return 0;
5426 err:
5427         if (be_physfn(adapter))
5428                 dev_err(dev, "Adapter recovery failed\n");
5429         else
5430                 dev_err(dev, "Re-trying adapter recovery\n");
5431
5432         return status;
5433 }
5434
5435 static void be_err_detection_task(struct work_struct *work)
5436 {
5437         struct be_adapter *adapter =
5438                                 container_of(work, struct be_adapter,
5439                                              be_err_detection_work.work);
5440         int status = 0;
5441
5442         be_detect_error(adapter);
5443
5444         if (be_check_error(adapter, BE_ERROR_HW)) {
5445                 be_cleanup(adapter);
5446
5447                 /* As of now error recovery support is in Lancer only */
5448                 if (lancer_chip(adapter))
5449                         status = be_err_recover(adapter);
5450         }
5451
5452         /* Always attempt recovery on VFs */
5453         if (!status || be_virtfn(adapter))
5454                 be_schedule_err_detection(adapter);
5455 }
5456
5457 static void be_log_sfp_info(struct be_adapter *adapter)
5458 {
5459         int status;
5460
5461         status = be_cmd_query_sfp_info(adapter);
5462         if (!status) {
5463                 dev_err(&adapter->pdev->dev,
5464                         "Unqualified SFP+ detected on %c from %s part no: %s",
5465                         adapter->port_name, adapter->phy.vendor_name,
5466                         adapter->phy.vendor_pn);
5467         }
5468         adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP;
5469 }
5470
5471 static void be_worker(struct work_struct *work)
5472 {
5473         struct be_adapter *adapter =
5474                 container_of(work, struct be_adapter, work.work);
5475         struct be_rx_obj *rxo;
5476         int i;
5477
5478         /* when interrupts are not yet enabled, just reap any pending
5479          * mcc completions
5480          */
5481         if (!netif_running(adapter->netdev)) {
5482                 local_bh_disable();
5483                 be_process_mcc(adapter);
5484                 local_bh_enable();
5485                 goto reschedule;
5486         }
5487
5488         if (!adapter->stats_cmd_sent) {
5489                 if (lancer_chip(adapter))
5490                         lancer_cmd_get_pport_stats(adapter,
5491                                                    &adapter->stats_cmd);
5492                 else
5493                         be_cmd_get_stats(adapter, &adapter->stats_cmd);
5494         }
5495
5496         if (be_physfn(adapter) &&
5497             MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
5498                 be_cmd_get_die_temperature(adapter);
5499
5500         for_all_rx_queues(adapter, rxo, i) {
5501                 /* Replenish RX-queues starved due to memory
5502                  * allocation failures.
5503                  */
5504                 if (rxo->rx_post_starved)
5505                         be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST);
5506         }
5507
5508         /* EQ-delay update for Skyhawk is done while notifying EQ */
5509         if (!skyhawk_chip(adapter))
5510                 be_eqd_update(adapter, false);
5511
5512         if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP)
5513                 be_log_sfp_info(adapter);
5514
5515 reschedule:
5516         adapter->work_counter++;
5517         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
5518 }
5519
5520 static void be_unmap_pci_bars(struct be_adapter *adapter)
5521 {
5522         if (adapter->csr)
5523                 pci_iounmap(adapter->pdev, adapter->csr);
5524         if (adapter->db)
5525                 pci_iounmap(adapter->pdev, adapter->db);
5526 }
5527
5528 static int db_bar(struct be_adapter *adapter)
5529 {
5530         if (lancer_chip(adapter) || be_virtfn(adapter))
5531                 return 0;
5532         else
5533                 return 4;
5534 }
5535
5536 static int be_roce_map_pci_bars(struct be_adapter *adapter)
5537 {
5538         if (skyhawk_chip(adapter)) {
5539                 adapter->roce_db.size = 4096;
5540                 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
5541                                                               db_bar(adapter));
5542                 adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
5543                                                                db_bar(adapter));
5544         }
5545         return 0;
5546 }
5547
5548 static int be_map_pci_bars(struct be_adapter *adapter)
5549 {
5550         struct pci_dev *pdev = adapter->pdev;
5551         u8 __iomem *addr;
5552         u32 sli_intf;
5553
5554         pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
5555         adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
5556                                 SLI_INTF_FAMILY_SHIFT;
5557         adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
5558
5559         if (BEx_chip(adapter) && be_physfn(adapter)) {
5560                 adapter->csr = pci_iomap(pdev, 2, 0);
5561                 if (!adapter->csr)
5562                         return -ENOMEM;
5563         }
5564
5565         addr = pci_iomap(pdev, db_bar(adapter), 0);
5566         if (!addr)
5567                 goto pci_map_err;
5568         adapter->db = addr;
5569
5570         if (skyhawk_chip(adapter) || BEx_chip(adapter)) {
5571                 if (be_physfn(adapter)) {
5572                         /* PCICFG is the 2nd BAR in BE2 */
5573                         addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0);
5574                         if (!addr)
5575                                 goto pci_map_err;
5576                         adapter->pcicfg = addr;
5577                 } else {
5578                         adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
5579                 }
5580         }
5581
5582         be_roce_map_pci_bars(adapter);
5583         return 0;
5584
5585 pci_map_err:
5586         dev_err(&pdev->dev, "Error in mapping PCI BARs\n");
5587         be_unmap_pci_bars(adapter);
5588         return -ENOMEM;
5589 }
5590
5591 static void be_drv_cleanup(struct be_adapter *adapter)
5592 {
5593         struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
5594         struct device *dev = &adapter->pdev->dev;
5595
5596         if (mem->va)
5597                 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5598
5599         mem = &adapter->rx_filter;
5600         if (mem->va)
5601                 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5602
5603         mem = &adapter->stats_cmd;
5604         if (mem->va)
5605                 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5606 }
5607
5608 /* Allocate and initialize various fields in be_adapter struct */
5609 static int be_drv_init(struct be_adapter *adapter)
5610 {
5611         struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
5612         struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
5613         struct be_dma_mem *rx_filter = &adapter->rx_filter;
5614         struct be_dma_mem *stats_cmd = &adapter->stats_cmd;
5615         struct device *dev = &adapter->pdev->dev;
5616         int status = 0;
5617
5618         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
5619         mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
5620                                                  &mbox_mem_alloc->dma,
5621                                                  GFP_KERNEL);
5622         if (!mbox_mem_alloc->va)
5623                 return -ENOMEM;
5624
5625         mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
5626         mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
5627         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
5628
5629         rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
5630         rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
5631                                             &rx_filter->dma, GFP_KERNEL);
5632         if (!rx_filter->va) {
5633                 status = -ENOMEM;
5634                 goto free_mbox;
5635         }
5636
5637         if (lancer_chip(adapter))
5638                 stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
5639         else if (BE2_chip(adapter))
5640                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
5641         else if (BE3_chip(adapter))
5642                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
5643         else
5644                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
5645         stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
5646                                             &stats_cmd->dma, GFP_KERNEL);
5647         if (!stats_cmd->va) {
5648                 status = -ENOMEM;
5649                 goto free_rx_filter;
5650         }
5651
5652         mutex_init(&adapter->mbox_lock);
5653         spin_lock_init(&adapter->mcc_lock);
5654         spin_lock_init(&adapter->mcc_cq_lock);
5655         init_completion(&adapter->et_cmd_compl);
5656
5657         pci_save_state(adapter->pdev);
5658
5659         INIT_DELAYED_WORK(&adapter->work, be_worker);
5660         INIT_DELAYED_WORK(&adapter->be_err_detection_work,
5661                           be_err_detection_task);
5662
5663         adapter->rx_fc = true;
5664         adapter->tx_fc = true;
5665
5666         /* Must be a power of 2 or else MODULO will BUG_ON */
5667         adapter->be_get_temp_freq = 64;
5668
5669         return 0;
5670
5671 free_rx_filter:
5672         dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma);
5673 free_mbox:
5674         dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va,
5675                           mbox_mem_alloc->dma);
5676         return status;
5677 }
5678
5679 static void be_remove(struct pci_dev *pdev)
5680 {
5681         struct be_adapter *adapter = pci_get_drvdata(pdev);
5682
5683         if (!adapter)
5684                 return;
5685
5686         be_roce_dev_remove(adapter);
5687         be_intr_set(adapter, false);
5688
5689         be_cancel_err_detection(adapter);
5690
5691         unregister_netdev(adapter->netdev);
5692
5693         be_clear(adapter);
5694
5695         /* tell fw we're done with firing cmds */
5696         be_cmd_fw_clean(adapter);
5697
5698         be_unmap_pci_bars(adapter);
5699         be_drv_cleanup(adapter);
5700
5701         pci_disable_pcie_error_reporting(pdev);
5702
5703         pci_release_regions(pdev);
5704         pci_disable_device(pdev);
5705
5706         free_netdev(adapter->netdev);
5707 }
5708
5709 static ssize_t be_hwmon_show_temp(struct device *dev,
5710                                   struct device_attribute *dev_attr,
5711                                   char *buf)
5712 {
5713         struct be_adapter *adapter = dev_get_drvdata(dev);
5714
5715         /* Unit: millidegree Celsius */
5716         if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP)
5717                 return -EIO;
5718         else
5719                 return sprintf(buf, "%u\n",
5720                                adapter->hwmon_info.be_on_die_temp * 1000);
5721 }
5722
5723 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
5724                           be_hwmon_show_temp, NULL, 1);
5725
5726 static struct attribute *be_hwmon_attrs[] = {
5727         &sensor_dev_attr_temp1_input.dev_attr.attr,
5728         NULL
5729 };
5730
5731 ATTRIBUTE_GROUPS(be_hwmon);
5732
5733 static char *mc_name(struct be_adapter *adapter)
5734 {
5735         char *str = ""; /* default */
5736
5737         switch (adapter->mc_type) {
5738         case UMC:
5739                 str = "UMC";
5740                 break;
5741         case FLEX10:
5742                 str = "FLEX10";
5743                 break;
5744         case vNIC1:
5745                 str = "vNIC-1";
5746                 break;
5747         case nPAR:
5748                 str = "nPAR";
5749                 break;
5750         case UFP:
5751                 str = "UFP";
5752                 break;
5753         case vNIC2:
5754                 str = "vNIC-2";
5755                 break;
5756         default:
5757                 str = "";
5758         }
5759
5760         return str;
5761 }
5762
5763 static inline char *func_name(struct be_adapter *adapter)
5764 {
5765         return be_physfn(adapter) ? "PF" : "VF";
5766 }
5767
5768 static inline char *nic_name(struct pci_dev *pdev)
5769 {
5770         switch (pdev->device) {
5771         case OC_DEVICE_ID1:
5772                 return OC_NAME;
5773         case OC_DEVICE_ID2:
5774                 return OC_NAME_BE;
5775         case OC_DEVICE_ID3:
5776         case OC_DEVICE_ID4:
5777                 return OC_NAME_LANCER;
5778         case BE_DEVICE_ID2:
5779                 return BE3_NAME;
5780         case OC_DEVICE_ID5:
5781         case OC_DEVICE_ID6:
5782                 return OC_NAME_SH;
5783         default:
5784                 return BE_NAME;
5785         }
5786 }
5787
5788 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
5789 {
5790         struct be_adapter *adapter;
5791         struct net_device *netdev;
5792         int status = 0;
5793
5794         dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER);
5795
5796         status = pci_enable_device(pdev);
5797         if (status)
5798                 goto do_none;
5799
5800         status = pci_request_regions(pdev, DRV_NAME);
5801         if (status)
5802                 goto disable_dev;
5803         pci_set_master(pdev);
5804
5805         netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
5806         if (!netdev) {
5807                 status = -ENOMEM;
5808                 goto rel_reg;
5809         }
5810         adapter = netdev_priv(netdev);
5811         adapter->pdev = pdev;
5812         pci_set_drvdata(pdev, adapter);
5813         adapter->netdev = netdev;
5814         SET_NETDEV_DEV(netdev, &pdev->dev);
5815
5816         status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
5817         if (!status) {
5818                 netdev->features |= NETIF_F_HIGHDMA;
5819         } else {
5820                 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
5821                 if (status) {
5822                         dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
5823                         goto free_netdev;
5824                 }
5825         }
5826
5827         status = pci_enable_pcie_error_reporting(pdev);
5828         if (!status)
5829                 dev_info(&pdev->dev, "PCIe error reporting enabled\n");
5830
5831         status = be_map_pci_bars(adapter);
5832         if (status)
5833                 goto free_netdev;
5834
5835         status = be_drv_init(adapter);
5836         if (status)
5837                 goto unmap_bars;
5838
5839         status = be_setup(adapter);
5840         if (status)
5841                 goto drv_cleanup;
5842
5843         be_netdev_init(netdev);
5844         status = register_netdev(netdev);
5845         if (status != 0)
5846                 goto unsetup;
5847
5848         be_roce_dev_add(adapter);
5849
5850         be_schedule_err_detection(adapter);
5851
5852         /* On Die temperature not supported for VF. */
5853         if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) {
5854                 adapter->hwmon_info.hwmon_dev =
5855                         devm_hwmon_device_register_with_groups(&pdev->dev,
5856                                                                DRV_NAME,
5857                                                                adapter,
5858                                                                be_hwmon_groups);
5859                 adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP;
5860         }
5861
5862         dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
5863                  func_name(adapter), mc_name(adapter), adapter->port_name);
5864
5865         return 0;
5866
5867 unsetup:
5868         be_clear(adapter);
5869 drv_cleanup:
5870         be_drv_cleanup(adapter);
5871 unmap_bars:
5872         be_unmap_pci_bars(adapter);
5873 free_netdev:
5874         free_netdev(netdev);
5875 rel_reg:
5876         pci_release_regions(pdev);
5877 disable_dev:
5878         pci_disable_device(pdev);
5879 do_none:
5880         dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
5881         return status;
5882 }
5883
5884 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
5885 {
5886         struct be_adapter *adapter = pci_get_drvdata(pdev);
5887
5888         if (adapter->wol_en)
5889                 be_setup_wol(adapter, true);
5890
5891         be_intr_set(adapter, false);
5892         be_cancel_err_detection(adapter);
5893
5894         be_cleanup(adapter);
5895
5896         pci_save_state(pdev);
5897         pci_disable_device(pdev);
5898         pci_set_power_state(pdev, pci_choose_state(pdev, state));
5899         return 0;
5900 }
5901
5902 static int be_pci_resume(struct pci_dev *pdev)
5903 {
5904         struct be_adapter *adapter = pci_get_drvdata(pdev);
5905         int status = 0;
5906
5907         status = pci_enable_device(pdev);
5908         if (status)
5909                 return status;
5910
5911         pci_restore_state(pdev);
5912
5913         status = be_resume(adapter);
5914         if (status)
5915                 return status;
5916
5917         be_schedule_err_detection(adapter);
5918
5919         if (adapter->wol_en)
5920                 be_setup_wol(adapter, false);
5921
5922         return 0;
5923 }
5924
5925 /*
5926  * An FLR will stop BE from DMAing any data.
5927  */
5928 static void be_shutdown(struct pci_dev *pdev)
5929 {
5930         struct be_adapter *adapter = pci_get_drvdata(pdev);
5931
5932         if (!adapter)
5933                 return;
5934
5935         be_roce_dev_shutdown(adapter);
5936         cancel_delayed_work_sync(&adapter->work);
5937         be_cancel_err_detection(adapter);
5938
5939         netif_device_detach(adapter->netdev);
5940
5941         be_cmd_reset_function(adapter);
5942
5943         pci_disable_device(pdev);
5944 }
5945
5946 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
5947                                             pci_channel_state_t state)
5948 {
5949         struct be_adapter *adapter = pci_get_drvdata(pdev);
5950
5951         dev_err(&adapter->pdev->dev, "EEH error detected\n");
5952
5953         if (!be_check_error(adapter, BE_ERROR_EEH)) {
5954                 be_set_error(adapter, BE_ERROR_EEH);
5955
5956                 be_cancel_err_detection(adapter);
5957
5958                 be_cleanup(adapter);
5959         }
5960
5961         if (state == pci_channel_io_perm_failure)
5962                 return PCI_ERS_RESULT_DISCONNECT;
5963
5964         pci_disable_device(pdev);
5965
5966         /* The error could cause the FW to trigger a flash debug dump.
5967          * Resetting the card while flash dump is in progress
5968          * can cause it not to recover; wait for it to finish.
5969          * Wait only for first function as it is needed only once per
5970          * adapter.
5971          */
5972         if (pdev->devfn == 0)
5973                 ssleep(30);
5974
5975         return PCI_ERS_RESULT_NEED_RESET;
5976 }
5977
5978 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
5979 {
5980         struct be_adapter *adapter = pci_get_drvdata(pdev);
5981         int status;
5982
5983         dev_info(&adapter->pdev->dev, "EEH reset\n");
5984
5985         status = pci_enable_device(pdev);
5986         if (status)
5987                 return PCI_ERS_RESULT_DISCONNECT;
5988
5989         pci_set_master(pdev);
5990         pci_restore_state(pdev);
5991
5992         /* Check if card is ok and fw is ready */
5993         dev_info(&adapter->pdev->dev,
5994                  "Waiting for FW to be ready after EEH reset\n");
5995         status = be_fw_wait_ready(adapter);
5996         if (status)
5997                 return PCI_ERS_RESULT_DISCONNECT;
5998
5999         pci_cleanup_aer_uncorrect_error_status(pdev);
6000         be_clear_error(adapter, BE_CLEAR_ALL);
6001         return PCI_ERS_RESULT_RECOVERED;
6002 }
6003
6004 static void be_eeh_resume(struct pci_dev *pdev)
6005 {
6006         int status = 0;
6007         struct be_adapter *adapter = pci_get_drvdata(pdev);
6008
6009         dev_info(&adapter->pdev->dev, "EEH resume\n");
6010
6011         pci_save_state(pdev);
6012
6013         status = be_resume(adapter);
6014         if (status)
6015                 goto err;
6016
6017         be_schedule_err_detection(adapter);
6018         return;
6019 err:
6020         dev_err(&adapter->pdev->dev, "EEH resume failed\n");
6021 }
6022
6023 static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
6024 {
6025         struct be_adapter *adapter = pci_get_drvdata(pdev);
6026         u16 num_vf_qs;
6027         int status;
6028
6029         if (!num_vfs)
6030                 be_vf_clear(adapter);
6031
6032         adapter->num_vfs = num_vfs;
6033
6034         if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) {
6035                 dev_warn(&pdev->dev,
6036                          "Cannot disable VFs while they are assigned\n");
6037                 return -EBUSY;
6038         }
6039
6040         /* When the HW is in SRIOV capable configuration, the PF-pool resources
6041          * are equally distributed across the max-number of VFs. The user may
6042          * request only a subset of the max-vfs to be enabled.
6043          * Based on num_vfs, redistribute the resources across num_vfs so that
6044          * each VF will have access to more number of resources.
6045          * This facility is not available in BE3 FW.
6046          * Also, this is done by FW in Lancer chip.
6047          */
6048         if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) {
6049                 num_vf_qs = be_calculate_vf_qs(adapter, adapter->num_vfs);
6050                 status = be_cmd_set_sriov_config(adapter, adapter->pool_res,
6051                                                  adapter->num_vfs, num_vf_qs);
6052                 if (status)
6053                         dev_err(&pdev->dev,
6054                                 "Failed to optimize SR-IOV resources\n");
6055         }
6056
6057         status = be_get_resources(adapter);
6058         if (status)
6059                 return be_cmd_status(status);
6060
6061         /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
6062         rtnl_lock();
6063         status = be_update_queues(adapter);
6064         rtnl_unlock();
6065         if (status)
6066                 return be_cmd_status(status);
6067
6068         if (adapter->num_vfs)
6069                 status = be_vf_setup(adapter);
6070
6071         if (!status)
6072                 return adapter->num_vfs;
6073
6074         return 0;
6075 }
6076
6077 static const struct pci_error_handlers be_eeh_handlers = {
6078         .error_detected = be_eeh_err_detected,
6079         .slot_reset = be_eeh_reset,
6080         .resume = be_eeh_resume,
6081 };
6082
6083 static struct pci_driver be_driver = {
6084         .name = DRV_NAME,
6085         .id_table = be_dev_ids,
6086         .probe = be_probe,
6087         .remove = be_remove,
6088         .suspend = be_suspend,
6089         .resume = be_pci_resume,
6090         .shutdown = be_shutdown,
6091         .sriov_configure = be_pci_sriov_configure,
6092         .err_handler = &be_eeh_handlers
6093 };
6094
6095 static int __init be_init_module(void)
6096 {
6097         if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
6098             rx_frag_size != 2048) {
6099                 printk(KERN_WARNING DRV_NAME
6100                         " : Module param rx_frag_size must be 2048/4096/8192."
6101                         " Using 2048\n");
6102                 rx_frag_size = 2048;
6103         }
6104
6105         if (num_vfs > 0) {
6106                 pr_info(DRV_NAME " : Module param num_vfs is obsolete.");
6107                 pr_info(DRV_NAME " : Use sysfs method to enable VFs\n");
6108         }
6109
6110         return pci_register_driver(&be_driver);
6111 }
6112 module_init(be_init_module);
6113
6114 static void __exit be_exit_module(void)
6115 {
6116         pci_unregister_driver(&be_driver);
6117 }
6118 module_exit(be_exit_module);