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