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