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

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