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