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

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