sys/dev/bxe/bxe.c

   1 /*-
   2  * Copyright (c) 2007-2014 QLogic Corporation. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
  15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  24  * THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #define BXE_DRIVER_VERSION "1.78.81"
  31
  32 #include "bxe.h"
  33 #include "ecore_sp.h"
  34 #include "ecore_init.h"
  35 #include "ecore_init_ops.h"
  36
  37 #include "57710_int_offsets.h"
  38 #include "57711_int_offsets.h"
  39 #include "57712_int_offsets.h"
  40
  41 /*
  42  * CTLTYPE_U64 and sysctl_handle_64 were added in r217616. Define these
  43  * explicitly here for older kernels that don't include this changeset.
  44  */
  45 #ifndef CTLTYPE_U64
  46 #define CTLTYPE_U64      CTLTYPE_QUAD
  47 #define sysctl_handle_64 sysctl_handle_quad
  48 #endif
  49
  50 /*
  51  * CSUM_TCP_IPV6 and CSUM_UDP_IPV6 were added in r236170. Define these
  52  * here as zero(0) for older kernels that don't include this changeset
  53  * thereby masking the functionality.
  54  */
  55 #ifndef CSUM_TCP_IPV6
  56 #define CSUM_TCP_IPV6 0
  57 #define CSUM_UDP_IPV6 0
  58 #endif
  59
  60 /*
  61  * pci_find_cap was added in r219865. Re-define this at pci_find_extcap
  62  * for older kernels that don't include this changeset.
  63  */
  64 #if __FreeBSD_version < 900035
  65 #define pci_find_cap pci_find_extcap
  66 #endif
  67
  68 #define BXE_DEF_SB_ATT_IDX 0x0001
  69 #define BXE_DEF_SB_IDX     0x0002
  70
  71 /*
  72  * FLR Support - bxe_pf_flr_clnup() is called during nic_load in the per
  73  * function HW initialization.
  74  */
  75 #define FLR_WAIT_USEC     10000 /* 10 msecs */
  76 #define FLR_WAIT_INTERVAL 50    /* usecs */
  77 #define FLR_POLL_CNT      (FLR_WAIT_USEC / FLR_WAIT_INTERVAL) /* 200 */
  78
  79 struct pbf_pN_buf_regs {
  80     int pN;
  81     uint32_t init_crd;
  82     uint32_t crd;
  83     uint32_t crd_freed;
  84 };
  85
  86 struct pbf_pN_cmd_regs {
  87     int pN;
  88     uint32_t lines_occup;
  89     uint32_t lines_freed;
  90 };
  91
  92 /*
  93  * PCI Device ID Table used by bxe_probe().
  94  */
  95 #define BXE_DEVDESC_MAX 64
  96 static struct bxe_device_type bxe_devs[] = {
  97     {
  98         BRCM_VENDORID,
  99         CHIP_NUM_57710,
 100         PCI_ANY_ID, PCI_ANY_ID,
 101         "QLogic NetXtreme II BCM57710 10GbE"
 102     },
 103     {
 104         BRCM_VENDORID,
 105         CHIP_NUM_57711,
 106         PCI_ANY_ID, PCI_ANY_ID,
 107         "QLogic NetXtreme II BCM57711 10GbE"
 108     },
 109     {
 110         BRCM_VENDORID,
 111         CHIP_NUM_57711E,
 112         PCI_ANY_ID, PCI_ANY_ID,
 113         "QLogic NetXtreme II BCM57711E 10GbE"
 114     },
 115     {
 116         BRCM_VENDORID,
 117         CHIP_NUM_57712,
 118         PCI_ANY_ID, PCI_ANY_ID,
 119         "QLogic NetXtreme II BCM57712 10GbE"
 120     },
 121     {
 122         BRCM_VENDORID,
 123         CHIP_NUM_57712_MF,
 124         PCI_ANY_ID, PCI_ANY_ID,
 125         "QLogic NetXtreme II BCM57712 MF 10GbE"
 126     },
 127     {
 128         BRCM_VENDORID,
 129         CHIP_NUM_57800,
 130         PCI_ANY_ID, PCI_ANY_ID,
 131         "QLogic NetXtreme II BCM57800 10GbE"
 132     },
 133     {
 134         BRCM_VENDORID,
 135         CHIP_NUM_57800_MF,
 136         PCI_ANY_ID, PCI_ANY_ID,
 137         "QLogic NetXtreme II BCM57800 MF 10GbE"
 138     },
 139     {
 140         BRCM_VENDORID,
 141         CHIP_NUM_57810,
 142         PCI_ANY_ID, PCI_ANY_ID,
 143         "QLogic NetXtreme II BCM57810 10GbE"
 144     },
 145     {
 146         BRCM_VENDORID,
 147         CHIP_NUM_57810_MF,
 148         PCI_ANY_ID, PCI_ANY_ID,
 149         "QLogic NetXtreme II BCM57810 MF 10GbE"
 150     },
 151     {
 152         BRCM_VENDORID,
 153         CHIP_NUM_57811,
 154         PCI_ANY_ID, PCI_ANY_ID,
 155         "QLogic NetXtreme II BCM57811 10GbE"
 156     },
 157     {
 158         BRCM_VENDORID,
 159         CHIP_NUM_57811_MF,
 160         PCI_ANY_ID, PCI_ANY_ID,
 161         "QLogic NetXtreme II BCM57811 MF 10GbE"
 162     },
 163     {
 164         BRCM_VENDORID,
 165         CHIP_NUM_57840_4_10,
 166         PCI_ANY_ID, PCI_ANY_ID,
 167         "QLogic NetXtreme II BCM57840 4x10GbE"
 168     },
 169     {
 170         BRCM_VENDORID,
 171         CHIP_NUM_57840_MF,
 172         PCI_ANY_ID, PCI_ANY_ID,
 173         "QLogic NetXtreme II BCM57840 MF 10GbE"
 174     },
 175     {
 176         0, 0, 0, 0, NULL
 177     }
 178 };
 179
 180 MALLOC_DECLARE(M_BXE_ILT);
 181 MALLOC_DEFINE(M_BXE_ILT, "bxe_ilt", "bxe ILT pointer");
 182
 183 /*
 184  * FreeBSD device entry points.
 185  */
 186 static int bxe_probe(device_t);
 187 static int bxe_attach(device_t);
 188 static int bxe_detach(device_t);
 189 static int bxe_shutdown(device_t);
 190
 191 /*
 192  * FreeBSD KLD module/device interface event handler method.
 193  */
 194 static device_method_t bxe_methods[] = {
 195     /* Device interface (device_if.h) */
 196     DEVMETHOD(device_probe,     bxe_probe),
 197     DEVMETHOD(device_attach,    bxe_attach),
 198     DEVMETHOD(device_detach,    bxe_detach),
 199     DEVMETHOD(device_shutdown,  bxe_shutdown),
 200     /* Bus interface (bus_if.h) */
 201     DEVMETHOD(bus_print_child,  bus_generic_print_child),
 202     DEVMETHOD(bus_driver_added, bus_generic_driver_added),
 203     KOBJMETHOD_END
 204 };
 205
 206 /*
 207  * FreeBSD KLD Module data declaration
 208  */
 209 static driver_t bxe_driver = {
 210     "bxe",                   /* module name */
 211     bxe_methods,             /* event handler */
 212     sizeof(struct bxe_softc) /* extra data */
 213 };
 214
 215 /*
 216  * FreeBSD dev class is needed to manage dev instances and
 217  * to associate with a bus type
 218  */
 219 static devclass_t bxe_devclass;
 220
 221 MODULE_DEPEND(bxe, pci, 1, 1, 1);
 222 MODULE_DEPEND(bxe, ether, 1, 1, 1);
 223 DRIVER_MODULE(bxe, pci, bxe_driver, bxe_devclass, 0, 0);
 224
 225 /* resources needed for unloading a previously loaded device */
 226
 227 #define BXE_PREV_WAIT_NEEDED 1
 228 struct mtx bxe_prev_mtx;
 229 MTX_SYSINIT(bxe_prev_mtx, &bxe_prev_mtx, "bxe_prev_lock", MTX_DEF);
 230 struct bxe_prev_list_node {
 231     LIST_ENTRY(bxe_prev_list_node) node;
 232     uint8_t bus;
 233     uint8_t slot;
 234     uint8_t path;
 235     uint8_t aer; /* XXX automatic error recovery */
 236     uint8_t undi;
 237 };
 238 static LIST_HEAD(, bxe_prev_list_node) bxe_prev_list = LIST_HEAD_INITIALIZER(bxe_prev_list);
 239
 240 static int load_count[2][3] = { {0} }; /* per-path: 0-common, 1-port0, 2-port1 */
 241
 242 /* Tunable device values... */
 243
 244 SYSCTL_NODE(_hw, OID_AUTO, bxe, CTLFLAG_RD, 0, "bxe driver parameters");
 245
 246 /* Debug */
 247 unsigned long bxe_debug = 0;
 248 TUNABLE_ULONG("hw.bxe.debug", &bxe_debug);
 249 SYSCTL_ULONG(_hw_bxe, OID_AUTO, debug, (CTLFLAG_RDTUN),
 250              &bxe_debug, 0, "Debug logging mode");
 251
 252 /* Interrupt Mode: 0 (IRQ), 1 (MSI/IRQ), and 2 (MSI-X/MSI/IRQ) */
 253 static int bxe_interrupt_mode = INTR_MODE_MSIX;
 254 TUNABLE_INT("hw.bxe.interrupt_mode", &bxe_interrupt_mode);
 255 SYSCTL_INT(_hw_bxe, OID_AUTO, interrupt_mode, CTLFLAG_RDTUN,
 256            &bxe_interrupt_mode, 0, "Interrupt (MSI-X/MSI/INTx) mode");
 257
 258 /* Number of Queues: 0 (Auto) or 1 to 16 (fixed queue number) */
 259 static int bxe_queue_count = 4;
 260 TUNABLE_INT("hw.bxe.queue_count", &bxe_queue_count);
 261 SYSCTL_INT(_hw_bxe, OID_AUTO, queue_count, CTLFLAG_RDTUN,
 262            &bxe_queue_count, 0, "Multi-Queue queue count");
 263
 264 /* max number of buffers per queue (default RX_BD_USABLE) */
 265 static int bxe_max_rx_bufs = 0;
 266 TUNABLE_INT("hw.bxe.max_rx_bufs", &bxe_max_rx_bufs);
 267 SYSCTL_INT(_hw_bxe, OID_AUTO, max_rx_bufs, CTLFLAG_RDTUN,
 268            &bxe_max_rx_bufs, 0, "Maximum Number of Rx Buffers Per Queue");
 269
 270 /* Host interrupt coalescing RX tick timer (usecs) */
 271 static int bxe_hc_rx_ticks = 25;
 272 TUNABLE_INT("hw.bxe.hc_rx_ticks", &bxe_hc_rx_ticks);
 273 SYSCTL_INT(_hw_bxe, OID_AUTO, hc_rx_ticks, CTLFLAG_RDTUN,
 274            &bxe_hc_rx_ticks, 0, "Host Coalescing Rx ticks");
 275
 276 /* Host interrupt coalescing TX tick timer (usecs) */
 277 static int bxe_hc_tx_ticks = 50;
 278 TUNABLE_INT("hw.bxe.hc_tx_ticks", &bxe_hc_tx_ticks);
 279 SYSCTL_INT(_hw_bxe, OID_AUTO, hc_tx_ticks, CTLFLAG_RDTUN,
 280            &bxe_hc_tx_ticks, 0, "Host Coalescing Tx ticks");
 281
 282 /* Maximum number of Rx packets to process at a time */
 283 static int bxe_rx_budget = 0xffffffff;
 284 TUNABLE_INT("hw.bxe.rx_budget", &bxe_rx_budget);
 285 SYSCTL_INT(_hw_bxe, OID_AUTO, rx_budget, CTLFLAG_TUN,
 286            &bxe_rx_budget, 0, "Rx processing budget");
 287
 288 /* Maximum LRO aggregation size */
 289 static int bxe_max_aggregation_size = 0;
 290 TUNABLE_INT("hw.bxe.max_aggregation_size", &bxe_max_aggregation_size);
 291 SYSCTL_INT(_hw_bxe, OID_AUTO, max_aggregation_size, CTLFLAG_TUN,
 292            &bxe_max_aggregation_size, 0, "max aggregation size");
 293
 294 /* PCI MRRS: -1 (Auto), 0 (128B), 1 (256B), 2 (512B), 3 (1KB) */
 295 static int bxe_mrrs = -1;
 296 TUNABLE_INT("hw.bxe.mrrs", &bxe_mrrs);
 297 SYSCTL_INT(_hw_bxe, OID_AUTO, mrrs, CTLFLAG_RDTUN,
 298            &bxe_mrrs, 0, "PCIe maximum read request size");
 299
 300 /* AutoGrEEEn: 0 (hardware default), 1 (force on), 2 (force off) */
 301 static int bxe_autogreeen = 0;
 302 TUNABLE_INT("hw.bxe.autogreeen", &bxe_autogreeen);
 303 SYSCTL_INT(_hw_bxe, OID_AUTO, autogreeen, CTLFLAG_RDTUN,
 304            &bxe_autogreeen, 0, "AutoGrEEEn support");
 305
 306 /* 4-tuple RSS support for UDP: 0 (disabled), 1 (enabled) */
 307 static int bxe_udp_rss = 0;
 308 TUNABLE_INT("hw.bxe.udp_rss", &bxe_udp_rss);
 309 SYSCTL_INT(_hw_bxe, OID_AUTO, udp_rss, CTLFLAG_RDTUN,
 310            &bxe_udp_rss, 0, "UDP RSS support");
 311
 312
 313 #define STAT_NAME_LEN 32 /* no stat names below can be longer than this */
 314
 315 #define STATS_OFFSET32(stat_name)                   \
 316     (offsetof(struct bxe_eth_stats, stat_name) / 4)
 317
 318 #define Q_STATS_OFFSET32(stat_name)                   \
 319     (offsetof(struct bxe_eth_q_stats, stat_name) / 4)
 320
 321 static const struct {
 322     uint32_t offset;
 323     uint32_t size;
 324     uint32_t flags;
 325 #define STATS_FLAGS_PORT  1
 326 #define STATS_FLAGS_FUNC  2 /* MF only cares about function stats */
 327 #define STATS_FLAGS_BOTH  (STATS_FLAGS_FUNC | STATS_FLAGS_PORT)
 328     char string[STAT_NAME_LEN];
 329 } bxe_eth_stats_arr[] = {
 330     { STATS_OFFSET32(total_bytes_received_hi),
 331                 8, STATS_FLAGS_BOTH, "rx_bytes" },
 332     { STATS_OFFSET32(error_bytes_received_hi),
 333                 8, STATS_FLAGS_BOTH, "rx_error_bytes" },
 334     { STATS_OFFSET32(total_unicast_packets_received_hi),
 335                 8, STATS_FLAGS_BOTH, "rx_ucast_packets" },
 336     { STATS_OFFSET32(total_multicast_packets_received_hi),
 337                 8, STATS_FLAGS_BOTH, "rx_mcast_packets" },
 338     { STATS_OFFSET32(total_broadcast_packets_received_hi),
 339                 8, STATS_FLAGS_BOTH, "rx_bcast_packets" },
 340     { STATS_OFFSET32(rx_stat_dot3statsfcserrors_hi),
 341                 8, STATS_FLAGS_PORT, "rx_crc_errors" },
 342     { STATS_OFFSET32(rx_stat_dot3statsalignmenterrors_hi),
 343                 8, STATS_FLAGS_PORT, "rx_align_errors" },
 344     { STATS_OFFSET32(rx_stat_etherstatsundersizepkts_hi),
 345                 8, STATS_FLAGS_PORT, "rx_undersize_packets" },
 346     { STATS_OFFSET32(etherstatsoverrsizepkts_hi),
 347                 8, STATS_FLAGS_PORT, "rx_oversize_packets" },
 348     { STATS_OFFSET32(rx_stat_etherstatsfragments_hi),
 349                 8, STATS_FLAGS_PORT, "rx_fragments" },
 350     { STATS_OFFSET32(rx_stat_etherstatsjabbers_hi),
 351                 8, STATS_FLAGS_PORT, "rx_jabbers" },
 352     { STATS_OFFSET32(no_buff_discard_hi),
 353                 8, STATS_FLAGS_BOTH, "rx_discards" },
 354     { STATS_OFFSET32(mac_filter_discard),
 355                 4, STATS_FLAGS_PORT, "rx_filtered_packets" },
 356     { STATS_OFFSET32(mf_tag_discard),
 357                 4, STATS_FLAGS_PORT, "rx_mf_tag_discard" },
 358     { STATS_OFFSET32(pfc_frames_received_hi),
 359                 8, STATS_FLAGS_PORT, "pfc_frames_received" },
 360     { STATS_OFFSET32(pfc_frames_sent_hi),
 361                 8, STATS_FLAGS_PORT, "pfc_frames_sent" },
 362     { STATS_OFFSET32(brb_drop_hi),
 363                 8, STATS_FLAGS_PORT, "rx_brb_discard" },
 364     { STATS_OFFSET32(brb_truncate_hi),
 365                 8, STATS_FLAGS_PORT, "rx_brb_truncate" },
 366     { STATS_OFFSET32(pause_frames_received_hi),
 367                 8, STATS_FLAGS_PORT, "rx_pause_frames" },
 368     { STATS_OFFSET32(rx_stat_maccontrolframesreceived_hi),
 369                 8, STATS_FLAGS_PORT, "rx_mac_ctrl_frames" },
 370     { STATS_OFFSET32(nig_timer_max),
 371                 4, STATS_FLAGS_PORT, "rx_constant_pause_events" },
 372     { STATS_OFFSET32(total_bytes_transmitted_hi),
 373                 8, STATS_FLAGS_BOTH, "tx_bytes" },
 374     { STATS_OFFSET32(tx_stat_ifhcoutbadoctets_hi),
 375                 8, STATS_FLAGS_PORT, "tx_error_bytes" },
 376     { STATS_OFFSET32(total_unicast_packets_transmitted_hi),
 377                 8, STATS_FLAGS_BOTH, "tx_ucast_packets" },
 378     { STATS_OFFSET32(total_multicast_packets_transmitted_hi),
 379                 8, STATS_FLAGS_BOTH, "tx_mcast_packets" },
 380     { STATS_OFFSET32(total_broadcast_packets_transmitted_hi),
 381                 8, STATS_FLAGS_BOTH, "tx_bcast_packets" },
 382     { STATS_OFFSET32(tx_stat_dot3statsinternalmactransmiterrors_hi),
 383                 8, STATS_FLAGS_PORT, "tx_mac_errors" },
 384     { STATS_OFFSET32(rx_stat_dot3statscarriersenseerrors_hi),
 385                 8, STATS_FLAGS_PORT, "tx_carrier_errors" },
 386     { STATS_OFFSET32(tx_stat_dot3statssinglecollisionframes_hi),
 387                 8, STATS_FLAGS_PORT, "tx_single_collisions" },
 388     { STATS_OFFSET32(tx_stat_dot3statsmultiplecollisionframes_hi),
 389                 8, STATS_FLAGS_PORT, "tx_multi_collisions" },
 390     { STATS_OFFSET32(tx_stat_dot3statsdeferredtransmissions_hi),
 391                 8, STATS_FLAGS_PORT, "tx_deferred" },
 392     { STATS_OFFSET32(tx_stat_dot3statsexcessivecollisions_hi),
 393                 8, STATS_FLAGS_PORT, "tx_excess_collisions" },
 394     { STATS_OFFSET32(tx_stat_dot3statslatecollisions_hi),
 395                 8, STATS_FLAGS_PORT, "tx_late_collisions" },
 396     { STATS_OFFSET32(tx_stat_etherstatscollisions_hi),
 397                 8, STATS_FLAGS_PORT, "tx_total_collisions" },
 398     { STATS_OFFSET32(tx_stat_etherstatspkts64octets_hi),
 399                 8, STATS_FLAGS_PORT, "tx_64_byte_packets" },
 400     { STATS_OFFSET32(tx_stat_etherstatspkts65octetsto127octets_hi),
 401                 8, STATS_FLAGS_PORT, "tx_65_to_127_byte_packets" },
 402     { STATS_OFFSET32(tx_stat_etherstatspkts128octetsto255octets_hi),
 403                 8, STATS_FLAGS_PORT, "tx_128_to_255_byte_packets" },
 404     { STATS_OFFSET32(tx_stat_etherstatspkts256octetsto511octets_hi),
 405                 8, STATS_FLAGS_PORT, "tx_256_to_511_byte_packets" },
 406     { STATS_OFFSET32(tx_stat_etherstatspkts512octetsto1023octets_hi),
 407                 8, STATS_FLAGS_PORT, "tx_512_to_1023_byte_packets" },
 408     { STATS_OFFSET32(etherstatspkts1024octetsto1522octets_hi),
 409                 8, STATS_FLAGS_PORT, "tx_1024_to_1522_byte_packets" },
 410     { STATS_OFFSET32(etherstatspktsover1522octets_hi),
 411                 8, STATS_FLAGS_PORT, "tx_1523_to_9022_byte_packets" },
 412     { STATS_OFFSET32(pause_frames_sent_hi),
 413                 8, STATS_FLAGS_PORT, "tx_pause_frames" },
 414     { STATS_OFFSET32(total_tpa_aggregations_hi),
 415                 8, STATS_FLAGS_FUNC, "tpa_aggregations" },
 416     { STATS_OFFSET32(total_tpa_aggregated_frames_hi),
 417                 8, STATS_FLAGS_FUNC, "tpa_aggregated_frames"},
 418     { STATS_OFFSET32(total_tpa_bytes_hi),
 419                 8, STATS_FLAGS_FUNC, "tpa_bytes"},
 420     { STATS_OFFSET32(eee_tx_lpi),
 421                 4, STATS_FLAGS_PORT, "eee_tx_lpi"},
 422     { STATS_OFFSET32(rx_calls),
 423                 4, STATS_FLAGS_FUNC, "rx_calls"},
 424     { STATS_OFFSET32(rx_pkts),
 425                 4, STATS_FLAGS_FUNC, "rx_pkts"},
 426     { STATS_OFFSET32(rx_tpa_pkts),
 427                 4, STATS_FLAGS_FUNC, "rx_tpa_pkts"},
 428     { STATS_OFFSET32(rx_erroneous_jumbo_sge_pkts),
 429                 4, STATS_FLAGS_FUNC, "rx_erroneous_jumbo_sge_pkts"},
 430     { STATS_OFFSET32(rx_bxe_service_rxsgl),
 431                 4, STATS_FLAGS_FUNC, "rx_bxe_service_rxsgl"},
 432     { STATS_OFFSET32(rx_jumbo_sge_pkts),
 433                 4, STATS_FLAGS_FUNC, "rx_jumbo_sge_pkts"},
 434     { STATS_OFFSET32(rx_soft_errors),
 435                 4, STATS_FLAGS_FUNC, "rx_soft_errors"},
 436     { STATS_OFFSET32(rx_hw_csum_errors),
 437                 4, STATS_FLAGS_FUNC, "rx_hw_csum_errors"},
 438     { STATS_OFFSET32(rx_ofld_frames_csum_ip),
 439                 4, STATS_FLAGS_FUNC, "rx_ofld_frames_csum_ip"},
 440     { STATS_OFFSET32(rx_ofld_frames_csum_tcp_udp),
 441                 4, STATS_FLAGS_FUNC, "rx_ofld_frames_csum_tcp_udp"},
 442     { STATS_OFFSET32(rx_budget_reached),
 443                 4, STATS_FLAGS_FUNC, "rx_budget_reached"},
 444     { STATS_OFFSET32(tx_pkts),
 445                 4, STATS_FLAGS_FUNC, "tx_pkts"},
 446     { STATS_OFFSET32(tx_soft_errors),
 447                 4, STATS_FLAGS_FUNC, "tx_soft_errors"},
 448     { STATS_OFFSET32(tx_ofld_frames_csum_ip),
 449                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_ip"},
 450     { STATS_OFFSET32(tx_ofld_frames_csum_tcp),
 451                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_tcp"},
 452     { STATS_OFFSET32(tx_ofld_frames_csum_udp),
 453                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_csum_udp"},
 454     { STATS_OFFSET32(tx_ofld_frames_lso),
 455                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_lso"},
 456     { STATS_OFFSET32(tx_ofld_frames_lso_hdr_splits),
 457                 4, STATS_FLAGS_FUNC, "tx_ofld_frames_lso_hdr_splits"},
 458     { STATS_OFFSET32(tx_encap_failures),
 459                 4, STATS_FLAGS_FUNC, "tx_encap_failures"},
 460     { STATS_OFFSET32(tx_hw_queue_full),
 461                 4, STATS_FLAGS_FUNC, "tx_hw_queue_full"},
 462     { STATS_OFFSET32(tx_hw_max_queue_depth),
 463                 4, STATS_FLAGS_FUNC, "tx_hw_max_queue_depth"},
 464     { STATS_OFFSET32(tx_dma_mapping_failure),
 465                 4, STATS_FLAGS_FUNC, "tx_dma_mapping_failure"},
 466     { STATS_OFFSET32(tx_max_drbr_queue_depth),
 467                 4, STATS_FLAGS_FUNC, "tx_max_drbr_queue_depth"},
 468     { STATS_OFFSET32(tx_window_violation_std),
 469                 4, STATS_FLAGS_FUNC, "tx_window_violation_std"},
 470     { STATS_OFFSET32(tx_window_violation_tso),
 471                 4, STATS_FLAGS_FUNC, "tx_window_violation_tso"},
 472     { STATS_OFFSET32(tx_chain_lost_mbuf),
 473                 4, STATS_FLAGS_FUNC, "tx_chain_lost_mbuf"},
 474     { STATS_OFFSET32(tx_frames_deferred),
 475                 4, STATS_FLAGS_FUNC, "tx_frames_deferred"},
 476     { STATS_OFFSET32(tx_queue_xoff),
 477                 4, STATS_FLAGS_FUNC, "tx_queue_xoff"},
 478     { STATS_OFFSET32(mbuf_defrag_attempts),
 479                 4, STATS_FLAGS_FUNC, "mbuf_defrag_attempts"},
 480     { STATS_OFFSET32(mbuf_defrag_failures),
 481                 4, STATS_FLAGS_FUNC, "mbuf_defrag_failures"},
 482     { STATS_OFFSET32(mbuf_rx_bd_alloc_failed),
 483                 4, STATS_FLAGS_FUNC, "mbuf_rx_bd_alloc_failed"},
 484     { STATS_OFFSET32(mbuf_rx_bd_mapping_failed),
 485                 4, STATS_FLAGS_FUNC, "mbuf_rx_bd_mapping_failed"},
 486     { STATS_OFFSET32(mbuf_rx_tpa_alloc_failed),
 487                 4, STATS_FLAGS_FUNC, "mbuf_rx_tpa_alloc_failed"},
 488     { STATS_OFFSET32(mbuf_rx_tpa_mapping_failed),
 489                 4, STATS_FLAGS_FUNC, "mbuf_rx_tpa_mapping_failed"},
 490     { STATS_OFFSET32(mbuf_rx_sge_alloc_failed),
 491                 4, STATS_FLAGS_FUNC, "mbuf_rx_sge_alloc_failed"},
 492     { STATS_OFFSET32(mbuf_rx_sge_mapping_failed),
 493                 4, STATS_FLAGS_FUNC, "mbuf_rx_sge_mapping_failed"},
 494     { STATS_OFFSET32(mbuf_alloc_tx),
 495                 4, STATS_FLAGS_FUNC, "mbuf_alloc_tx"},
 496     { STATS_OFFSET32(mbuf_alloc_rx),
 497                 4, STATS_FLAGS_FUNC, "mbuf_alloc_rx"},
 498     { STATS_OFFSET32(mbuf_alloc_sge),
 499                 4, STATS_FLAGS_FUNC, "mbuf_alloc_sge"},
 500     { STATS_OFFSET32(mbuf_alloc_tpa),
 501                 4, STATS_FLAGS_FUNC, "mbuf_alloc_tpa"}
 502 };
 503
 504 static const struct {
 505     uint32_t offset;
 506     uint32_t size;
 507     char string[STAT_NAME_LEN];
 508 } bxe_eth_q_stats_arr[] = {
 509     { Q_STATS_OFFSET32(total_bytes_received_hi),
 510                 8, "rx_bytes" },
 511     { Q_STATS_OFFSET32(total_unicast_packets_received_hi),
 512                 8, "rx_ucast_packets" },
 513     { Q_STATS_OFFSET32(total_multicast_packets_received_hi),
 514                 8, "rx_mcast_packets" },
 515     { Q_STATS_OFFSET32(total_broadcast_packets_received_hi),
 516                 8, "rx_bcast_packets" },
 517     { Q_STATS_OFFSET32(no_buff_discard_hi),
 518                 8, "rx_discards" },
 519     { Q_STATS_OFFSET32(total_bytes_transmitted_hi),
 520                 8, "tx_bytes" },
 521     { Q_STATS_OFFSET32(total_unicast_packets_transmitted_hi),
 522                 8, "tx_ucast_packets" },
 523     { Q_STATS_OFFSET32(total_multicast_packets_transmitted_hi),
 524                 8, "tx_mcast_packets" },
 525     { Q_STATS_OFFSET32(total_broadcast_packets_transmitted_hi),
 526                 8, "tx_bcast_packets" },
 527     { Q_STATS_OFFSET32(total_tpa_aggregations_hi),
 528                 8, "tpa_aggregations" },
 529     { Q_STATS_OFFSET32(total_tpa_aggregated_frames_hi),
 530                 8, "tpa_aggregated_frames"},
 531     { Q_STATS_OFFSET32(total_tpa_bytes_hi),
 532                 8, "tpa_bytes"},
 533     { Q_STATS_OFFSET32(rx_calls),
 534                 4, "rx_calls"},
 535     { Q_STATS_OFFSET32(rx_pkts),
 536                 4, "rx_pkts"},
 537     { Q_STATS_OFFSET32(rx_tpa_pkts),
 538                 4, "rx_tpa_pkts"},
 539     { Q_STATS_OFFSET32(rx_erroneous_jumbo_sge_pkts),
 540                 4, "rx_erroneous_jumbo_sge_pkts"},
 541     { Q_STATS_OFFSET32(rx_bxe_service_rxsgl),
 542                 4, "rx_bxe_service_rxsgl"},
 543     { Q_STATS_OFFSET32(rx_jumbo_sge_pkts),
 544                 4, "rx_jumbo_sge_pkts"},
 545     { Q_STATS_OFFSET32(rx_soft_errors),
 546                 4, "rx_soft_errors"},
 547     { Q_STATS_OFFSET32(rx_hw_csum_errors),
 548                 4, "rx_hw_csum_errors"},
 549     { Q_STATS_OFFSET32(rx_ofld_frames_csum_ip),
 550                 4, "rx_ofld_frames_csum_ip"},
 551     { Q_STATS_OFFSET32(rx_ofld_frames_csum_tcp_udp),
 552                 4, "rx_ofld_frames_csum_tcp_udp"},
 553     { Q_STATS_OFFSET32(rx_budget_reached),
 554                 4, "rx_budget_reached"},
 555     { Q_STATS_OFFSET32(tx_pkts),
 556                 4, "tx_pkts"},
 557     { Q_STATS_OFFSET32(tx_soft_errors),
 558                 4, "tx_soft_errors"},
 559     { Q_STATS_OFFSET32(tx_ofld_frames_csum_ip),
 560                 4, "tx_ofld_frames_csum_ip"},
 561     { Q_STATS_OFFSET32(tx_ofld_frames_csum_tcp),
 562                 4, "tx_ofld_frames_csum_tcp"},
 563     { Q_STATS_OFFSET32(tx_ofld_frames_csum_udp),
 564                 4, "tx_ofld_frames_csum_udp"},
 565     { Q_STATS_OFFSET32(tx_ofld_frames_lso),
 566                 4, "tx_ofld_frames_lso"},
 567     { Q_STATS_OFFSET32(tx_ofld_frames_lso_hdr_splits),
 568                 4, "tx_ofld_frames_lso_hdr_splits"},
 569     { Q_STATS_OFFSET32(tx_encap_failures),
 570                 4, "tx_encap_failures"},
 571     { Q_STATS_OFFSET32(tx_hw_queue_full),
 572                 4, "tx_hw_queue_full"},
 573     { Q_STATS_OFFSET32(tx_hw_max_queue_depth),
 574                 4, "tx_hw_max_queue_depth"},
 575     { Q_STATS_OFFSET32(tx_dma_mapping_failure),
 576                 4, "tx_dma_mapping_failure"},
 577     { Q_STATS_OFFSET32(tx_max_drbr_queue_depth),
 578                 4, "tx_max_drbr_queue_depth"},
 579     { Q_STATS_OFFSET32(tx_window_violation_std),
 580                 4, "tx_window_violation_std"},
 581     { Q_STATS_OFFSET32(tx_window_violation_tso),
 582                 4, "tx_window_violation_tso"},
 583     { Q_STATS_OFFSET32(tx_chain_lost_mbuf),
 584                 4, "tx_chain_lost_mbuf"},
 585     { Q_STATS_OFFSET32(tx_frames_deferred),
 586                 4, "tx_frames_deferred"},
 587     { Q_STATS_OFFSET32(tx_queue_xoff),
 588                 4, "tx_queue_xoff"},
 589     { Q_STATS_OFFSET32(mbuf_defrag_attempts),
 590                 4, "mbuf_defrag_attempts"},
 591     { Q_STATS_OFFSET32(mbuf_defrag_failures),
 592                 4, "mbuf_defrag_failures"},
 593     { Q_STATS_OFFSET32(mbuf_rx_bd_alloc_failed),
 594                 4, "mbuf_rx_bd_alloc_failed"},
 595     { Q_STATS_OFFSET32(mbuf_rx_bd_mapping_failed),
 596                 4, "mbuf_rx_bd_mapping_failed"},
 597     { Q_STATS_OFFSET32(mbuf_rx_tpa_alloc_failed),
 598                 4, "mbuf_rx_tpa_alloc_failed"},
 599     { Q_STATS_OFFSET32(mbuf_rx_tpa_mapping_failed),
 600                 4, "mbuf_rx_tpa_mapping_failed"},
 601     { Q_STATS_OFFSET32(mbuf_rx_sge_alloc_failed),
 602                 4, "mbuf_rx_sge_alloc_failed"},
 603     { Q_STATS_OFFSET32(mbuf_rx_sge_mapping_failed),
 604                 4, "mbuf_rx_sge_mapping_failed"},
 605     { Q_STATS_OFFSET32(mbuf_alloc_tx),
 606                 4, "mbuf_alloc_tx"},
 607     { Q_STATS_OFFSET32(mbuf_alloc_rx),
 608                 4, "mbuf_alloc_rx"},
 609     { Q_STATS_OFFSET32(mbuf_alloc_sge),
 610                 4, "mbuf_alloc_sge"},
 611     { Q_STATS_OFFSET32(mbuf_alloc_tpa),
 612                 4, "mbuf_alloc_tpa"}
 613 };
 614
 615 #define BXE_NUM_ETH_STATS   ARRAY_SIZE(bxe_eth_stats_arr)
 616 #define BXE_NUM_ETH_Q_STATS ARRAY_SIZE(bxe_eth_q_stats_arr)
 617
 618
 619 static void    bxe_cmng_fns_init(struct bxe_softc *sc,
 620                                  uint8_t          read_cfg,
 621                                  uint8_t          cmng_type);
 622 static int     bxe_get_cmng_fns_mode(struct bxe_softc *sc);
 623 static void    storm_memset_cmng(struct bxe_softc *sc,
 624                                  struct cmng_init *cmng,
 625                                  uint8_t          port);
 626 static void    bxe_set_reset_global(struct bxe_softc *sc);
 627 static void    bxe_set_reset_in_progress(struct bxe_softc *sc);
 628 static uint8_t bxe_reset_is_done(struct bxe_softc *sc,
 629                                  int              engine);
 630 static uint8_t bxe_clear_pf_load(struct bxe_softc *sc);
 631 static uint8_t bxe_chk_parity_attn(struct bxe_softc *sc,
 632                                    uint8_t          *global,
 633                                    uint8_t          print);
 634 static void    bxe_int_disable(struct bxe_softc *sc);
 635 static int     bxe_release_leader_lock(struct bxe_softc *sc);
 636 static void    bxe_pf_disable(struct bxe_softc *sc);
 637 static void    bxe_free_fp_buffers(struct bxe_softc *sc);
 638 static inline void bxe_update_rx_prod(struct bxe_softc    *sc,
 639                                       struct bxe_fastpath *fp,
 640                                       uint16_t            rx_bd_prod,
 641                                       uint16_t            rx_cq_prod,
 642                                       uint16_t            rx_sge_prod);
 643 static void    bxe_link_report_locked(struct bxe_softc *sc);
 644 static void    bxe_link_report(struct bxe_softc *sc);
 645 static void    bxe_link_status_update(struct bxe_softc *sc);
 646 static void    bxe_periodic_callout_func(void *xsc);
 647 static void    bxe_periodic_start(struct bxe_softc *sc);
 648 static void    bxe_periodic_stop(struct bxe_softc *sc);
 649 static int     bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
 650                                     uint16_t prev_index,
 651                                     uint16_t index);
 652 static int     bxe_alloc_rx_tpa_mbuf(struct bxe_fastpath *fp,
 653                                      int                 queue);
 654 static int     bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
 655                                      uint16_t            index);
 656 static uint8_t bxe_txeof(struct bxe_softc *sc,
 657                          struct bxe_fastpath *fp);
 658 static void    bxe_task_fp(struct bxe_fastpath *fp);
 659 static __noinline void bxe_dump_mbuf(struct bxe_softc *sc,
 660                                      struct mbuf      *m,
 661                                      uint8_t          contents);
 662 static int     bxe_alloc_mem(struct bxe_softc *sc);
 663 static void    bxe_free_mem(struct bxe_softc *sc);
 664 static int     bxe_alloc_fw_stats_mem(struct bxe_softc *sc);
 665 static void    bxe_free_fw_stats_mem(struct bxe_softc *sc);
 666 static int     bxe_interrupt_attach(struct bxe_softc *sc);
 667 static void    bxe_interrupt_detach(struct bxe_softc *sc);
 668 static void    bxe_set_rx_mode(struct bxe_softc *sc);
 669 static int     bxe_init_locked(struct bxe_softc *sc);
 670 static int     bxe_stop_locked(struct bxe_softc *sc);
 671 static __noinline int bxe_nic_load(struct bxe_softc *sc,
 672                                    int              load_mode);
 673 static __noinline int bxe_nic_unload(struct bxe_softc *sc,
 674                                      uint32_t         unload_mode,
 675                                      uint8_t          keep_link);
 676
 677 static void bxe_handle_sp_tq(void *context, int pending);
 678 static void bxe_handle_fp_tq(void *context, int pending);
 679
 680 static int bxe_add_cdev(struct bxe_softc *sc);
 681 static void bxe_del_cdev(struct bxe_softc *sc);
 682 static int bxe_grc_dump(struct bxe_softc *sc);
 683 static int bxe_alloc_buf_rings(struct bxe_softc *sc);
 684 static void bxe_free_buf_rings(struct bxe_softc *sc);
 685
 686 /* calculate crc32 on a buffer (NOTE: crc32_length MUST be aligned to 8) */
 687 uint32_t
 688 calc_crc32(uint8_t  *crc32_packet,
 689            uint32_t crc32_length,
 690            uint32_t crc32_seed,
 691            uint8_t  complement)
 692 {
 693    uint32_t byte         = 0;
 694    uint32_t bit          = 0;
 695    uint8_t  msb          = 0;
 696    uint32_t temp         = 0;
 697    uint32_t shft         = 0;
 698    uint8_t  current_byte = 0;
 699    uint32_t crc32_result = crc32_seed;
 700    const uint32_t CRC32_POLY = 0x1edc6f41;
 701
 702    if ((crc32_packet == NULL) ||
 703        (crc32_length == 0) ||
 704        ((crc32_length % 8) != 0))
 705     {
 706         return (crc32_result);
 707     }
 708
 709     for (byte = 0; byte < crc32_length; byte = byte + 1)
 710     {
 711         current_byte = crc32_packet[byte];
 712         for (bit = 0; bit < 8; bit = bit + 1)
 713         {
 714             /* msb = crc32_result[31]; */
 715             msb = (uint8_t)(crc32_result >> 31);
 716
 717             crc32_result = crc32_result << 1;
 718
 719             /* it (msb != current_byte[bit]) */
 720             if (msb != (0x1 & (current_byte >> bit)))
 721             {
 722                 crc32_result = crc32_result ^ CRC32_POLY;
 723                 /* crc32_result[0] = 1 */
 724                 crc32_result |= 1;
 725             }
 726         }
 727     }
 728
 729     /* Last step is to:
 730      * 1. "mirror" every bit
 731      * 2. swap the 4 bytes
 732      * 3. complement each bit
 733      */
 734
 735     /* Mirror */
 736     temp = crc32_result;
 737     shft = sizeof(crc32_result) * 8 - 1;
 738
 739     for (crc32_result >>= 1; crc32_result; crc32_result >>= 1)
 740     {
 741         temp <<= 1;
 742         temp |= crc32_result & 1;
 743         shft-- ;
 744     }
 745
 746     /* temp[31-bit] = crc32_result[bit] */
 747     temp <<= shft;
 748
 749     /* Swap */
 750     /* crc32_result = {temp[7:0], temp[15:8], temp[23:16], temp[31:24]} */
 751     {
 752         uint32_t t0, t1, t2, t3;
 753         t0 = (0x000000ff & (temp >> 24));
 754         t1 = (0x0000ff00 & (temp >> 8));
 755         t2 = (0x00ff0000 & (temp << 8));
 756         t3 = (0xff000000 & (temp << 24));
 757         crc32_result = t0 | t1 | t2 | t3;
 758     }
 759
 760     /* Complement */
 761     if (complement)
 762     {
 763         crc32_result = ~crc32_result;
 764     }
 765
 766     return (crc32_result);
 767 }
 768
 769 int
 770 bxe_test_bit(int                    nr,
 771              volatile unsigned long *addr)
 772 {
 773     return ((atomic_load_acq_long(addr) & (1 << nr)) != 0);
 774 }
 775
 776 void
 777 bxe_set_bit(unsigned int           nr,
 778             volatile unsigned long *addr)
 779 {
 780     atomic_set_acq_long(addr, (1 << nr));
 781 }
 782
 783 void
 784 bxe_clear_bit(int                    nr,
 785               volatile unsigned long *addr)
 786 {
 787     atomic_clear_acq_long(addr, (1 << nr));
 788 }
 789
 790 int
 791 bxe_test_and_set_bit(int                    nr,
 792                        volatile unsigned long *addr)
 793 {
 794     unsigned long x;
 795     nr = (1 << nr);
 796     do {
 797         x = *addr;
 798     } while (atomic_cmpset_acq_long(addr, x, x | nr) == 0);
 799     // if (x & nr) bit_was_set; else bit_was_not_set;
 800     return (x & nr);
 801 }
 802
 803 int
 804 bxe_test_and_clear_bit(int                    nr,
 805                        volatile unsigned long *addr)
 806 {
 807     unsigned long x;
 808     nr = (1 << nr);
 809     do {
 810         x = *addr;
 811     } while (atomic_cmpset_acq_long(addr, x, x & ~nr) == 0);
 812     // if (x & nr) bit_was_set; else bit_was_not_set;
 813     return (x & nr);
 814 }
 815
 816 int
 817 bxe_cmpxchg(volatile int *addr,
 818             int          old,
 819             int          new)
 820 {
 821     int x;
 822     do {
 823         x = *addr;
 824     } while (atomic_cmpset_acq_int(addr, old, new) == 0);
 825     return (x);
 826 }
 827
 828 /*
 829  * Get DMA memory from the OS.
 830  *
 831  * Validates that the OS has provided DMA buffers in response to a
 832  * bus_dmamap_load call and saves the physical address of those buffers.
 833  * When the callback is used the OS will return 0 for the mapping function
 834  * (bus_dmamap_load) so we use the value of map_arg->maxsegs to pass any
 835  * failures back to the caller.
 836  *
 837  * Returns:
 838  *   Nothing.
 839  */
 840 static void
 841 bxe_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 842 {
 843     struct bxe_dma *dma = arg;
 844
 845     if (error) {
 846         dma->paddr = 0;
 847         dma->nseg  = 0;
 848         BLOGE(dma->sc, "Failed DMA alloc '%s' (%d)!\n", dma->msg, error);
 849     } else {
 850         dma->paddr = segs->ds_addr;
 851         dma->nseg  = nseg;
 852     }
 853 }
 854
 855 /*
 856  * Allocate a block of memory and map it for DMA. No partial completions
 857  * allowed and release any resources acquired if we can't acquire all
 858  * resources.
 859  *
 860  * Returns:
 861  *   0 = Success, !0 = Failure
 862  */
 863 int
 864 bxe_dma_alloc(struct bxe_softc *sc,
 865               bus_size_t       size,
 866               struct bxe_dma   *dma,
 867               const char       *msg)
 868 {
 869     int rc;
 870
 871     if (dma->size > 0) {
 872         BLOGE(sc, "dma block '%s' already has size %lu\n", msg,
 873               (unsigned long)dma->size);
 874         return (1);
 875     }
 876
 877     memset(dma, 0, sizeof(*dma)); /* sanity */
 878     dma->sc   = sc;
 879     dma->size = size;
 880     snprintf(dma->msg, sizeof(dma->msg), "%s", msg);
 881
 882     rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
 883                             BCM_PAGE_SIZE,      /* alignment */
 884                             0,                  /* boundary limit */
 885                             BUS_SPACE_MAXADDR,  /* restricted low */
 886                             BUS_SPACE_MAXADDR,  /* restricted hi */
 887                             NULL,               /* addr filter() */
 888                             NULL,               /* addr filter() arg */
 889                             size,               /* max map size */
 890                             1,                  /* num discontinuous */
 891                             size,               /* max seg size */
 892                             BUS_DMA_ALLOCNOW,   /* flags */
 893                             NULL,               /* lock() */
 894                             NULL,               /* lock() arg */
 895                             &dma->tag);         /* returned dma tag */
 896     if (rc != 0) {
 897         BLOGE(sc, "Failed to create dma tag for '%s' (%d)\n", msg, rc);
 898         memset(dma, 0, sizeof(*dma));
 899         return (1);
 900     }
 901
 902     rc = bus_dmamem_alloc(dma->tag,
 903                           (void **)&dma->vaddr,
 904                           (BUS_DMA_NOWAIT | BUS_DMA_ZERO),
 905                           &dma->map);
 906     if (rc != 0) {
 907         BLOGE(sc, "Failed to alloc dma mem for '%s' (%d)\n", msg, rc);
 908         bus_dma_tag_destroy(dma->tag);
 909         memset(dma, 0, sizeof(*dma));
 910         return (1);
 911     }
 912
 913     rc = bus_dmamap_load(dma->tag,
 914                          dma->map,
 915                          dma->vaddr,
 916                          size,
 917                          bxe_dma_map_addr, /* BLOGD in here */
 918                          dma,
 919                          BUS_DMA_NOWAIT);
 920     if (rc != 0) {
 921         BLOGE(sc, "Failed to load dma map for '%s' (%d)\n", msg, rc);
 922         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
 923         bus_dma_tag_destroy(dma->tag);
 924         memset(dma, 0, sizeof(*dma));
 925         return (1);
 926     }
 927
 928     return (0);
 929 }
 930
 931 void
 932 bxe_dma_free(struct bxe_softc *sc,
 933              struct bxe_dma   *dma)
 934 {
 935     if (dma->size > 0) {
 936         DBASSERT(sc, (dma->tag != NULL), ("dma tag is NULL"));
 937
 938         bus_dmamap_sync(dma->tag, dma->map,
 939                         (BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE));
 940         bus_dmamap_unload(dma->tag, dma->map);
 941         bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
 942         bus_dma_tag_destroy(dma->tag);
 943     }
 944
 945     memset(dma, 0, sizeof(*dma));
 946 }
 947
 948 /*
 949  * These indirect read and write routines are only during init.
 950  * The locking is handled by the MCP.
 951  */
 952
 953 void
 954 bxe_reg_wr_ind(struct bxe_softc *sc,
 955                uint32_t         addr,
 956                uint32_t         val)
 957 {
 958     pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, addr, 4);
 959     pci_write_config(sc->dev, PCICFG_GRC_DATA, val, 4);
 960     pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
 961 }
 962
 963 uint32_t
 964 bxe_reg_rd_ind(struct bxe_softc *sc,
 965                uint32_t         addr)
 966 {
 967     uint32_t val;
 968
 969     pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, addr, 4);
 970     val = pci_read_config(sc->dev, PCICFG_GRC_DATA, 4);
 971     pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
 972
 973     return (val);
 974 }
 975
 976 static int
 977 bxe_acquire_hw_lock(struct bxe_softc *sc,
 978                     uint32_t         resource)
 979 {
 980     uint32_t lock_status;
 981     uint32_t resource_bit = (1 << resource);
 982     int func = SC_FUNC(sc);
 983     uint32_t hw_lock_control_reg;
 984     int cnt;
 985
 986     /* validate the resource is within range */
 987     if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
 988         BLOGE(sc, "(resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE)"
 989             " resource_bit 0x%x\n", resource, resource_bit);
 990         return (-1);
 991     }
 992
 993     if (func <= 5) {
 994         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + (func * 8));
 995     } else {
 996         hw_lock_control_reg =
 997                 (MISC_REG_DRIVER_CONTROL_7 + ((func - 6) * 8));
 998     }
 999
1000     /* validate the resource is not already taken */
1001     lock_status = REG_RD(sc, hw_lock_control_reg);
1002     if (lock_status & resource_bit) {
1003         BLOGE(sc, "resource (0x%x) in use (status 0x%x bit 0x%x)\n",
1004               resource, lock_status, resource_bit);
1005         return (-1);
1006     }
1007
1008     /* try every 5ms for 5 seconds */
1009     for (cnt = 0; cnt < 1000; cnt++) {
1010         REG_WR(sc, (hw_lock_control_reg + 4), resource_bit);
1011         lock_status = REG_RD(sc, hw_lock_control_reg);
1012         if (lock_status & resource_bit) {
1013             return (0);
1014         }
1015         DELAY(5000);
1016     }
1017
1018     BLOGE(sc, "Resource 0x%x resource_bit 0x%x lock timeout!\n",
1019         resource, resource_bit);
1020     return (-1);
1021 }
1022
1023 static int
1024 bxe_release_hw_lock(struct bxe_softc *sc,
1025                     uint32_t         resource)
1026 {
1027     uint32_t lock_status;
1028     uint32_t resource_bit = (1 << resource);
1029     int func = SC_FUNC(sc);
1030     uint32_t hw_lock_control_reg;
1031
1032     /* validate the resource is within range */
1033     if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
1034         BLOGE(sc, "(resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE)"
1035             " resource_bit 0x%x\n", resource, resource_bit);
1036         return (-1);
1037     }
1038
1039     if (func <= 5) {
1040         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + (func * 8));
1041     } else {
1042         hw_lock_control_reg =
1043                 (MISC_REG_DRIVER_CONTROL_7 + ((func - 6) * 8));
1044     }
1045
1046     /* validate the resource is currently taken */
1047     lock_status = REG_RD(sc, hw_lock_control_reg);
1048     if (!(lock_status & resource_bit)) {
1049         BLOGE(sc, "resource (0x%x) not in use (status 0x%x bit 0x%x)\n",
1050               resource, lock_status, resource_bit);
1051         return (-1);
1052     }
1053
1054     REG_WR(sc, hw_lock_control_reg, resource_bit);
1055     return (0);
1056 }
1057 static void bxe_acquire_phy_lock(struct bxe_softc *sc)
1058 {
1059         BXE_PHY_LOCK(sc);
1060         bxe_acquire_hw_lock(sc,HW_LOCK_RESOURCE_MDIO);
1061 }
1062
1063 static void bxe_release_phy_lock(struct bxe_softc *sc)
1064 {
1065         bxe_release_hw_lock(sc,HW_LOCK_RESOURCE_MDIO);
1066         BXE_PHY_UNLOCK(sc);
1067 }
1068 /*
1069  * Per pf misc lock must be acquired before the per port mcp lock. Otherwise,
1070  * had we done things the other way around, if two pfs from the same port
1071  * would attempt to access nvram at the same time, we could run into a
1072  * scenario such as:
1073  * pf A takes the port lock.
1074  * pf B succeeds in taking the same lock since they are from the same port.
1075  * pf A takes the per pf misc lock. Performs eeprom access.
1076  * pf A finishes. Unlocks the per pf misc lock.
1077  * Pf B takes the lock and proceeds to perform it's own access.
1078  * pf A unlocks the per port lock, while pf B is still working (!).
1079  * mcp takes the per port lock and corrupts pf B's access (and/or has it's own
1080  * access corrupted by pf B).*
1081  */
1082 static int
1083 bxe_acquire_nvram_lock(struct bxe_softc *sc)
1084 {
1085     int port = SC_PORT(sc);
1086     int count, i;
1087     uint32_t val = 0;
1088
1089     /* acquire HW lock: protect against other PFs in PF Direct Assignment */
1090     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_NVRAM);
1091
1092     /* adjust timeout for emulation/FPGA */
1093     count = NVRAM_TIMEOUT_COUNT;
1094     if (CHIP_REV_IS_SLOW(sc)) {
1095         count *= 100;
1096     }
1097
1098     /* request access to nvram interface */
1099     REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
1100            (MCPR_NVM_SW_ARB_ARB_REQ_SET1 << port));
1101
1102     for (i = 0; i < count*10; i++) {
1103         val = REG_RD(sc, MCP_REG_MCPR_NVM_SW_ARB);
1104         if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
1105             break;
1106         }
1107
1108         DELAY(5);
1109     }
1110
1111     if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
1112         BLOGE(sc, "Cannot get access to nvram interface "
1113             "port %d val 0x%x (MCPR_NVM_SW_ARB_ARB_ARB1 << port)\n",
1114             port, val);
1115         return (-1);
1116     }
1117
1118     return (0);
1119 }
1120
1121 static int
1122 bxe_release_nvram_lock(struct bxe_softc *sc)
1123 {
1124     int port = SC_PORT(sc);
1125     int count, i;
1126     uint32_t val = 0;
1127
1128     /* adjust timeout for emulation/FPGA */
1129     count = NVRAM_TIMEOUT_COUNT;
1130     if (CHIP_REV_IS_SLOW(sc)) {
1131         count *= 100;
1132     }
1133
1134     /* relinquish nvram interface */
1135     REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
1136            (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << port));
1137
1138     for (i = 0; i < count*10; i++) {
1139         val = REG_RD(sc, MCP_REG_MCPR_NVM_SW_ARB);
1140         if (!(val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port))) {
1141             break;
1142         }
1143
1144         DELAY(5);
1145     }
1146
1147     if (val & (MCPR_NVM_SW_ARB_ARB_ARB1 << port)) {
1148         BLOGE(sc, "Cannot free access to nvram interface "
1149             "port %d val 0x%x (MCPR_NVM_SW_ARB_ARB_ARB1 << port)\n",
1150             port, val);
1151         return (-1);
1152     }
1153
1154     /* release HW lock: protect against other PFs in PF Direct Assignment */
1155     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_NVRAM);
1156
1157     return (0);
1158 }
1159
1160 static void
1161 bxe_enable_nvram_access(struct bxe_softc *sc)
1162 {
1163     uint32_t val;
1164
1165     val = REG_RD(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
1166
1167     /* enable both bits, even on read */
1168     REG_WR(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
1169            (val | MCPR_NVM_ACCESS_ENABLE_EN | MCPR_NVM_ACCESS_ENABLE_WR_EN));
1170 }
1171
1172 static void
1173 bxe_disable_nvram_access(struct bxe_softc *sc)
1174 {
1175     uint32_t val;
1176
1177     val = REG_RD(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE);
1178
1179     /* disable both bits, even after read */
1180     REG_WR(sc, MCP_REG_MCPR_NVM_ACCESS_ENABLE,
1181            (val & ~(MCPR_NVM_ACCESS_ENABLE_EN |
1182                     MCPR_NVM_ACCESS_ENABLE_WR_EN)));
1183 }
1184
1185 static int
1186 bxe_nvram_read_dword(struct bxe_softc *sc,
1187                      uint32_t         offset,
1188                      uint32_t         *ret_val,
1189                      uint32_t         cmd_flags)
1190 {
1191     int count, i, rc;
1192     uint32_t val;
1193
1194     /* build the command word */
1195     cmd_flags |= MCPR_NVM_COMMAND_DOIT;
1196
1197     /* need to clear DONE bit separately */
1198     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
1199
1200     /* address of the NVRAM to read from */
1201     REG_WR(sc, MCP_REG_MCPR_NVM_ADDR,
1202            (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
1203
1204     /* issue a read command */
1205     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
1206
1207     /* adjust timeout for emulation/FPGA */
1208     count = NVRAM_TIMEOUT_COUNT;
1209     if (CHIP_REV_IS_SLOW(sc)) {
1210         count *= 100;
1211     }
1212
1213     /* wait for completion */
1214     *ret_val = 0;
1215     rc = -1;
1216     for (i = 0; i < count; i++) {
1217         DELAY(5);
1218         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
1219
1220         if (val & MCPR_NVM_COMMAND_DONE) {
1221             val = REG_RD(sc, MCP_REG_MCPR_NVM_READ);
1222             /* we read nvram data in cpu order
1223              * but ethtool sees it as an array of bytes
1224              * converting to big-endian will do the work
1225              */
1226             *ret_val = htobe32(val);
1227             rc = 0;
1228             break;
1229         }
1230     }
1231
1232     if (rc == -1) {
1233         BLOGE(sc, "nvram read timeout expired "
1234             "(offset 0x%x cmd_flags 0x%x val 0x%x)\n",
1235             offset, cmd_flags, val);
1236     }
1237
1238     return (rc);
1239 }
1240
1241 static int
1242 bxe_nvram_read(struct bxe_softc *sc,
1243                uint32_t         offset,
1244                uint8_t          *ret_buf,
1245                int              buf_size)
1246 {
1247     uint32_t cmd_flags;
1248     uint32_t val;
1249     int rc;
1250
1251     if ((offset & 0x03) || (buf_size & 0x03) || (buf_size == 0)) {
1252         BLOGE(sc, "Invalid parameter, offset 0x%x buf_size 0x%x\n",
1253               offset, buf_size);
1254         return (-1);
1255     }
1256
1257     if ((offset + buf_size) > sc->devinfo.flash_size) {
1258         BLOGE(sc, "Invalid parameter, "
1259                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1260               offset, buf_size, sc->devinfo.flash_size);
1261         return (-1);
1262     }
1263
1264     /* request access to nvram interface */
1265     rc = bxe_acquire_nvram_lock(sc);
1266     if (rc) {
1267         return (rc);
1268     }
1269
1270     /* enable access to nvram interface */
1271     bxe_enable_nvram_access(sc);
1272
1273     /* read the first word(s) */
1274     cmd_flags = MCPR_NVM_COMMAND_FIRST;
1275     while ((buf_size > sizeof(uint32_t)) && (rc == 0)) {
1276         rc = bxe_nvram_read_dword(sc, offset, &val, cmd_flags);
1277         memcpy(ret_buf, &val, 4);
1278
1279         /* advance to the next dword */
1280         offset += sizeof(uint32_t);
1281         ret_buf += sizeof(uint32_t);
1282         buf_size -= sizeof(uint32_t);
1283         cmd_flags = 0;
1284     }
1285
1286     if (rc == 0) {
1287         cmd_flags |= MCPR_NVM_COMMAND_LAST;
1288         rc = bxe_nvram_read_dword(sc, offset, &val, cmd_flags);
1289         memcpy(ret_buf, &val, 4);
1290     }
1291
1292     /* disable access to nvram interface */
1293     bxe_disable_nvram_access(sc);
1294     bxe_release_nvram_lock(sc);
1295
1296     return (rc);
1297 }
1298
1299 static int
1300 bxe_nvram_write_dword(struct bxe_softc *sc,
1301                       uint32_t         offset,
1302                       uint32_t         val,
1303                       uint32_t         cmd_flags)
1304 {
1305     int count, i, rc;
1306
1307     /* build the command word */
1308     cmd_flags |= (MCPR_NVM_COMMAND_DOIT | MCPR_NVM_COMMAND_WR);
1309
1310     /* need to clear DONE bit separately */
1311     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, MCPR_NVM_COMMAND_DONE);
1312
1313     /* write the data */
1314     REG_WR(sc, MCP_REG_MCPR_NVM_WRITE, val);
1315
1316     /* address of the NVRAM to write to */
1317     REG_WR(sc, MCP_REG_MCPR_NVM_ADDR,
1318            (offset & MCPR_NVM_ADDR_NVM_ADDR_VALUE));
1319
1320     /* issue the write command */
1321     REG_WR(sc, MCP_REG_MCPR_NVM_COMMAND, cmd_flags);
1322
1323     /* adjust timeout for emulation/FPGA */
1324     count = NVRAM_TIMEOUT_COUNT;
1325     if (CHIP_REV_IS_SLOW(sc)) {
1326         count *= 100;
1327     }
1328
1329     /* wait for completion */
1330     rc = -1;
1331     for (i = 0; i < count; i++) {
1332         DELAY(5);
1333         val = REG_RD(sc, MCP_REG_MCPR_NVM_COMMAND);
1334         if (val & MCPR_NVM_COMMAND_DONE) {
1335             rc = 0;
1336             break;
1337         }
1338     }
1339
1340     if (rc == -1) {
1341         BLOGE(sc, "nvram write timeout expired "
1342             "(offset 0x%x cmd_flags 0x%x val 0x%x)\n",
1343             offset, cmd_flags, val);
1344     }
1345
1346     return (rc);
1347 }
1348
1349 #define BYTE_OFFSET(offset) (8 * (offset & 0x03))
1350
1351 static int
1352 bxe_nvram_write1(struct bxe_softc *sc,
1353                  uint32_t         offset,
1354                  uint8_t          *data_buf,
1355                  int              buf_size)
1356 {
1357     uint32_t cmd_flags;
1358     uint32_t align_offset;
1359     uint32_t val;
1360     int rc;
1361
1362     if ((offset + buf_size) > sc->devinfo.flash_size) {
1363         BLOGE(sc, "Invalid parameter, "
1364                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1365               offset, buf_size, sc->devinfo.flash_size);
1366         return (-1);
1367     }
1368
1369     /* request access to nvram interface */
1370     rc = bxe_acquire_nvram_lock(sc);
1371     if (rc) {
1372         return (rc);
1373     }
1374
1375     /* enable access to nvram interface */
1376     bxe_enable_nvram_access(sc);
1377
1378     cmd_flags = (MCPR_NVM_COMMAND_FIRST | MCPR_NVM_COMMAND_LAST);
1379     align_offset = (offset & ~0x03);
1380     rc = bxe_nvram_read_dword(sc, align_offset, &val, cmd_flags);
1381
1382     if (rc == 0) {
1383         val &= ~(0xff << BYTE_OFFSET(offset));
1384         val |= (*data_buf << BYTE_OFFSET(offset));
1385
1386         /* nvram data is returned as an array of bytes
1387          * convert it back to cpu order
1388          */
1389         val = be32toh(val);
1390
1391         rc = bxe_nvram_write_dword(sc, align_offset, val, cmd_flags);
1392     }
1393
1394     /* disable access to nvram interface */
1395     bxe_disable_nvram_access(sc);
1396     bxe_release_nvram_lock(sc);
1397
1398     return (rc);
1399 }
1400
1401 static int
1402 bxe_nvram_write(struct bxe_softc *sc,
1403                 uint32_t         offset,
1404                 uint8_t          *data_buf,
1405                 int              buf_size)
1406 {
1407     uint32_t cmd_flags;
1408     uint32_t val;
1409     uint32_t written_so_far;
1410     int rc;
1411
1412     if (buf_size == 1) {
1413         return (bxe_nvram_write1(sc, offset, data_buf, buf_size));
1414     }
1415
1416     if ((offset & 0x03) || (buf_size & 0x03) /* || (buf_size == 0) */) {
1417         BLOGE(sc, "Invalid parameter, offset 0x%x buf_size 0x%x\n",
1418               offset, buf_size);
1419         return (-1);
1420     }
1421
1422     if (buf_size == 0) {
1423         return (0); /* nothing to do */
1424     }
1425
1426     if ((offset + buf_size) > sc->devinfo.flash_size) {
1427         BLOGE(sc, "Invalid parameter, "
1428                   "offset 0x%x + buf_size 0x%x > flash_size 0x%x\n",
1429               offset, buf_size, sc->devinfo.flash_size);
1430         return (-1);
1431     }
1432
1433     /* request access to nvram interface */
1434     rc = bxe_acquire_nvram_lock(sc);
1435     if (rc) {
1436         return (rc);
1437     }
1438
1439     /* enable access to nvram interface */
1440     bxe_enable_nvram_access(sc);
1441
1442     written_so_far = 0;
1443     cmd_flags = MCPR_NVM_COMMAND_FIRST;
1444     while ((written_so_far < buf_size) && (rc == 0)) {
1445         if (written_so_far == (buf_size - sizeof(uint32_t))) {
1446             cmd_flags |= MCPR_NVM_COMMAND_LAST;
1447         } else if (((offset + 4) % NVRAM_PAGE_SIZE) == 0) {
1448             cmd_flags |= MCPR_NVM_COMMAND_LAST;
1449         } else if ((offset % NVRAM_PAGE_SIZE) == 0) {
1450             cmd_flags |= MCPR_NVM_COMMAND_FIRST;
1451         }
1452
1453         memcpy(&val, data_buf, 4);
1454
1455         rc = bxe_nvram_write_dword(sc, offset, val, cmd_flags);
1456
1457         /* advance to the next dword */
1458         offset += sizeof(uint32_t);
1459         data_buf += sizeof(uint32_t);
1460         written_so_far += sizeof(uint32_t);
1461         cmd_flags = 0;
1462     }
1463
1464     /* disable access to nvram interface */
1465     bxe_disable_nvram_access(sc);
1466     bxe_release_nvram_lock(sc);
1467
1468     return (rc);
1469 }
1470
1471 /* copy command into DMAE command memory and set DMAE command Go */
1472 void
1473 bxe_post_dmae(struct bxe_softc    *sc,
1474               struct dmae_cmd *dmae,
1475               int                 idx)
1476 {
1477     uint32_t cmd_offset;
1478     int i;
1479
1480     cmd_offset = (DMAE_REG_CMD_MEM + (sizeof(struct dmae_cmd) * idx));
1481     for (i = 0; i < ((sizeof(struct dmae_cmd) / 4)); i++) {
1482         REG_WR(sc, (cmd_offset + (i * 4)), *(((uint32_t *)dmae) + i));
1483     }
1484
1485     REG_WR(sc, dmae_reg_go_c[idx], 1);
1486 }
1487
1488 uint32_t
1489 bxe_dmae_opcode_add_comp(uint32_t opcode,
1490                          uint8_t  comp_type)
1491 {
1492     return (opcode | ((comp_type << DMAE_CMD_C_DST_SHIFT) |
1493                       DMAE_CMD_C_TYPE_ENABLE));
1494 }
1495
1496 uint32_t
1497 bxe_dmae_opcode_clr_src_reset(uint32_t opcode)
1498 {
1499     return (opcode & ~DMAE_CMD_SRC_RESET);
1500 }
1501
1502 uint32_t
1503 bxe_dmae_opcode(struct bxe_softc *sc,
1504                 uint8_t          src_type,
1505                 uint8_t          dst_type,
1506                 uint8_t          with_comp,
1507                 uint8_t          comp_type)
1508 {
1509     uint32_t opcode = 0;
1510
1511     opcode |= ((src_type << DMAE_CMD_SRC_SHIFT) |
1512                (dst_type << DMAE_CMD_DST_SHIFT));
1513
1514     opcode |= (DMAE_CMD_SRC_RESET | DMAE_CMD_DST_RESET);
1515
1516     opcode |= (SC_PORT(sc) ? DMAE_CMD_PORT_1 : DMAE_CMD_PORT_0);
1517
1518     opcode |= ((SC_VN(sc) << DMAE_CMD_E1HVN_SHIFT) |
1519                (SC_VN(sc) << DMAE_CMD_DST_VN_SHIFT));
1520
1521     opcode |= (DMAE_COM_SET_ERR << DMAE_CMD_ERR_POLICY_SHIFT);
1522
1523 #ifdef __BIG_ENDIAN
1524     opcode |= DMAE_CMD_ENDIANITY_B_DW_SWAP;
1525 #else
1526     opcode |= DMAE_CMD_ENDIANITY_DW_SWAP;
1527 #endif
1528
1529     if (with_comp) {
1530         opcode = bxe_dmae_opcode_add_comp(opcode, comp_type);
1531     }
1532
1533     return (opcode);
1534 }
1535
1536 static void
1537 bxe_prep_dmae_with_comp(struct bxe_softc    *sc,
1538                         struct dmae_cmd *dmae,
1539                         uint8_t             src_type,
1540                         uint8_t             dst_type)
1541 {
1542     memset(dmae, 0, sizeof(struct dmae_cmd));
1543
1544     /* set the opcode */
1545     dmae->opcode = bxe_dmae_opcode(sc, src_type, dst_type,
1546                                    TRUE, DMAE_COMP_PCI);
1547
1548     /* fill in the completion parameters */
1549     dmae->comp_addr_lo = U64_LO(BXE_SP_MAPPING(sc, wb_comp));
1550     dmae->comp_addr_hi = U64_HI(BXE_SP_MAPPING(sc, wb_comp));
1551     dmae->comp_val     = DMAE_COMP_VAL;
1552 }
1553
1554 /* issue a DMAE command over the init channel and wait for completion */
1555 static int
1556 bxe_issue_dmae_with_comp(struct bxe_softc    *sc,
1557                          struct dmae_cmd *dmae)
1558 {
1559     uint32_t *wb_comp = BXE_SP(sc, wb_comp);
1560     int timeout = CHIP_REV_IS_SLOW(sc) ? 400000 : 4000;
1561
1562     BXE_DMAE_LOCK(sc);
1563
1564     /* reset completion */
1565     *wb_comp = 0;
1566
1567     /* post the command on the channel used for initializations */
1568     bxe_post_dmae(sc, dmae, INIT_DMAE_C(sc));
1569
1570     /* wait for completion */
1571     DELAY(5);
1572
1573     while ((*wb_comp & ~DMAE_PCI_ERR_FLAG) != DMAE_COMP_VAL) {
1574         if (!timeout ||
1575             (sc->recovery_state != BXE_RECOVERY_DONE &&
1576              sc->recovery_state != BXE_RECOVERY_NIC_LOADING)) {
1577             BLOGE(sc, "DMAE timeout! *wb_comp 0x%x recovery_state 0x%x\n",
1578                 *wb_comp, sc->recovery_state);
1579             BXE_DMAE_UNLOCK(sc);
1580             return (DMAE_TIMEOUT);
1581         }
1582
1583         timeout--;
1584         DELAY(50);
1585     }
1586
1587     if (*wb_comp & DMAE_PCI_ERR_FLAG) {
1588         BLOGE(sc, "DMAE PCI error! *wb_comp 0x%x recovery_state 0x%x\n",
1589                 *wb_comp, sc->recovery_state);
1590         BXE_DMAE_UNLOCK(sc);
1591         return (DMAE_PCI_ERROR);
1592     }
1593
1594     BXE_DMAE_UNLOCK(sc);
1595     return (0);
1596 }
1597
1598 void
1599 bxe_read_dmae(struct bxe_softc *sc,
1600               uint32_t         src_addr,
1601               uint32_t         len32)
1602 {
1603     struct dmae_cmd dmae;
1604     uint32_t *data;
1605     int i, rc;
1606
1607     DBASSERT(sc, (len32 <= 4), ("DMAE read length is %d", len32));
1608
1609     if (!sc->dmae_ready) {
1610         data = BXE_SP(sc, wb_data[0]);
1611
1612         for (i = 0; i < len32; i++) {
1613             data[i] = (CHIP_IS_E1(sc)) ?
1614                           bxe_reg_rd_ind(sc, (src_addr + (i * 4))) :
1615                           REG_RD(sc, (src_addr + (i * 4)));
1616         }
1617
1618         return;
1619     }
1620
1621     /* set opcode and fixed command fields */
1622     bxe_prep_dmae_with_comp(sc, &dmae, DMAE_SRC_GRC, DMAE_DST_PCI);
1623
1624     /* fill in addresses and len */
1625     dmae.src_addr_lo = (src_addr >> 2); /* GRC addr has dword resolution */
1626     dmae.src_addr_hi = 0;
1627     dmae.dst_addr_lo = U64_LO(BXE_SP_MAPPING(sc, wb_data));
1628     dmae.dst_addr_hi = U64_HI(BXE_SP_MAPPING(sc, wb_data));
1629     dmae.len         = len32;
1630
1631     /* issue the command and wait for completion */
1632     if ((rc = bxe_issue_dmae_with_comp(sc, &dmae)) != 0) {
1633         bxe_panic(sc, ("DMAE failed (%d)\n", rc));
1634     };
1635 }
1636
1637 void
1638 bxe_write_dmae(struct bxe_softc *sc,
1639                bus_addr_t       dma_addr,
1640                uint32_t         dst_addr,
1641                uint32_t         len32)
1642 {
1643     struct dmae_cmd dmae;
1644     int rc;
1645
1646     if (!sc->dmae_ready) {
1647         DBASSERT(sc, (len32 <= 4), ("DMAE not ready and length is %d", len32));
1648
1649         if (CHIP_IS_E1(sc)) {
1650             ecore_init_ind_wr(sc, dst_addr, BXE_SP(sc, wb_data[0]), len32);
1651         } else {
1652             ecore_init_str_wr(sc, dst_addr, BXE_SP(sc, wb_data[0]), len32);
1653         }
1654
1655         return;
1656     }
1657
1658     /* set opcode and fixed command fields */
1659     bxe_prep_dmae_with_comp(sc, &dmae, DMAE_SRC_PCI, DMAE_DST_GRC);
1660
1661     /* fill in addresses and len */
1662     dmae.src_addr_lo = U64_LO(dma_addr);
1663     dmae.src_addr_hi = U64_HI(dma_addr);
1664     dmae.dst_addr_lo = (dst_addr >> 2); /* GRC addr has dword resolution */
1665     dmae.dst_addr_hi = 0;
1666     dmae.len         = len32;
1667
1668     /* issue the command and wait for completion */
1669     if ((rc = bxe_issue_dmae_with_comp(sc, &dmae)) != 0) {
1670         bxe_panic(sc, ("DMAE failed (%d)\n", rc));
1671     }
1672 }
1673
1674 void
1675 bxe_write_dmae_phys_len(struct bxe_softc *sc,
1676                         bus_addr_t       phys_addr,
1677                         uint32_t         addr,
1678                         uint32_t         len)
1679 {
1680     int dmae_wr_max = DMAE_LEN32_WR_MAX(sc);
1681     int offset = 0;
1682
1683     while (len > dmae_wr_max) {
1684         bxe_write_dmae(sc,
1685                        (phys_addr + offset), /* src DMA address */
1686                        (addr + offset),      /* dst GRC address */
1687                        dmae_wr_max);
1688         offset += (dmae_wr_max * 4);
1689         len -= dmae_wr_max;
1690     }
1691
1692     bxe_write_dmae(sc,
1693                    (phys_addr + offset), /* src DMA address */
1694                    (addr + offset),      /* dst GRC address */
1695                    len);
1696 }
1697
1698 void
1699 bxe_set_ctx_validation(struct bxe_softc   *sc,
1700                        struct eth_context *cxt,
1701                        uint32_t           cid)
1702 {
1703     /* ustorm cxt validation */
1704     cxt->ustorm_ag_context.cdu_usage =
1705         CDU_RSRVD_VALUE_TYPE_A(HW_CID(sc, cid),
1706             CDU_REGION_NUMBER_UCM_AG, ETH_CONNECTION_TYPE);
1707     /* xcontext validation */
1708     cxt->xstorm_ag_context.cdu_reserved =
1709         CDU_RSRVD_VALUE_TYPE_A(HW_CID(sc, cid),
1710             CDU_REGION_NUMBER_XCM_AG, ETH_CONNECTION_TYPE);
1711 }
1712
1713 static void
1714 bxe_storm_memset_hc_timeout(struct bxe_softc *sc,
1715                             uint8_t          port,
1716                             uint8_t          fw_sb_id,
1717                             uint8_t          sb_index,
1718                             uint8_t          ticks)
1719 {
1720     uint32_t addr =
1721         (BAR_CSTRORM_INTMEM +
1722          CSTORM_STATUS_BLOCK_DATA_TIMEOUT_OFFSET(fw_sb_id, sb_index));
1723
1724     REG_WR8(sc, addr, ticks);
1725
1726     BLOGD(sc, DBG_LOAD,
1727           "port %d fw_sb_id %d sb_index %d ticks %d\n",
1728           port, fw_sb_id, sb_index, ticks);
1729 }
1730
1731 static void
1732 bxe_storm_memset_hc_disable(struct bxe_softc *sc,
1733                             uint8_t          port,
1734                             uint16_t         fw_sb_id,
1735                             uint8_t          sb_index,
1736                             uint8_t          disable)
1737 {
1738     uint32_t enable_flag =
1739         (disable) ? 0 : (1 << HC_INDEX_DATA_HC_ENABLED_SHIFT);
1740     uint32_t addr =
1741         (BAR_CSTRORM_INTMEM +
1742          CSTORM_STATUS_BLOCK_DATA_FLAGS_OFFSET(fw_sb_id, sb_index));
1743     uint8_t flags;
1744
1745     /* clear and set */
1746     flags = REG_RD8(sc, addr);
1747     flags &= ~HC_INDEX_DATA_HC_ENABLED;
1748     flags |= enable_flag;
1749     REG_WR8(sc, addr, flags);
1750
1751     BLOGD(sc, DBG_LOAD,
1752           "port %d fw_sb_id %d sb_index %d disable %d\n",
1753           port, fw_sb_id, sb_index, disable);
1754 }
1755
1756 void
1757 bxe_update_coalesce_sb_index(struct bxe_softc *sc,
1758                              uint8_t          fw_sb_id,
1759                              uint8_t          sb_index,
1760                              uint8_t          disable,
1761                              uint16_t         usec)
1762 {
1763     int port = SC_PORT(sc);
1764     uint8_t ticks = (usec / 4); /* XXX ??? */
1765
1766     bxe_storm_memset_hc_timeout(sc, port, fw_sb_id, sb_index, ticks);
1767
1768     disable = (disable) ? 1 : ((usec) ? 0 : 1);
1769     bxe_storm_memset_hc_disable(sc, port, fw_sb_id, sb_index, disable);
1770 }
1771
1772 void
1773 elink_cb_udelay(struct bxe_softc *sc,
1774                 uint32_t         usecs)
1775 {
1776     DELAY(usecs);
1777 }
1778
1779 uint32_t
1780 elink_cb_reg_read(struct bxe_softc *sc,
1781                   uint32_t         reg_addr)
1782 {
1783     return (REG_RD(sc, reg_addr));
1784 }
1785
1786 void
1787 elink_cb_reg_write(struct bxe_softc *sc,
1788                    uint32_t         reg_addr,
1789                    uint32_t         val)
1790 {
1791     REG_WR(sc, reg_addr, val);
1792 }
1793
1794 void
1795 elink_cb_reg_wb_write(struct bxe_softc *sc,
1796                       uint32_t         offset,
1797                       uint32_t         *wb_write,
1798                       uint16_t         len)
1799 {
1800     REG_WR_DMAE(sc, offset, wb_write, len);
1801 }
1802
1803 void
1804 elink_cb_reg_wb_read(struct bxe_softc *sc,
1805                      uint32_t         offset,
1806                      uint32_t         *wb_write,
1807                      uint16_t         len)
1808 {
1809     REG_RD_DMAE(sc, offset, wb_write, len);
1810 }
1811
1812 uint8_t
1813 elink_cb_path_id(struct bxe_softc *sc)
1814 {
1815     return (SC_PATH(sc));
1816 }
1817
1818 void
1819 elink_cb_event_log(struct bxe_softc     *sc,
1820                    const elink_log_id_t elink_log_id,
1821                    ...)
1822 {
1823     /* XXX */
1824     BLOGI(sc, "ELINK EVENT LOG (%d)\n", elink_log_id);
1825 }
1826
1827 static int
1828 bxe_set_spio(struct bxe_softc *sc,
1829              int              spio,
1830              uint32_t         mode)
1831 {
1832     uint32_t spio_reg;
1833
1834     /* Only 2 SPIOs are configurable */
1835     if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
1836         BLOGE(sc, "Invalid SPIO 0x%x mode 0x%x\n", spio, mode);
1837         return (-1);
1838     }
1839
1840     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_SPIO);
1841
1842     /* read SPIO and mask except the float bits */
1843     spio_reg = (REG_RD(sc, MISC_REG_SPIO) & MISC_SPIO_FLOAT);
1844
1845     switch (mode) {
1846     case MISC_SPIO_OUTPUT_LOW:
1847         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> output low\n", spio);
1848         /* clear FLOAT and set CLR */
1849         spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
1850         spio_reg |=  (spio << MISC_SPIO_CLR_POS);
1851         break;
1852
1853     case MISC_SPIO_OUTPUT_HIGH:
1854         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> output high\n", spio);
1855         /* clear FLOAT and set SET */
1856         spio_reg &= ~(spio << MISC_SPIO_FLOAT_POS);
1857         spio_reg |=  (spio << MISC_SPIO_SET_POS);
1858         break;
1859
1860     case MISC_SPIO_INPUT_HI_Z:
1861         BLOGD(sc, DBG_LOAD, "Set SPIO 0x%x -> input\n", spio);
1862         /* set FLOAT */
1863         spio_reg |= (spio << MISC_SPIO_FLOAT_POS);
1864         break;
1865
1866     default:
1867         break;
1868     }
1869
1870     REG_WR(sc, MISC_REG_SPIO, spio_reg);
1871     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_SPIO);
1872
1873     return (0);
1874 }
1875
1876 static int
1877 bxe_gpio_read(struct bxe_softc *sc,
1878               int              gpio_num,
1879               uint8_t          port)
1880 {
1881     /* The GPIO should be swapped if swap register is set and active */
1882     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
1883                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
1884     int gpio_shift = (gpio_num +
1885                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
1886     uint32_t gpio_mask = (1 << gpio_shift);
1887     uint32_t gpio_reg;
1888
1889     if (gpio_num > MISC_REGISTERS_GPIO_3) {
1890         BLOGE(sc, "Invalid GPIO %d port 0x%x gpio_port %d gpio_shift %d"
1891             " gpio_mask 0x%x\n", gpio_num, port, gpio_port, gpio_shift,
1892             gpio_mask);
1893         return (-1);
1894     }
1895
1896     /* read GPIO value */
1897     gpio_reg = REG_RD(sc, MISC_REG_GPIO);
1898
1899     /* get the requested pin value */
1900     return ((gpio_reg & gpio_mask) == gpio_mask) ? 1 : 0;
1901 }
1902
1903 static int
1904 bxe_gpio_write(struct bxe_softc *sc,
1905                int              gpio_num,
1906                uint32_t         mode,
1907                uint8_t          port)
1908 {
1909     /* The GPIO should be swapped if swap register is set and active */
1910     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
1911                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
1912     int gpio_shift = (gpio_num +
1913                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
1914     uint32_t gpio_mask = (1 << gpio_shift);
1915     uint32_t gpio_reg;
1916
1917     if (gpio_num > MISC_REGISTERS_GPIO_3) {
1918         BLOGE(sc, "Invalid GPIO %d mode 0x%x port 0x%x gpio_port %d"
1919             " gpio_shift %d gpio_mask 0x%x\n",
1920             gpio_num, mode, port, gpio_port, gpio_shift, gpio_mask);
1921         return (-1);
1922     }
1923
1924     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
1925
1926     /* read GPIO and mask except the float bits */
1927     gpio_reg = (REG_RD(sc, MISC_REG_GPIO) & MISC_REGISTERS_GPIO_FLOAT);
1928
1929     switch (mode) {
1930     case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1931         BLOGD(sc, DBG_PHY,
1932               "Set GPIO %d (shift %d) -> output low\n",
1933               gpio_num, gpio_shift);
1934         /* clear FLOAT and set CLR */
1935         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1936         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_CLR_POS);
1937         break;
1938
1939     case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1940         BLOGD(sc, DBG_PHY,
1941               "Set GPIO %d (shift %d) -> output high\n",
1942               gpio_num, gpio_shift);
1943         /* clear FLOAT and set SET */
1944         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1945         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_SET_POS);
1946         break;
1947
1948     case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1949         BLOGD(sc, DBG_PHY,
1950               "Set GPIO %d (shift %d) -> input\n",
1951               gpio_num, gpio_shift);
1952         /* set FLOAT */
1953         gpio_reg |= (gpio_mask << MISC_REGISTERS_GPIO_FLOAT_POS);
1954         break;
1955
1956     default:
1957         break;
1958     }
1959
1960     REG_WR(sc, MISC_REG_GPIO, gpio_reg);
1961     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
1962
1963     return (0);
1964 }
1965
1966 static int
1967 bxe_gpio_mult_write(struct bxe_softc *sc,
1968                     uint8_t          pins,
1969                     uint32_t         mode)
1970 {
1971     uint32_t gpio_reg;
1972
1973     /* any port swapping should be handled by caller */
1974
1975     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
1976
1977     /* read GPIO and mask except the float bits */
1978     gpio_reg = REG_RD(sc, MISC_REG_GPIO);
1979     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_FLOAT_POS);
1980     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_CLR_POS);
1981     gpio_reg &= ~(pins << MISC_REGISTERS_GPIO_SET_POS);
1982
1983     switch (mode) {
1984     case MISC_REGISTERS_GPIO_OUTPUT_LOW:
1985         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> output low\n", pins);
1986         /* set CLR */
1987         gpio_reg |= (pins << MISC_REGISTERS_GPIO_CLR_POS);
1988         break;
1989
1990     case MISC_REGISTERS_GPIO_OUTPUT_HIGH:
1991         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> output high\n", pins);
1992         /* set SET */
1993         gpio_reg |= (pins << MISC_REGISTERS_GPIO_SET_POS);
1994         break;
1995
1996     case MISC_REGISTERS_GPIO_INPUT_HI_Z:
1997         BLOGD(sc, DBG_PHY, "Set GPIO 0x%x -> input\n", pins);
1998         /* set FLOAT */
1999         gpio_reg |= (pins << MISC_REGISTERS_GPIO_FLOAT_POS);
2000         break;
2001
2002     default:
2003         BLOGE(sc, "Invalid GPIO mode assignment pins 0x%x mode 0x%x"
2004             " gpio_reg 0x%x\n", pins, mode, gpio_reg);
2005         bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2006         return (-1);
2007     }
2008
2009     REG_WR(sc, MISC_REG_GPIO, gpio_reg);
2010     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2011
2012     return (0);
2013 }
2014
2015 static int
2016 bxe_gpio_int_write(struct bxe_softc *sc,
2017                    int              gpio_num,
2018                    uint32_t         mode,
2019                    uint8_t          port)
2020 {
2021     /* The GPIO should be swapped if swap register is set and active */
2022     int gpio_port = ((REG_RD(sc, NIG_REG_PORT_SWAP) &&
2023                       REG_RD(sc, NIG_REG_STRAP_OVERRIDE)) ^ port);
2024     int gpio_shift = (gpio_num +
2025                       (gpio_port ? MISC_REGISTERS_GPIO_PORT_SHIFT : 0));
2026     uint32_t gpio_mask = (1 << gpio_shift);
2027     uint32_t gpio_reg;
2028
2029     if (gpio_num > MISC_REGISTERS_GPIO_3) {
2030         BLOGE(sc, "Invalid GPIO %d mode 0x%x port 0x%x gpio_port %d"
2031             " gpio_shift %d gpio_mask 0x%x\n",
2032             gpio_num, mode, port, gpio_port, gpio_shift, gpio_mask);
2033         return (-1);
2034     }
2035
2036     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2037
2038     /* read GPIO int */
2039     gpio_reg = REG_RD(sc, MISC_REG_GPIO_INT);
2040
2041     switch (mode) {
2042     case MISC_REGISTERS_GPIO_INT_OUTPUT_CLR:
2043         BLOGD(sc, DBG_PHY,
2044               "Clear GPIO INT %d (shift %d) -> output low\n",
2045               gpio_num, gpio_shift);
2046         /* clear SET and set CLR */
2047         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2048         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2049         break;
2050
2051     case MISC_REGISTERS_GPIO_INT_OUTPUT_SET:
2052         BLOGD(sc, DBG_PHY,
2053               "Set GPIO INT %d (shift %d) -> output high\n",
2054               gpio_num, gpio_shift);
2055         /* clear CLR and set SET */
2056         gpio_reg &= ~(gpio_mask << MISC_REGISTERS_GPIO_INT_CLR_POS);
2057         gpio_reg |=  (gpio_mask << MISC_REGISTERS_GPIO_INT_SET_POS);
2058         break;
2059
2060     default:
2061         break;
2062     }
2063
2064     REG_WR(sc, MISC_REG_GPIO_INT, gpio_reg);
2065     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
2066
2067     return (0);
2068 }
2069
2070 uint32_t
2071 elink_cb_gpio_read(struct bxe_softc *sc,
2072                    uint16_t         gpio_num,
2073                    uint8_t          port)
2074 {
2075     return (bxe_gpio_read(sc, gpio_num, port));
2076 }
2077
2078 uint8_t
2079 elink_cb_gpio_write(struct bxe_softc *sc,
2080                     uint16_t         gpio_num,
2081                     uint8_t          mode, /* 0=low 1=high */
2082                     uint8_t          port)
2083 {
2084     return (bxe_gpio_write(sc, gpio_num, mode, port));
2085 }
2086
2087 uint8_t
2088 elink_cb_gpio_mult_write(struct bxe_softc *sc,
2089                          uint8_t          pins,
2090                          uint8_t          mode) /* 0=low 1=high */
2091 {
2092     return (bxe_gpio_mult_write(sc, pins, mode));
2093 }
2094
2095 uint8_t
2096 elink_cb_gpio_int_write(struct bxe_softc *sc,
2097                         uint16_t         gpio_num,
2098                         uint8_t          mode, /* 0=low 1=high */
2099                         uint8_t          port)
2100 {
2101     return (bxe_gpio_int_write(sc, gpio_num, mode, port));
2102 }
2103
2104 void
2105 elink_cb_notify_link_changed(struct bxe_softc *sc)
2106 {
2107     REG_WR(sc, (MISC_REG_AEU_GENERAL_ATTN_12 +
2108                 (SC_FUNC(sc) * sizeof(uint32_t))), 1);
2109 }
2110
2111 /* send the MCP a request, block until there is a reply */
2112 uint32_t
2113 elink_cb_fw_command(struct bxe_softc *sc,
2114                     uint32_t         command,
2115                     uint32_t         param)
2116 {
2117     int mb_idx = SC_FW_MB_IDX(sc);
2118     uint32_t seq;
2119     uint32_t rc = 0;
2120     uint32_t cnt = 1;
2121     uint8_t delay = CHIP_REV_IS_SLOW(sc) ? 100 : 10;
2122
2123     BXE_FWMB_LOCK(sc);
2124
2125     seq = ++sc->fw_seq;
2126     SHMEM_WR(sc, func_mb[mb_idx].drv_mb_param, param);
2127     SHMEM_WR(sc, func_mb[mb_idx].drv_mb_header, (command | seq));
2128
2129     BLOGD(sc, DBG_PHY,
2130           "wrote command 0x%08x to FW MB param 0x%08x\n",
2131           (command | seq), param);
2132
2133     /* Let the FW do it's magic. GIve it up to 5 seconds... */
2134     do {
2135         DELAY(delay * 1000);
2136         rc = SHMEM_RD(sc, func_mb[mb_idx].fw_mb_header);
2137     } while ((seq != (rc & FW_MSG_SEQ_NUMBER_MASK)) && (cnt++ < 500));
2138
2139     BLOGD(sc, DBG_PHY,
2140           "[after %d ms] read 0x%x seq 0x%x from FW MB\n",
2141           cnt*delay, rc, seq);
2142
2143     /* is this a reply to our command? */
2144     if (seq == (rc & FW_MSG_SEQ_NUMBER_MASK)) {
2145         rc &= FW_MSG_CODE_MASK;
2146     } else {
2147         /* Ruh-roh! */
2148         BLOGE(sc, "FW failed to respond!\n");
2149         // XXX bxe_fw_dump(sc);
2150         rc = 0;
2151     }
2152
2153     BXE_FWMB_UNLOCK(sc);
2154     return (rc);
2155 }
2156
2157 static uint32_t
2158 bxe_fw_command(struct bxe_softc *sc,
2159                uint32_t         command,
2160                uint32_t         param)
2161 {
2162     return (elink_cb_fw_command(sc, command, param));
2163 }
2164
2165 static void
2166 __storm_memset_dma_mapping(struct bxe_softc *sc,
2167                            uint32_t         addr,
2168                            bus_addr_t       mapping)
2169 {
2170     REG_WR(sc, addr, U64_LO(mapping));
2171     REG_WR(sc, (addr + 4), U64_HI(mapping));
2172 }
2173
2174 static void
2175 storm_memset_spq_addr(struct bxe_softc *sc,
2176                       bus_addr_t       mapping,
2177                       uint16_t         abs_fid)
2178 {
2179     uint32_t addr = (XSEM_REG_FAST_MEMORY +
2180                      XSTORM_SPQ_PAGE_BASE_OFFSET(abs_fid));
2181     __storm_memset_dma_mapping(sc, addr, mapping);
2182 }
2183
2184 static void
2185 storm_memset_vf_to_pf(struct bxe_softc *sc,
2186                       uint16_t         abs_fid,
2187                       uint16_t         pf_id)
2188 {
2189     REG_WR8(sc, (BAR_XSTRORM_INTMEM + XSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2190     REG_WR8(sc, (BAR_CSTRORM_INTMEM + CSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2191     REG_WR8(sc, (BAR_TSTRORM_INTMEM + TSTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2192     REG_WR8(sc, (BAR_USTRORM_INTMEM + USTORM_VF_TO_PF_OFFSET(abs_fid)), pf_id);
2193 }
2194
2195 static void
2196 storm_memset_func_en(struct bxe_softc *sc,
2197                      uint16_t         abs_fid,
2198                      uint8_t          enable)
2199 {
2200     REG_WR8(sc, (BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2201     REG_WR8(sc, (BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2202     REG_WR8(sc, (BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2203     REG_WR8(sc, (BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(abs_fid)), enable);
2204 }
2205
2206 static void
2207 storm_memset_eq_data(struct bxe_softc       *sc,
2208                      struct event_ring_data *eq_data,
2209                      uint16_t               pfid)
2210 {
2211     uint32_t addr;
2212     size_t size;
2213
2214     addr = (BAR_CSTRORM_INTMEM + CSTORM_EVENT_RING_DATA_OFFSET(pfid));
2215     size = sizeof(struct event_ring_data);
2216     ecore_storm_memset_struct(sc, addr, size, (uint32_t *)eq_data);
2217 }
2218
2219 static void
2220 storm_memset_eq_prod(struct bxe_softc *sc,
2221                      uint16_t         eq_prod,
2222                      uint16_t         pfid)
2223 {
2224     uint32_t addr = (BAR_CSTRORM_INTMEM +
2225                      CSTORM_EVENT_RING_PROD_OFFSET(pfid));
2226     REG_WR16(sc, addr, eq_prod);
2227 }
2228
2229 /*
2230  * Post a slowpath command.
2231  *
2232  * A slowpath command is used to propogate a configuration change through
2233  * the controller in a controlled manner, allowing each STORM processor and
2234  * other H/W blocks to phase in the change.  The commands sent on the
2235  * slowpath are referred to as ramrods.  Depending on the ramrod used the
2236  * completion of the ramrod will occur in different ways.  Here's a
2237  * breakdown of ramrods and how they complete:
2238  *
2239  * RAMROD_CMD_ID_ETH_PORT_SETUP
2240  *   Used to setup the leading connection on a port.  Completes on the
2241  *   Receive Completion Queue (RCQ) of that port (typically fp[0]).
2242  *
2243  * RAMROD_CMD_ID_ETH_CLIENT_SETUP
2244  *   Used to setup an additional connection on a port.  Completes on the
2245  *   RCQ of the multi-queue/RSS connection being initialized.
2246  *
2247  * RAMROD_CMD_ID_ETH_STAT_QUERY
2248  *   Used to force the storm processors to update the statistics database
2249  *   in host memory.  This ramrod is send on the leading connection CID and
2250  *   completes as an index increment of the CSTORM on the default status
2251  *   block.
2252  *
2253  * RAMROD_CMD_ID_ETH_UPDATE
2254  *   Used to update the state of the leading connection, usually to udpate
2255  *   the RSS indirection table.  Completes on the RCQ of the leading
2256  *   connection. (Not currently used under FreeBSD until OS support becomes
2257  *   available.)
2258  *
2259  * RAMROD_CMD_ID_ETH_HALT
2260  *   Used when tearing down a connection prior to driver unload.  Completes
2261  *   on the RCQ of the multi-queue/RSS connection being torn down.  Don't
2262  *   use this on the leading connection.
2263  *
2264  * RAMROD_CMD_ID_ETH_SET_MAC
2265  *   Sets the Unicast/Broadcast/Multicast used by the port.  Completes on
2266  *   the RCQ of the leading connection.
2267  *
2268  * RAMROD_CMD_ID_ETH_CFC_DEL
2269  *   Used when tearing down a conneciton prior to driver unload.  Completes
2270  *   on the RCQ of the leading connection (since the current connection
2271  *   has been completely removed from controller memory).
2272  *
2273  * RAMROD_CMD_ID_ETH_PORT_DEL
2274  *   Used to tear down the leading connection prior to driver unload,
2275  *   typically fp[0].  Completes as an index increment of the CSTORM on the
2276  *   default status block.
2277  *
2278  * RAMROD_CMD_ID_ETH_FORWARD_SETUP
2279  *   Used for connection offload.  Completes on the RCQ of the multi-queue
2280  *   RSS connection that is being offloaded.  (Not currently used under
2281  *   FreeBSD.)
2282  *
2283  * There can only be one command pending per function.
2284  *
2285  * Returns:
2286  *   0 = Success, !0 = Failure.
2287  */
2288
2289 /* must be called under the spq lock */
2290 static inline
2291 struct eth_spe *bxe_sp_get_next(struct bxe_softc *sc)
2292 {
2293     struct eth_spe *next_spe = sc->spq_prod_bd;
2294
2295     if (sc->spq_prod_bd == sc->spq_last_bd) {
2296         /* wrap back to the first eth_spq */
2297         sc->spq_prod_bd = sc->spq;
2298         sc->spq_prod_idx = 0;
2299     } else {
2300         sc->spq_prod_bd++;
2301         sc->spq_prod_idx++;
2302     }
2303
2304     return (next_spe);
2305 }
2306
2307 /* must be called under the spq lock */
2308 static inline
2309 void bxe_sp_prod_update(struct bxe_softc *sc)
2310 {
2311     int func = SC_FUNC(sc);
2312
2313     /*
2314      * Make sure that BD data is updated before writing the producer.
2315      * BD data is written to the memory, the producer is read from the
2316      * memory, thus we need a full memory barrier to ensure the ordering.
2317      */
2318     mb();
2319
2320     REG_WR16(sc, (BAR_XSTRORM_INTMEM + XSTORM_SPQ_PROD_OFFSET(func)),
2321              sc->spq_prod_idx);
2322
2323     bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
2324                       BUS_SPACE_BARRIER_WRITE);
2325 }
2326
2327 /**
2328  * bxe_is_contextless_ramrod - check if the current command ends on EQ
2329  *
2330  * @cmd:      command to check
2331  * @cmd_type: command type
2332  */
2333 static inline
2334 int bxe_is_contextless_ramrod(int cmd,
2335                               int cmd_type)
2336 {
2337     if ((cmd_type == NONE_CONNECTION_TYPE) ||
2338         (cmd == RAMROD_CMD_ID_ETH_FORWARD_SETUP) ||
2339         (cmd == RAMROD_CMD_ID_ETH_CLASSIFICATION_RULES) ||
2340         (cmd == RAMROD_CMD_ID_ETH_FILTER_RULES) ||
2341         (cmd == RAMROD_CMD_ID_ETH_MULTICAST_RULES) ||
2342         (cmd == RAMROD_CMD_ID_ETH_SET_MAC) ||
2343         (cmd == RAMROD_CMD_ID_ETH_RSS_UPDATE)) {
2344         return (TRUE);
2345     } else {
2346         return (FALSE);
2347     }
2348 }
2349
2350 /**
2351  * bxe_sp_post - place a single command on an SP ring
2352  *
2353  * @sc:         driver handle
2354  * @command:    command to place (e.g. SETUP, FILTER_RULES, etc.)
2355  * @cid:        SW CID the command is related to
2356  * @data_hi:    command private data address (high 32 bits)
2357  * @data_lo:    command private data address (low 32 bits)
2358  * @cmd_type:   command type (e.g. NONE, ETH)
2359  *
2360  * SP data is handled as if it's always an address pair, thus data fields are
2361  * not swapped to little endian in upper functions. Instead this function swaps
2362  * data as if it's two uint32 fields.
2363  */
2364 int
2365 bxe_sp_post(struct bxe_softc *sc,
2366             int              command,
2367             int              cid,
2368             uint32_t         data_hi,
2369             uint32_t         data_lo,
2370             int              cmd_type)
2371 {
2372     struct eth_spe *spe;
2373     uint16_t type;
2374     int common;
2375
2376     common = bxe_is_contextless_ramrod(command, cmd_type);
2377
2378     BXE_SP_LOCK(sc);
2379
2380     if (common) {
2381         if (!atomic_load_acq_long(&sc->eq_spq_left)) {
2382             BLOGE(sc, "EQ ring is full!\n");
2383             BXE_SP_UNLOCK(sc);
2384             return (-1);
2385         }
2386     } else {
2387         if (!atomic_load_acq_long(&sc->cq_spq_left)) {
2388             BLOGE(sc, "SPQ ring is full!\n");
2389             BXE_SP_UNLOCK(sc);
2390             return (-1);
2391         }
2392     }
2393
2394     spe = bxe_sp_get_next(sc);
2395
2396     /* CID needs port number to be encoded int it */
2397     spe->hdr.conn_and_cmd_data =
2398         htole32((command << SPE_HDR_T_CMD_ID_SHIFT) | HW_CID(sc, cid));
2399
2400     type = (cmd_type << SPE_HDR_T_CONN_TYPE_SHIFT) & SPE_HDR_T_CONN_TYPE;
2401
2402     /* TBD: Check if it works for VFs */
2403     type |= ((SC_FUNC(sc) << SPE_HDR_T_FUNCTION_ID_SHIFT) &
2404              SPE_HDR_T_FUNCTION_ID);
2405
2406     spe->hdr.type = htole16(type);
2407
2408     spe->data.update_data_addr.hi = htole32(data_hi);
2409     spe->data.update_data_addr.lo = htole32(data_lo);
2410
2411     /*
2412      * It's ok if the actual decrement is issued towards the memory
2413      * somewhere between the lock and unlock. Thus no more explict
2414      * memory barrier is needed.
2415      */
2416     if (common) {
2417         atomic_subtract_acq_long(&sc->eq_spq_left, 1);
2418     } else {
2419         atomic_subtract_acq_long(&sc->cq_spq_left, 1);
2420     }
2421
2422     BLOGD(sc, DBG_SP, "SPQE -> %#jx\n", (uintmax_t)sc->spq_dma.paddr);
2423     BLOGD(sc, DBG_SP, "FUNC_RDATA -> %p / %#jx\n",
2424           BXE_SP(sc, func_rdata), (uintmax_t)BXE_SP_MAPPING(sc, func_rdata));
2425     BLOGD(sc, DBG_SP,
2426           "SPQE[%x] (%x:%x) (cmd, common?) (%d,%d) hw_cid %x data (%x:%x) type(0x%x) left (CQ, EQ) (%lx,%lx)\n",
2427           sc->spq_prod_idx,
2428           (uint32_t)U64_HI(sc->spq_dma.paddr),
2429           (uint32_t)(U64_LO(sc->spq_dma.paddr) + (uint8_t *)sc->spq_prod_bd - (uint8_t *)sc->spq),
2430           command,
2431           common,
2432           HW_CID(sc, cid),
2433           data_hi,
2434           data_lo,
2435           type,
2436           atomic_load_acq_long(&sc->cq_spq_left),
2437           atomic_load_acq_long(&sc->eq_spq_left));
2438
2439     bxe_sp_prod_update(sc);
2440
2441     BXE_SP_UNLOCK(sc);
2442     return (0);
2443 }
2444
2445 /**
2446  * bxe_debug_print_ind_table - prints the indirection table configuration.
2447  *
2448  * @sc: driver hanlde
2449  * @p:  pointer to rss configuration
2450  */
2451
2452 /*
2453  * FreeBSD Device probe function.
2454  *
2455  * Compares the device found to the driver's list of supported devices and
2456  * reports back to the bsd loader whether this is the right driver for the device.
2457  * This is the driver entry function called from the "kldload" command.
2458  *
2459  * Returns:
2460  *   BUS_PROBE_DEFAULT on success, positive value on failure.
2461  */
2462 static int
2463 bxe_probe(device_t dev)
2464 {
2465     struct bxe_softc *sc;
2466     struct bxe_device_type *t;
2467     char *descbuf;
2468     uint16_t did, sdid, svid, vid;
2469
2470     /* Find our device structure */
2471     sc = device_get_softc(dev);
2472     sc->dev = dev;
2473     t = bxe_devs;
2474
2475     /* Get the data for the device to be probed. */
2476     vid  = pci_get_vendor(dev);
2477     did  = pci_get_device(dev);
2478     svid = pci_get_subvendor(dev);
2479     sdid = pci_get_subdevice(dev);
2480
2481     BLOGD(sc, DBG_LOAD,
2482           "%s(); VID = 0x%04X, DID = 0x%04X, SVID = 0x%04X, "
2483           "SDID = 0x%04X\n", __FUNCTION__, vid, did, svid, sdid);
2484
2485     /* Look through the list of known devices for a match. */
2486     while (t->bxe_name != NULL) {
2487         if ((vid == t->bxe_vid) && (did == t->bxe_did) &&
2488             ((svid == t->bxe_svid) || (t->bxe_svid == PCI_ANY_ID)) &&
2489             ((sdid == t->bxe_sdid) || (t->bxe_sdid == PCI_ANY_ID))) {
2490             descbuf = malloc(BXE_DEVDESC_MAX, M_TEMP, M_NOWAIT);
2491             if (descbuf == NULL)
2492                 return (ENOMEM);
2493
2494             /* Print out the device identity. */
2495             snprintf(descbuf, BXE_DEVDESC_MAX,
2496                      "%s (%c%d) BXE v:%s\n", t->bxe_name,
2497                      (((pci_read_config(dev, PCIR_REVID, 4) &
2498                         0xf0) >> 4) + 'A'),
2499                      (pci_read_config(dev, PCIR_REVID, 4) & 0xf),
2500                      BXE_DRIVER_VERSION);
2501
2502             device_set_desc_copy(dev, descbuf);
2503             free(descbuf, M_TEMP);
2504             return (BUS_PROBE_DEFAULT);
2505         }
2506         t++;
2507     }
2508
2509     return (ENXIO);
2510 }
2511
2512 static void
2513 bxe_init_mutexes(struct bxe_softc *sc)
2514 {
2515 #ifdef BXE_CORE_LOCK_SX
2516     snprintf(sc->core_sx_name, sizeof(sc->core_sx_name),
2517              "bxe%d_core_lock", sc->unit);
2518     sx_init(&sc->core_sx, sc->core_sx_name);
2519 #else
2520     snprintf(sc->core_mtx_name, sizeof(sc->core_mtx_name),
2521              "bxe%d_core_lock", sc->unit);
2522     mtx_init(&sc->core_mtx, sc->core_mtx_name, NULL, MTX_DEF);
2523 #endif
2524
2525     snprintf(sc->sp_mtx_name, sizeof(sc->sp_mtx_name),
2526              "bxe%d_sp_lock", sc->unit);
2527     mtx_init(&sc->sp_mtx, sc->sp_mtx_name, NULL, MTX_DEF);
2528
2529     snprintf(sc->dmae_mtx_name, sizeof(sc->dmae_mtx_name),
2530              "bxe%d_dmae_lock", sc->unit);
2531     mtx_init(&sc->dmae_mtx, sc->dmae_mtx_name, NULL, MTX_DEF);
2532
2533     snprintf(sc->port.phy_mtx_name, sizeof(sc->port.phy_mtx_name),
2534              "bxe%d_phy_lock", sc->unit);
2535     mtx_init(&sc->port.phy_mtx, sc->port.phy_mtx_name, NULL, MTX_DEF);
2536
2537     snprintf(sc->fwmb_mtx_name, sizeof(sc->fwmb_mtx_name),
2538              "bxe%d_fwmb_lock", sc->unit);
2539     mtx_init(&sc->fwmb_mtx, sc->fwmb_mtx_name, NULL, MTX_DEF);
2540
2541     snprintf(sc->print_mtx_name, sizeof(sc->print_mtx_name),
2542              "bxe%d_print_lock", sc->unit);
2543     mtx_init(&(sc->print_mtx), sc->print_mtx_name, NULL, MTX_DEF);
2544
2545     snprintf(sc->stats_mtx_name, sizeof(sc->stats_mtx_name),
2546              "bxe%d_stats_lock", sc->unit);
2547     mtx_init(&(sc->stats_mtx), sc->stats_mtx_name, NULL, MTX_DEF);
2548
2549     snprintf(sc->mcast_mtx_name, sizeof(sc->mcast_mtx_name),
2550              "bxe%d_mcast_lock", sc->unit);
2551     mtx_init(&(sc->mcast_mtx), sc->mcast_mtx_name, NULL, MTX_DEF);
2552 }
2553
2554 static void
2555 bxe_release_mutexes(struct bxe_softc *sc)
2556 {
2557 #ifdef BXE_CORE_LOCK_SX
2558     sx_destroy(&sc->core_sx);
2559 #else
2560     if (mtx_initialized(&sc->core_mtx)) {
2561         mtx_destroy(&sc->core_mtx);
2562     }
2563 #endif
2564
2565     if (mtx_initialized(&sc->sp_mtx)) {
2566         mtx_destroy(&sc->sp_mtx);
2567     }
2568
2569     if (mtx_initialized(&sc->dmae_mtx)) {
2570         mtx_destroy(&sc->dmae_mtx);
2571     }
2572
2573     if (mtx_initialized(&sc->port.phy_mtx)) {
2574         mtx_destroy(&sc->port.phy_mtx);
2575     }
2576
2577     if (mtx_initialized(&sc->fwmb_mtx)) {
2578         mtx_destroy(&sc->fwmb_mtx);
2579     }
2580
2581     if (mtx_initialized(&sc->print_mtx)) {
2582         mtx_destroy(&sc->print_mtx);
2583     }
2584
2585     if (mtx_initialized(&sc->stats_mtx)) {
2586         mtx_destroy(&sc->stats_mtx);
2587     }
2588
2589     if (mtx_initialized(&sc->mcast_mtx)) {
2590         mtx_destroy(&sc->mcast_mtx);
2591     }
2592 }
2593
2594 static void
2595 bxe_tx_disable(struct bxe_softc* sc)
2596 {
2597     struct ifnet *ifp = sc->ifnet;
2598
2599     /* tell the stack the driver is stopped and TX queue is full */
2600     if (ifp != NULL) {
2601         ifp->if_drv_flags = 0;
2602     }
2603 }
2604
2605 static void
2606 bxe_drv_pulse(struct bxe_softc *sc)
2607 {
2608     SHMEM_WR(sc, func_mb[SC_FW_MB_IDX(sc)].drv_pulse_mb,
2609              sc->fw_drv_pulse_wr_seq);
2610 }
2611
2612 static inline uint16_t
2613 bxe_tx_avail(struct bxe_softc *sc,
2614              struct bxe_fastpath *fp)
2615 {
2616     int16_t  used;
2617     uint16_t prod;
2618     uint16_t cons;
2619
2620     prod = fp->tx_bd_prod;
2621     cons = fp->tx_bd_cons;
2622
2623     used = SUB_S16(prod, cons);
2624
2625     return (int16_t)(sc->tx_ring_size) - used;
2626 }
2627
2628 static inline int
2629 bxe_tx_queue_has_work(struct bxe_fastpath *fp)
2630 {
2631     uint16_t hw_cons;
2632
2633     mb(); /* status block fields can change */
2634     hw_cons = le16toh(*fp->tx_cons_sb);
2635     return (hw_cons != fp->tx_pkt_cons);
2636 }
2637
2638 static inline uint8_t
2639 bxe_has_tx_work(struct bxe_fastpath *fp)
2640 {
2641     /* expand this for multi-cos if ever supported */
2642     return (bxe_tx_queue_has_work(fp)) ? TRUE : FALSE;
2643 }
2644
2645 static inline int
2646 bxe_has_rx_work(struct bxe_fastpath *fp)
2647 {
2648     uint16_t rx_cq_cons_sb;
2649
2650     mb(); /* status block fields can change */
2651     rx_cq_cons_sb = le16toh(*fp->rx_cq_cons_sb);
2652     if ((rx_cq_cons_sb & RCQ_MAX) == RCQ_MAX)
2653         rx_cq_cons_sb++;
2654     return (fp->rx_cq_cons != rx_cq_cons_sb);
2655 }
2656
2657 static void
2658 bxe_sp_event(struct bxe_softc    *sc,
2659              struct bxe_fastpath *fp,
2660              union eth_rx_cqe    *rr_cqe)
2661 {
2662     int cid = SW_CID(rr_cqe->ramrod_cqe.conn_and_cmd_data);
2663     int command = CQE_CMD(rr_cqe->ramrod_cqe.conn_and_cmd_data);
2664     enum ecore_queue_cmd drv_cmd = ECORE_Q_CMD_MAX;
2665     struct ecore_queue_sp_obj *q_obj = &BXE_SP_OBJ(sc, fp).q_obj;
2666
2667     BLOGD(sc, DBG_SP, "fp=%d cid=%d got ramrod #%d state is %x type is %d\n",
2668           fp->index, cid, command, sc->state, rr_cqe->ramrod_cqe.ramrod_type);
2669
2670     switch (command) {
2671     case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
2672         BLOGD(sc, DBG_SP, "got UPDATE ramrod. CID %d\n", cid);
2673         drv_cmd = ECORE_Q_CMD_UPDATE;
2674         break;
2675
2676     case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
2677         BLOGD(sc, DBG_SP, "got MULTI[%d] setup ramrod\n", cid);
2678         drv_cmd = ECORE_Q_CMD_SETUP;
2679         break;
2680
2681     case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
2682         BLOGD(sc, DBG_SP, "got MULTI[%d] tx-only setup ramrod\n", cid);
2683         drv_cmd = ECORE_Q_CMD_SETUP_TX_ONLY;
2684         break;
2685
2686     case (RAMROD_CMD_ID_ETH_HALT):
2687         BLOGD(sc, DBG_SP, "got MULTI[%d] halt ramrod\n", cid);
2688         drv_cmd = ECORE_Q_CMD_HALT;
2689         break;
2690
2691     case (RAMROD_CMD_ID_ETH_TERMINATE):
2692         BLOGD(sc, DBG_SP, "got MULTI[%d] teminate ramrod\n", cid);
2693         drv_cmd = ECORE_Q_CMD_TERMINATE;
2694         break;
2695
2696     case (RAMROD_CMD_ID_ETH_EMPTY):
2697         BLOGD(sc, DBG_SP, "got MULTI[%d] empty ramrod\n", cid);
2698         drv_cmd = ECORE_Q_CMD_EMPTY;
2699         break;
2700
2701     default:
2702         BLOGD(sc, DBG_SP, "ERROR: unexpected MC reply (%d) on fp[%d]\n",
2703               command, fp->index);
2704         return;
2705     }
2706
2707     if ((drv_cmd != ECORE_Q_CMD_MAX) &&
2708         q_obj->complete_cmd(sc, q_obj, drv_cmd)) {
2709         /*
2710          * q_obj->complete_cmd() failure means that this was
2711          * an unexpected completion.
2712          *
2713          * In this case we don't want to increase the sc->spq_left
2714          * because apparently we haven't sent this command the first
2715          * place.
2716          */
2717         // bxe_panic(sc, ("Unexpected SP completion\n"));
2718         return;
2719     }
2720
2721     atomic_add_acq_long(&sc->cq_spq_left, 1);
2722
2723     BLOGD(sc, DBG_SP, "sc->cq_spq_left 0x%lx\n",
2724           atomic_load_acq_long(&sc->cq_spq_left));
2725 }
2726
2727 /*
2728  * The current mbuf is part of an aggregation. Move the mbuf into the TPA
2729  * aggregation queue, put an empty mbuf back onto the receive chain, and mark
2730  * the current aggregation queue as in-progress.
2731  */
2732 static void
2733 bxe_tpa_start(struct bxe_softc            *sc,
2734               struct bxe_fastpath         *fp,
2735               uint16_t                    queue,
2736               uint16_t                    cons,
2737               uint16_t                    prod,
2738               struct eth_fast_path_rx_cqe *cqe)
2739 {
2740     struct bxe_sw_rx_bd tmp_bd;
2741     struct bxe_sw_rx_bd *rx_buf;
2742     struct eth_rx_bd *rx_bd;
2743     int max_agg_queues;
2744     struct bxe_sw_tpa_info *tpa_info = &fp->rx_tpa_info[queue];
2745     uint16_t index;
2746
2747     BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA START "
2748                        "cons=%d prod=%d\n",
2749           fp->index, queue, cons, prod);
2750
2751     max_agg_queues = MAX_AGG_QS(sc);
2752
2753     KASSERT((queue < max_agg_queues),
2754             ("fp[%02d] invalid aggr queue (%d >= %d)!",
2755              fp->index, queue, max_agg_queues));
2756
2757     KASSERT((tpa_info->state == BXE_TPA_STATE_STOP),
2758             ("fp[%02d].tpa[%02d] starting aggr on queue not stopped!",
2759              fp->index, queue));
2760
2761     /* copy the existing mbuf and mapping from the TPA pool */
2762     tmp_bd = tpa_info->bd;
2763
2764     if (tmp_bd.m == NULL) {
2765         uint32_t *tmp;
2766
2767         tmp = (uint32_t *)cqe;
2768
2769         BLOGE(sc, "fp[%02d].tpa[%02d] cons[%d] prod[%d]mbuf not allocated!\n",
2770               fp->index, queue, cons, prod);
2771         BLOGE(sc, "cqe [0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x]\n",
2772             *tmp, *(tmp+1), *(tmp+2), *(tmp+3), *(tmp+4), *(tmp+5), *(tmp+6), *(tmp+7));
2773
2774         /* XXX Error handling? */
2775         return;
2776     }
2777
2778     /* change the TPA queue to the start state */
2779     tpa_info->state            = BXE_TPA_STATE_START;
2780     tpa_info->placement_offset = cqe->placement_offset;
2781     tpa_info->parsing_flags    = le16toh(cqe->pars_flags.flags);
2782     tpa_info->vlan_tag         = le16toh(cqe->vlan_tag);
2783     tpa_info->len_on_bd        = le16toh(cqe->len_on_bd);
2784
2785     fp->rx_tpa_queue_used |= (1 << queue);
2786
2787     /*
2788      * If all the buffer descriptors are filled with mbufs then fill in
2789      * the current consumer index with a new BD. Else if a maximum Rx
2790      * buffer limit is imposed then fill in the next producer index.
2791      */
2792     index = (sc->max_rx_bufs != RX_BD_USABLE) ?
2793                 prod : cons;
2794
2795     /* move the received mbuf and mapping to TPA pool */
2796     tpa_info->bd = fp->rx_mbuf_chain[cons];
2797
2798     /* release any existing RX BD mbuf mappings */
2799     if (cons != index) {
2800         rx_buf = &fp->rx_mbuf_chain[cons];
2801
2802         if (rx_buf->m_map != NULL) {
2803             bus_dmamap_sync(fp->rx_mbuf_tag, rx_buf->m_map,
2804                             BUS_DMASYNC_POSTREAD);
2805             bus_dmamap_unload(fp->rx_mbuf_tag, rx_buf->m_map);
2806         }
2807
2808         /*
2809          * We get here when the maximum number of rx buffers is less than
2810          * RX_BD_USABLE. The mbuf is already saved above so it's OK to NULL
2811          * it out here without concern of a memory leak.
2812          */
2813         fp->rx_mbuf_chain[cons].m = NULL;
2814     }
2815
2816     /* update the Rx SW BD with the mbuf info from the TPA pool */
2817     fp->rx_mbuf_chain[index] = tmp_bd;
2818
2819     /* update the Rx BD with the empty mbuf phys address from the TPA pool */
2820     rx_bd = &fp->rx_chain[index];
2821     rx_bd->addr_hi = htole32(U64_HI(tpa_info->seg.ds_addr));
2822     rx_bd->addr_lo = htole32(U64_LO(tpa_info->seg.ds_addr));
2823 }
2824
2825 /*
2826  * When a TPA aggregation is completed, loop through the individual mbufs
2827  * of the aggregation, combining them into a single mbuf which will be sent
2828  * up the stack. Refill all freed SGEs with mbufs as we go along.
2829  */
2830 static int
2831 bxe_fill_frag_mbuf(struct bxe_softc          *sc,
2832                    struct bxe_fastpath       *fp,
2833                    struct bxe_sw_tpa_info    *tpa_info,
2834                    uint16_t                  queue,
2835                    uint16_t                  pages,
2836                    struct mbuf               *m,
2837                                struct eth_end_agg_rx_cqe *cqe,
2838                    uint16_t                  cqe_idx)
2839 {
2840     struct mbuf *m_frag;
2841     uint32_t frag_len, frag_size, i;
2842     uint16_t sge_idx;
2843     int rc = 0;
2844     int j;
2845
2846     frag_size = le16toh(cqe->pkt_len) - tpa_info->len_on_bd;
2847
2848     BLOGD(sc, DBG_LRO,
2849           "fp[%02d].tpa[%02d] TPA fill len_on_bd=%d frag_size=%d pages=%d\n",
2850           fp->index, queue, tpa_info->len_on_bd, frag_size, pages);
2851
2852     /* make sure the aggregated frame is not too big to handle */
2853     if (pages > 8 * PAGES_PER_SGE) {
2854
2855         uint32_t *tmp = (uint32_t *)cqe;
2856
2857         BLOGE(sc, "fp[%02d].sge[0x%04x] has too many pages (%d)! "
2858                   "pkt_len=%d len_on_bd=%d frag_size=%d\n",
2859               fp->index, cqe_idx, pages, le16toh(cqe->pkt_len),
2860               tpa_info->len_on_bd, frag_size);
2861
2862         BLOGE(sc, "cqe [0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x]\n",
2863             *tmp, *(tmp+1), *(tmp+2), *(tmp+3), *(tmp+4), *(tmp+5), *(tmp+6), *(tmp+7));
2864
2865         bxe_panic(sc, ("sge page count error\n"));
2866         return (EINVAL);
2867     }
2868
2869     /*
2870      * Scan through the scatter gather list pulling individual mbufs into a
2871      * single mbuf for the host stack.
2872      */
2873     for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
2874         sge_idx = RX_SGE(le16toh(cqe->sgl_or_raw_data.sgl[j]));
2875
2876         /*
2877          * Firmware gives the indices of the SGE as if the ring is an array
2878          * (meaning that the "next" element will consume 2 indices).
2879          */
2880         frag_len = min(frag_size, (uint32_t)(SGE_PAGES));
2881
2882         BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA fill i=%d j=%d "
2883                            "sge_idx=%d frag_size=%d frag_len=%d\n",
2884               fp->index, queue, i, j, sge_idx, frag_size, frag_len);
2885
2886         m_frag = fp->rx_sge_mbuf_chain[sge_idx].m;
2887
2888         /* allocate a new mbuf for the SGE */
2889         rc = bxe_alloc_rx_sge_mbuf(fp, sge_idx);
2890         if (rc) {
2891             /* Leave all remaining SGEs in the ring! */
2892             return (rc);
2893         }
2894
2895         /* update the fragment length */
2896         m_frag->m_len = frag_len;
2897
2898         /* concatenate the fragment to the head mbuf */
2899         m_cat(m, m_frag);
2900         fp->eth_q_stats.mbuf_alloc_sge--;
2901
2902         /* update the TPA mbuf size and remaining fragment size */
2903         m->m_pkthdr.len += frag_len;
2904         frag_size -= frag_len;
2905     }
2906
2907     BLOGD(sc, DBG_LRO,
2908           "fp[%02d].tpa[%02d] TPA fill done frag_size=%d\n",
2909           fp->index, queue, frag_size);
2910
2911     return (rc);
2912 }
2913
2914 static inline void
2915 bxe_clear_sge_mask_next_elems(struct bxe_fastpath *fp)
2916 {
2917     int i, j;
2918
2919     for (i = 1; i <= RX_SGE_NUM_PAGES; i++) {
2920         int idx = RX_SGE_TOTAL_PER_PAGE * i - 1;
2921
2922         for (j = 0; j < 2; j++) {
2923             BIT_VEC64_CLEAR_BIT(fp->sge_mask, idx);
2924             idx--;
2925         }
2926     }
2927 }
2928
2929 static inline void
2930 bxe_init_sge_ring_bit_mask(struct bxe_fastpath *fp)
2931 {
2932     /* set the mask to all 1's, it's faster to compare to 0 than to 0xf's */
2933     memset(fp->sge_mask, 0xff, sizeof(fp->sge_mask));
2934
2935     /*
2936      * Clear the two last indices in the page to 1. These are the indices that
2937      * correspond to the "next" element, hence will never be indicated and
2938      * should be removed from the calculations.
2939      */
2940     bxe_clear_sge_mask_next_elems(fp);
2941 }
2942
2943 static inline void
2944 bxe_update_last_max_sge(struct bxe_fastpath *fp,
2945                         uint16_t            idx)
2946 {
2947     uint16_t last_max = fp->last_max_sge;
2948
2949     if (SUB_S16(idx, last_max) > 0) {
2950         fp->last_max_sge = idx;
2951     }
2952 }
2953
2954 static inline void
2955 bxe_update_sge_prod(struct bxe_softc          *sc,
2956                     struct bxe_fastpath       *fp,
2957                     uint16_t                  sge_len,
2958                     union eth_sgl_or_raw_data *cqe)
2959 {
2960     uint16_t last_max, last_elem, first_elem;
2961     uint16_t delta = 0;
2962     uint16_t i;
2963
2964     if (!sge_len) {
2965         return;
2966     }
2967
2968     /* first mark all used pages */
2969     for (i = 0; i < sge_len; i++) {
2970         BIT_VEC64_CLEAR_BIT(fp->sge_mask,
2971                             RX_SGE(le16toh(cqe->sgl[i])));
2972     }
2973
2974     BLOGD(sc, DBG_LRO,
2975           "fp[%02d] fp_cqe->sgl[%d] = %d\n",
2976           fp->index, sge_len - 1,
2977           le16toh(cqe->sgl[sge_len - 1]));
2978
2979     /* assume that the last SGE index is the biggest */
2980     bxe_update_last_max_sge(fp,
2981                             le16toh(cqe->sgl[sge_len - 1]));
2982
2983     last_max = RX_SGE(fp->last_max_sge);
2984     last_elem = last_max >> BIT_VEC64_ELEM_SHIFT;
2985     first_elem = RX_SGE(fp->rx_sge_prod) >> BIT_VEC64_ELEM_SHIFT;
2986
2987     /* if ring is not full */
2988     if (last_elem + 1 != first_elem) {
2989         last_elem++;
2990     }
2991
2992     /* now update the prod */
2993     for (i = first_elem; i != last_elem; i = RX_SGE_NEXT_MASK_ELEM(i)) {
2994         if (__predict_true(fp->sge_mask[i])) {
2995             break;
2996         }
2997
2998         fp->sge_mask[i] = BIT_VEC64_ELEM_ONE_MASK;
2999         delta += BIT_VEC64_ELEM_SZ;
3000     }
3001
3002     if (delta > 0) {
3003         fp->rx_sge_prod += delta;
3004         /* clear page-end entries */
3005         bxe_clear_sge_mask_next_elems(fp);
3006     }
3007
3008     BLOGD(sc, DBG_LRO,
3009           "fp[%02d] fp->last_max_sge=%d fp->rx_sge_prod=%d\n",
3010           fp->index, fp->last_max_sge, fp->rx_sge_prod);
3011 }
3012
3013 /*
3014  * The aggregation on the current TPA queue has completed. Pull the individual
3015  * mbuf fragments together into a single mbuf, perform all necessary checksum
3016  * calculations, and send the resuting mbuf to the stack.
3017  */
3018 static void
3019 bxe_tpa_stop(struct bxe_softc          *sc,
3020              struct bxe_fastpath       *fp,
3021              struct bxe_sw_tpa_info    *tpa_info,
3022              uint16_t                  queue,
3023              uint16_t                  pages,
3024                          struct eth_end_agg_rx_cqe *cqe,
3025              uint16_t                  cqe_idx)
3026 {
3027     struct ifnet *ifp = sc->ifnet;
3028     struct mbuf *m;
3029     int rc = 0;
3030
3031     BLOGD(sc, DBG_LRO,
3032           "fp[%02d].tpa[%02d] pad=%d pkt_len=%d pages=%d vlan=%d\n",
3033           fp->index, queue, tpa_info->placement_offset,
3034           le16toh(cqe->pkt_len), pages, tpa_info->vlan_tag);
3035
3036     m = tpa_info->bd.m;
3037
3038     /* allocate a replacement before modifying existing mbuf */
3039     rc = bxe_alloc_rx_tpa_mbuf(fp, queue);
3040     if (rc) {
3041         /* drop the frame and log an error */
3042         fp->eth_q_stats.rx_soft_errors++;
3043         goto bxe_tpa_stop_exit;
3044     }
3045
3046     /* we have a replacement, fixup the current mbuf */
3047     m_adj(m, tpa_info->placement_offset);
3048     m->m_pkthdr.len = m->m_len = tpa_info->len_on_bd;
3049
3050     /* mark the checksums valid (taken care of by the firmware) */
3051     fp->eth_q_stats.rx_ofld_frames_csum_ip++;
3052     fp->eth_q_stats.rx_ofld_frames_csum_tcp_udp++;
3053     m->m_pkthdr.csum_data = 0xffff;
3054     m->m_pkthdr.csum_flags |= (CSUM_IP_CHECKED |
3055                                CSUM_IP_VALID   |
3056                                CSUM_DATA_VALID |
3057                                CSUM_PSEUDO_HDR);
3058
3059     /* aggregate all of the SGEs into a single mbuf */
3060     rc = bxe_fill_frag_mbuf(sc, fp, tpa_info, queue, pages, m, cqe, cqe_idx);
3061     if (rc) {
3062         /* drop the packet and log an error */
3063         fp->eth_q_stats.rx_soft_errors++;
3064         m_freem(m);
3065     } else {
3066         if (tpa_info->parsing_flags & PARSING_FLAGS_INNER_VLAN_EXIST) {
3067             m->m_pkthdr.ether_vtag = tpa_info->vlan_tag;
3068             m->m_flags |= M_VLANTAG;
3069         }
3070
3071         /* assign packet to this interface interface */
3072         m->m_pkthdr.rcvif = ifp;
3073
3074 #if __FreeBSD_version >= 800000
3075         /* specify what RSS queue was used for this flow */
3076         m->m_pkthdr.flowid = fp->index;
3077         m->m_flags |= M_FLOWID;
3078 #endif
3079
3080         ifp->if_ipackets++;
3081         fp->eth_q_stats.rx_tpa_pkts++;
3082
3083         /* pass the frame to the stack */
3084         (*ifp->if_input)(ifp, m);
3085     }
3086
3087     /* we passed an mbuf up the stack or dropped the frame */
3088     fp->eth_q_stats.mbuf_alloc_tpa--;
3089
3090 bxe_tpa_stop_exit:
3091
3092     fp->rx_tpa_info[queue].state = BXE_TPA_STATE_STOP;
3093     fp->rx_tpa_queue_used &= ~(1 << queue);
3094 }
3095
3096 static uint8_t
3097 bxe_service_rxsgl(
3098                  struct bxe_fastpath *fp,
3099                  uint16_t len,
3100                  uint16_t lenonbd,
3101                  struct mbuf *m,
3102                  struct eth_fast_path_rx_cqe *cqe_fp)
3103 {
3104     struct mbuf *m_frag;
3105     uint16_t frags, frag_len;
3106     uint16_t sge_idx = 0;
3107     uint16_t j;
3108     uint8_t i, rc = 0;
3109     uint32_t frag_size;
3110
3111     /* adjust the mbuf */
3112     m->m_len = lenonbd;
3113
3114     frag_size =  len - lenonbd;
3115     frags = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
3116
3117     for (i = 0, j = 0; i < frags; i += PAGES_PER_SGE, j++) {
3118         sge_idx = RX_SGE(le16toh(cqe_fp->sgl_or_raw_data.sgl[j]));
3119
3120         m_frag = fp->rx_sge_mbuf_chain[sge_idx].m;
3121         frag_len = min(frag_size, (uint32_t)(SGE_PAGE_SIZE));
3122         m_frag->m_len = frag_len;
3123
3124        /* allocate a new mbuf for the SGE */
3125         rc = bxe_alloc_rx_sge_mbuf(fp, sge_idx);
3126         if (rc) {
3127             /* Leave all remaining SGEs in the ring! */
3128             return (rc);
3129         }
3130         fp->eth_q_stats.mbuf_alloc_sge--;
3131
3132         /* concatenate the fragment to the head mbuf */
3133         m_cat(m, m_frag);
3134
3135         frag_size -= frag_len;
3136     }
3137
3138     bxe_update_sge_prod(fp->sc, fp, frags, &cqe_fp->sgl_or_raw_data);
3139
3140     return rc;
3141 }
3142
3143 static uint8_t
3144 bxe_rxeof(struct bxe_softc    *sc,
3145           struct bxe_fastpath *fp)
3146 {
3147     struct ifnet *ifp = sc->ifnet;
3148     uint16_t bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
3149     uint16_t hw_cq_cons, sw_cq_cons, sw_cq_prod;
3150     int rx_pkts = 0;
3151     int rc = 0;
3152
3153     BXE_FP_RX_LOCK(fp);
3154
3155     /* CQ "next element" is of the size of the regular element */
3156     hw_cq_cons = le16toh(*fp->rx_cq_cons_sb);
3157     if ((hw_cq_cons & RCQ_USABLE_PER_PAGE) == RCQ_USABLE_PER_PAGE) {
3158         hw_cq_cons++;
3159     }
3160
3161     bd_cons = fp->rx_bd_cons;
3162     bd_prod = fp->rx_bd_prod;
3163     bd_prod_fw = bd_prod;
3164     sw_cq_cons = fp->rx_cq_cons;
3165     sw_cq_prod = fp->rx_cq_prod;
3166
3167     /*
3168      * Memory barrier necessary as speculative reads of the rx
3169      * buffer can be ahead of the index in the status block
3170      */
3171     rmb();
3172
3173     BLOGD(sc, DBG_RX,
3174           "fp[%02d] Rx START hw_cq_cons=%u sw_cq_cons=%u\n",
3175           fp->index, hw_cq_cons, sw_cq_cons);
3176
3177     while (sw_cq_cons != hw_cq_cons) {
3178         struct bxe_sw_rx_bd *rx_buf = NULL;
3179         union eth_rx_cqe *cqe;
3180         struct eth_fast_path_rx_cqe *cqe_fp;
3181         uint8_t cqe_fp_flags;
3182         enum eth_rx_cqe_type cqe_fp_type;
3183         uint16_t len, lenonbd,  pad;
3184         struct mbuf *m = NULL;
3185
3186         comp_ring_cons = RCQ(sw_cq_cons);
3187         bd_prod = RX_BD(bd_prod);
3188         bd_cons = RX_BD(bd_cons);
3189
3190         cqe          = &fp->rcq_chain[comp_ring_cons];
3191         cqe_fp       = &cqe->fast_path_cqe;
3192         cqe_fp_flags = cqe_fp->type_error_flags;
3193         cqe_fp_type  = cqe_fp_flags & ETH_FAST_PATH_RX_CQE_TYPE;
3194
3195         BLOGD(sc, DBG_RX,
3196               "fp[%02d] Rx hw_cq_cons=%d hw_sw_cons=%d "
3197               "BD prod=%d cons=%d CQE type=0x%x err=0x%x "
3198               "status=0x%x rss_hash=0x%x vlan=0x%x len=%u lenonbd=%u\n",
3199               fp->index,
3200               hw_cq_cons,
3201               sw_cq_cons,
3202               bd_prod,
3203               bd_cons,
3204               CQE_TYPE(cqe_fp_flags),
3205               cqe_fp_flags,
3206               cqe_fp->status_flags,
3207               le32toh(cqe_fp->rss_hash_result),
3208               le16toh(cqe_fp->vlan_tag),
3209               le16toh(cqe_fp->pkt_len_or_gro_seg_len),
3210               le16toh(cqe_fp->len_on_bd));
3211
3212         /* is this a slowpath msg? */
3213         if (__predict_false(CQE_TYPE_SLOW(cqe_fp_type))) {
3214             bxe_sp_event(sc, fp, cqe);
3215             goto next_cqe;
3216         }
3217
3218         rx_buf = &fp->rx_mbuf_chain[bd_cons];
3219
3220         if (!CQE_TYPE_FAST(cqe_fp_type)) {
3221             struct bxe_sw_tpa_info *tpa_info;
3222             uint16_t frag_size, pages;
3223             uint8_t queue;
3224
3225             if (CQE_TYPE_START(cqe_fp_type)) {
3226                 bxe_tpa_start(sc, fp, cqe_fp->queue_index,
3227                               bd_cons, bd_prod, cqe_fp);
3228                 m = NULL; /* packet not ready yet */
3229                 goto next_rx;
3230             }
3231
3232             KASSERT(CQE_TYPE_STOP(cqe_fp_type),
3233                     ("CQE type is not STOP! (0x%x)\n", cqe_fp_type));
3234
3235             queue = cqe->end_agg_cqe.queue_index;
3236             tpa_info = &fp->rx_tpa_info[queue];
3237
3238             BLOGD(sc, DBG_LRO, "fp[%02d].tpa[%02d] TPA STOP\n",
3239                   fp->index, queue);
3240
3241             frag_size = (le16toh(cqe->end_agg_cqe.pkt_len) -
3242                          tpa_info->len_on_bd);
3243             pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
3244
3245             bxe_tpa_stop(sc, fp, tpa_info, queue, pages,
3246                          &cqe->end_agg_cqe, comp_ring_cons);
3247
3248             bxe_update_sge_prod(sc, fp, pages, &cqe->end_agg_cqe.sgl_or_raw_data);
3249
3250             goto next_cqe;
3251         }
3252
3253         /* non TPA */
3254
3255         /* is this an error packet? */
3256         if (__predict_false(cqe_fp_flags &
3257                             ETH_FAST_PATH_RX_CQE_PHY_DECODE_ERR_FLG)) {
3258             BLOGE(sc, "flags 0x%x rx packet %u\n", cqe_fp_flags, sw_cq_cons);
3259             fp->eth_q_stats.rx_soft_errors++;
3260             goto next_rx;
3261         }
3262
3263         len = le16toh(cqe_fp->pkt_len_or_gro_seg_len);
3264         lenonbd = le16toh(cqe_fp->len_on_bd);
3265         pad = cqe_fp->placement_offset;
3266
3267         m = rx_buf->m;
3268
3269         if (__predict_false(m == NULL)) {
3270             BLOGE(sc, "No mbuf in rx chain descriptor %d for fp[%02d]\n",
3271                   bd_cons, fp->index);
3272             goto next_rx;
3273         }
3274
3275         /* XXX double copy if packet length under a threshold */
3276
3277         /*
3278          * If all the buffer descriptors are filled with mbufs then fill in
3279          * the current consumer index with a new BD. Else if a maximum Rx
3280          * buffer limit is imposed then fill in the next producer index.
3281          */
3282         rc = bxe_alloc_rx_bd_mbuf(fp, bd_cons,
3283                                   (sc->max_rx_bufs != RX_BD_USABLE) ?
3284                                       bd_prod : bd_cons);
3285         if (rc != 0) {
3286
3287             /* we simply reuse the received mbuf and don't post it to the stack */
3288             m = NULL;
3289
3290             BLOGE(sc, "mbuf alloc fail for fp[%02d] rx chain (%d)\n",
3291                   fp->index, rc);
3292             fp->eth_q_stats.rx_soft_errors++;
3293
3294             if (sc->max_rx_bufs != RX_BD_USABLE) {
3295                 /* copy this consumer index to the producer index */
3296                 memcpy(&fp->rx_mbuf_chain[bd_prod], rx_buf,
3297                        sizeof(struct bxe_sw_rx_bd));
3298                 memset(rx_buf, 0, sizeof(struct bxe_sw_rx_bd));
3299             }
3300
3301             goto next_rx;
3302         }
3303
3304         /* current mbuf was detached from the bd */
3305         fp->eth_q_stats.mbuf_alloc_rx--;
3306
3307         /* we allocated a replacement mbuf, fixup the current one */
3308         m_adj(m, pad);
3309         m->m_pkthdr.len = m->m_len = len;
3310
3311         if ((len > 60) && (len > lenonbd)) {
3312             fp->eth_q_stats.rx_bxe_service_rxsgl++;
3313             rc = bxe_service_rxsgl(fp, len, lenonbd, m, cqe_fp);
3314             if (rc)
3315                 break;
3316             fp->eth_q_stats.rx_jumbo_sge_pkts++;
3317         } else if (lenonbd < len) {
3318             fp->eth_q_stats.rx_erroneous_jumbo_sge_pkts++;
3319         }
3320
3321         /* assign packet to this interface interface */
3322         m->m_pkthdr.rcvif = ifp;
3323
3324         /* assume no hardware checksum has complated */
3325         m->m_pkthdr.csum_flags = 0;
3326
3327         /* validate checksum if offload enabled */
3328         if (ifp->if_capenable & IFCAP_RXCSUM) {
3329             /* check for a valid IP frame */
3330             if (!(cqe->fast_path_cqe.status_flags &
3331                   ETH_FAST_PATH_RX_CQE_IP_XSUM_NO_VALIDATION_FLG)) {
3332                 m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
3333                 if (__predict_false(cqe_fp_flags &
3334                                     ETH_FAST_PATH_RX_CQE_IP_BAD_XSUM_FLG)) {
3335                     fp->eth_q_stats.rx_hw_csum_errors++;
3336                 } else {
3337                     fp->eth_q_stats.rx_ofld_frames_csum_ip++;
3338                     m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
3339                 }
3340             }
3341
3342             /* check for a valid TCP/UDP frame */
3343             if (!(cqe->fast_path_cqe.status_flags &
3344                   ETH_FAST_PATH_RX_CQE_L4_XSUM_NO_VALIDATION_FLG)) {
3345                 if (__predict_false(cqe_fp_flags &
3346                                     ETH_FAST_PATH_RX_CQE_L4_BAD_XSUM_FLG)) {
3347                     fp->eth_q_stats.rx_hw_csum_errors++;
3348                 } else {
3349                     fp->eth_q_stats.rx_ofld_frames_csum_tcp_udp++;
3350                     m->m_pkthdr.csum_data = 0xFFFF;
3351                     m->m_pkthdr.csum_flags |= (CSUM_DATA_VALID |
3352                                                CSUM_PSEUDO_HDR);
3353                 }
3354             }
3355         }
3356
3357         /* if there is a VLAN tag then flag that info */
3358         if (cqe->fast_path_cqe.pars_flags.flags & PARSING_FLAGS_INNER_VLAN_EXIST) {
3359             m->m_pkthdr.ether_vtag = cqe->fast_path_cqe.vlan_tag;
3360             m->m_flags |= M_VLANTAG;
3361         }
3362
3363 #if __FreeBSD_version >= 800000
3364         /* specify what RSS queue was used for this flow */
3365         m->m_pkthdr.flowid = fp->index;
3366         m->m_flags |= M_FLOWID;
3367 #endif
3368
3369 next_rx:
3370
3371         bd_cons    = RX_BD_NEXT(bd_cons);
3372         bd_prod    = RX_BD_NEXT(bd_prod);
3373         bd_prod_fw = RX_BD_NEXT(bd_prod_fw);
3374
3375         /* pass the frame to the stack */
3376         if (__predict_true(m != NULL)) {
3377             ifp->if_ipackets++;
3378             rx_pkts++;
3379             (*ifp->if_input)(ifp, m);
3380         }
3381
3382 next_cqe:
3383
3384         sw_cq_prod = RCQ_NEXT(sw_cq_prod);
3385         sw_cq_cons = RCQ_NEXT(sw_cq_cons);
3386
3387         /* limit spinning on the queue */
3388         if (rc != 0)
3389             break;
3390
3391         if (rx_pkts == sc->rx_budget) {
3392             fp->eth_q_stats.rx_budget_reached++;
3393             break;
3394         }
3395     } /* while work to do */
3396
3397     fp->rx_bd_cons = bd_cons;
3398     fp->rx_bd_prod = bd_prod_fw;
3399     fp->rx_cq_cons = sw_cq_cons;
3400     fp->rx_cq_prod = sw_cq_prod;
3401
3402     /* Update producers */
3403     bxe_update_rx_prod(sc, fp, bd_prod_fw, sw_cq_prod, fp->rx_sge_prod);
3404
3405     fp->eth_q_stats.rx_pkts += rx_pkts;
3406     fp->eth_q_stats.rx_calls++;
3407
3408     BXE_FP_RX_UNLOCK(fp);
3409
3410     return (sw_cq_cons != hw_cq_cons);
3411 }
3412
3413 static uint16_t
3414 bxe_free_tx_pkt(struct bxe_softc    *sc,
3415                 struct bxe_fastpath *fp,
3416                 uint16_t            idx)
3417 {
3418     struct bxe_sw_tx_bd *tx_buf = &fp->tx_mbuf_chain[idx];
3419     struct eth_tx_start_bd *tx_start_bd;
3420     uint16_t bd_idx = TX_BD(tx_buf->first_bd);
3421     uint16_t new_cons;
3422     int nbd;
3423
3424     /* unmap the mbuf from non-paged memory */
3425     bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
3426
3427     tx_start_bd = &fp->tx_chain[bd_idx].start_bd;
3428     nbd = le16toh(tx_start_bd->nbd) - 1;
3429
3430     new_cons = (tx_buf->first_bd + nbd);
3431
3432     /* free the mbuf */
3433     if (__predict_true(tx_buf->m != NULL)) {
3434         m_freem(tx_buf->m);
3435         fp->eth_q_stats.mbuf_alloc_tx--;
3436     } else {
3437         fp->eth_q_stats.tx_chain_lost_mbuf++;
3438     }
3439
3440     tx_buf->m = NULL;
3441     tx_buf->first_bd = 0;
3442
3443     return (new_cons);
3444 }
3445
3446 /* transmit timeout watchdog */
3447 static int
3448 bxe_watchdog(struct bxe_softc    *sc,
3449              struct bxe_fastpath *fp)
3450 {
3451     BXE_FP_TX_LOCK(fp);
3452
3453     if ((fp->watchdog_timer == 0) || (--fp->watchdog_timer)) {
3454         BXE_FP_TX_UNLOCK(fp);
3455         return (0);
3456     }
3457
3458     BLOGE(sc, "TX watchdog timeout on fp[%02d], resetting!\n", fp->index);
3459
3460     BXE_FP_TX_UNLOCK(fp);
3461
3462     atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_REINIT);
3463     taskqueue_enqueue(sc->chip_tq, &sc->chip_tq_task);
3464
3465     return (-1);
3466 }
3467
3468 /* processes transmit completions */
3469 static uint8_t
3470 bxe_txeof(struct bxe_softc    *sc,
3471           struct bxe_fastpath *fp)
3472 {
3473     struct ifnet *ifp = sc->ifnet;
3474     uint16_t bd_cons, hw_cons, sw_cons, pkt_cons;
3475     uint16_t tx_bd_avail;
3476
3477     BXE_FP_TX_LOCK_ASSERT(fp);
3478
3479     bd_cons = fp->tx_bd_cons;
3480     hw_cons = le16toh(*fp->tx_cons_sb);
3481     sw_cons = fp->tx_pkt_cons;
3482
3483     while (sw_cons != hw_cons) {
3484         pkt_cons = TX_BD(sw_cons);
3485
3486         BLOGD(sc, DBG_TX,
3487               "TX: fp[%d]: hw_cons=%u sw_cons=%u pkt_cons=%u\n",
3488               fp->index, hw_cons, sw_cons, pkt_cons);
3489
3490         bd_cons = bxe_free_tx_pkt(sc, fp, pkt_cons);
3491
3492         sw_cons++;
3493     }
3494
3495     fp->tx_pkt_cons = sw_cons;
3496     fp->tx_bd_cons  = bd_cons;
3497
3498     BLOGD(sc, DBG_TX,
3499           "TX done: fp[%d]: hw_cons=%u sw_cons=%u sw_prod=%u\n",
3500           fp->index, hw_cons, fp->tx_pkt_cons, fp->tx_pkt_prod);
3501
3502     mb();
3503
3504     tx_bd_avail = bxe_tx_avail(sc, fp);
3505
3506     if (tx_bd_avail < BXE_TX_CLEANUP_THRESHOLD) {
3507         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
3508     } else {
3509         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
3510     }
3511
3512     if (fp->tx_pkt_prod != fp->tx_pkt_cons) {
3513         /* reset the watchdog timer if there are pending transmits */
3514         fp->watchdog_timer = BXE_TX_TIMEOUT;
3515         return (TRUE);
3516     } else {
3517         /* clear watchdog when there are no pending transmits */
3518         fp->watchdog_timer = 0;
3519         return (FALSE);
3520     }
3521 }
3522
3523 static void
3524 bxe_drain_tx_queues(struct bxe_softc *sc)
3525 {
3526     struct bxe_fastpath *fp;
3527     int i, count;
3528
3529     /* wait until all TX fastpath tasks have completed */
3530     for (i = 0; i < sc->num_queues; i++) {
3531         fp = &sc->fp[i];
3532
3533         count = 1000;
3534
3535         while (bxe_has_tx_work(fp)) {
3536
3537             BXE_FP_TX_LOCK(fp);
3538             bxe_txeof(sc, fp);
3539             BXE_FP_TX_UNLOCK(fp);
3540
3541             if (count == 0) {
3542                 BLOGE(sc, "Timeout waiting for fp[%d] "
3543                           "transmits to complete!\n", i);
3544                 bxe_panic(sc, ("tx drain failure\n"));
3545                 return;
3546             }
3547
3548             count--;
3549             DELAY(1000);
3550             rmb();
3551         }
3552     }
3553
3554     return;
3555 }
3556
3557 static int
3558 bxe_del_all_macs(struct bxe_softc          *sc,
3559                  struct ecore_vlan_mac_obj *mac_obj,
3560                  int                       mac_type,
3561                  uint8_t                   wait_for_comp)
3562 {
3563     unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
3564     int rc;
3565
3566     /* wait for completion of requested */
3567     if (wait_for_comp) {
3568         bxe_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
3569     }
3570
3571     /* Set the mac type of addresses we want to clear */
3572     bxe_set_bit(mac_type, &vlan_mac_flags);
3573
3574     rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
3575     if (rc < 0) {
3576         BLOGE(sc, "Failed to delete MACs (%d) mac_type %d wait_for_comp 0x%x\n",
3577             rc, mac_type, wait_for_comp);
3578     }
3579
3580     return (rc);
3581 }
3582
3583 static int
3584 bxe_fill_accept_flags(struct bxe_softc *sc,
3585                       uint32_t         rx_mode,
3586                       unsigned long    *rx_accept_flags,
3587                       unsigned long    *tx_accept_flags)
3588 {
3589     /* Clear the flags first */
3590     *rx_accept_flags = 0;
3591     *tx_accept_flags = 0;
3592
3593     switch (rx_mode) {
3594     case BXE_RX_MODE_NONE:
3595         /*
3596          * 'drop all' supersedes any accept flags that may have been
3597          * passed to the function.
3598          */
3599         break;
3600
3601     case BXE_RX_MODE_NORMAL:
3602         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3603         bxe_set_bit(ECORE_ACCEPT_MULTICAST, rx_accept_flags);
3604         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3605
3606         /* internal switching mode */
3607         bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3608         bxe_set_bit(ECORE_ACCEPT_MULTICAST, tx_accept_flags);
3609         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3610
3611         break;
3612
3613     case BXE_RX_MODE_ALLMULTI:
3614         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3615         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, rx_accept_flags);
3616         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3617
3618         /* internal switching mode */
3619         bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3620         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, tx_accept_flags);
3621         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3622
3623         break;
3624
3625     case BXE_RX_MODE_PROMISC:
3626         /*
3627          * According to deffinition of SI mode, iface in promisc mode
3628          * should receive matched and unmatched (in resolution of port)
3629          * unicast packets.
3630          */
3631         bxe_set_bit(ECORE_ACCEPT_UNMATCHED, rx_accept_flags);
3632         bxe_set_bit(ECORE_ACCEPT_UNICAST, rx_accept_flags);
3633         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, rx_accept_flags);
3634         bxe_set_bit(ECORE_ACCEPT_BROADCAST, rx_accept_flags);
3635
3636         /* internal switching mode */
3637         bxe_set_bit(ECORE_ACCEPT_ALL_MULTICAST, tx_accept_flags);
3638         bxe_set_bit(ECORE_ACCEPT_BROADCAST, tx_accept_flags);
3639
3640         if (IS_MF_SI(sc)) {
3641             bxe_set_bit(ECORE_ACCEPT_ALL_UNICAST, tx_accept_flags);
3642         } else {
3643             bxe_set_bit(ECORE_ACCEPT_UNICAST, tx_accept_flags);
3644         }
3645
3646         break;
3647
3648     default:
3649         BLOGE(sc, "Unknown rx_mode (0x%x)\n", rx_mode);
3650         return (-1);
3651     }
3652
3653     /* Set ACCEPT_ANY_VLAN as we do not enable filtering by VLAN */
3654     if (rx_mode != BXE_RX_MODE_NONE) {
3655         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, rx_accept_flags);
3656         bxe_set_bit(ECORE_ACCEPT_ANY_VLAN, tx_accept_flags);
3657     }
3658
3659     return (0);
3660 }
3661
3662 static int
3663 bxe_set_q_rx_mode(struct bxe_softc *sc,
3664                   uint8_t          cl_id,
3665                   unsigned long    rx_mode_flags,
3666                   unsigned long    rx_accept_flags,
3667                   unsigned long    tx_accept_flags,
3668                   unsigned long    ramrod_flags)
3669 {
3670     struct ecore_rx_mode_ramrod_params ramrod_param;
3671     int rc;
3672
3673     memset(&ramrod_param, 0, sizeof(ramrod_param));
3674
3675     /* Prepare ramrod parameters */
3676     ramrod_param.cid = 0;
3677     ramrod_param.cl_id = cl_id;
3678     ramrod_param.rx_mode_obj = &sc->rx_mode_obj;
3679     ramrod_param.func_id = SC_FUNC(sc);
3680
3681     ramrod_param.pstate = &sc->sp_state;
3682     ramrod_param.state = ECORE_FILTER_RX_MODE_PENDING;
3683
3684     ramrod_param.rdata = BXE_SP(sc, rx_mode_rdata);
3685     ramrod_param.rdata_mapping = BXE_SP_MAPPING(sc, rx_mode_rdata);
3686
3687     bxe_set_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state);
3688
3689     ramrod_param.ramrod_flags = ramrod_flags;
3690     ramrod_param.rx_mode_flags = rx_mode_flags;
3691
3692     ramrod_param.rx_accept_flags = rx_accept_flags;
3693     ramrod_param.tx_accept_flags = tx_accept_flags;
3694
3695     rc = ecore_config_rx_mode(sc, &ramrod_param);
3696     if (rc < 0) {
3697         BLOGE(sc, "Set rx_mode %d cli_id 0x%x rx_mode_flags 0x%x "
3698             "rx_accept_flags 0x%x tx_accept_flags 0x%x "
3699             "ramrod_flags 0x%x rc %d failed\n", sc->rx_mode, cl_id,
3700             (uint32_t)rx_mode_flags, (uint32_t)rx_accept_flags,
3701             (uint32_t)tx_accept_flags, (uint32_t)ramrod_flags, rc);
3702         return (rc);
3703     }
3704
3705     return (0);
3706 }
3707
3708 static int
3709 bxe_set_storm_rx_mode(struct bxe_softc *sc)
3710 {
3711     unsigned long rx_mode_flags = 0, ramrod_flags = 0;
3712     unsigned long rx_accept_flags = 0, tx_accept_flags = 0;
3713     int rc;
3714
3715     rc = bxe_fill_accept_flags(sc, sc->rx_mode, &rx_accept_flags,
3716                                &tx_accept_flags);
3717     if (rc) {
3718         return (rc);
3719     }
3720
3721     bxe_set_bit(RAMROD_RX, &ramrod_flags);
3722     bxe_set_bit(RAMROD_TX, &ramrod_flags);
3723
3724     /* XXX ensure all fastpath have same cl_id and/or move it to bxe_softc */
3725     return (bxe_set_q_rx_mode(sc, sc->fp[0].cl_id, rx_mode_flags,
3726                               rx_accept_flags, tx_accept_flags,
3727                               ramrod_flags));
3728 }
3729
3730 /* returns the "mcp load_code" according to global load_count array */
3731 static int
3732 bxe_nic_load_no_mcp(struct bxe_softc *sc)
3733 {
3734     int path = SC_PATH(sc);
3735     int port = SC_PORT(sc);
3736
3737     BLOGI(sc, "NO MCP - load counts[%d]      %d, %d, %d\n",
3738           path, load_count[path][0], load_count[path][1],
3739           load_count[path][2]);
3740     load_count[path][0]++;
3741     load_count[path][1 + port]++;
3742     BLOGI(sc, "NO MCP - new load counts[%d]  %d, %d, %d\n",
3743           path, load_count[path][0], load_count[path][1],
3744           load_count[path][2]);
3745     if (load_count[path][0] == 1) {
3746         return (FW_MSG_CODE_DRV_LOAD_COMMON);
3747     } else if (load_count[path][1 + port] == 1) {
3748         return (FW_MSG_CODE_DRV_LOAD_PORT);
3749     } else {
3750         return (FW_MSG_CODE_DRV_LOAD_FUNCTION);
3751     }
3752 }
3753
3754 /* returns the "mcp load_code" according to global load_count array */
3755 static int
3756 bxe_nic_unload_no_mcp(struct bxe_softc *sc)
3757 {
3758     int port = SC_PORT(sc);
3759     int path = SC_PATH(sc);
3760
3761     BLOGI(sc, "NO MCP - load counts[%d]      %d, %d, %d\n",
3762           path, load_count[path][0], load_count[path][1],
3763           load_count[path][2]);
3764     load_count[path][0]--;
3765     load_count[path][1 + port]--;
3766     BLOGI(sc, "NO MCP - new load counts[%d]  %d, %d, %d\n",
3767           path, load_count[path][0], load_count[path][1],
3768           load_count[path][2]);
3769     if (load_count[path][0] == 0) {
3770         return (FW_MSG_CODE_DRV_UNLOAD_COMMON);
3771     } else if (load_count[path][1 + port] == 0) {
3772         return (FW_MSG_CODE_DRV_UNLOAD_PORT);
3773     } else {
3774         return (FW_MSG_CODE_DRV_UNLOAD_FUNCTION);
3775     }
3776 }
3777
3778 /* request unload mode from the MCP: COMMON, PORT or FUNCTION */
3779 static uint32_t
3780 bxe_send_unload_req(struct bxe_softc *sc,
3781                     int              unload_mode)
3782 {
3783     uint32_t reset_code = 0;
3784
3785     /* Select the UNLOAD request mode */
3786     if (unload_mode == UNLOAD_NORMAL) {
3787         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
3788     } else {
3789         reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
3790     }
3791
3792     /* Send the request to the MCP */
3793     if (!BXE_NOMCP(sc)) {
3794         reset_code = bxe_fw_command(sc, reset_code, 0);
3795     } else {
3796         reset_code = bxe_nic_unload_no_mcp(sc);
3797     }
3798
3799     return (reset_code);
3800 }
3801
3802 /* send UNLOAD_DONE command to the MCP */
3803 static void
3804 bxe_send_unload_done(struct bxe_softc *sc,
3805                      uint8_t          keep_link)
3806 {
3807     uint32_t reset_param =
3808         keep_link ? DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET : 0;
3809
3810     /* Report UNLOAD_DONE to MCP */
3811     if (!BXE_NOMCP(sc)) {
3812         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE, reset_param);
3813     }
3814 }
3815
3816 static int
3817 bxe_func_wait_started(struct bxe_softc *sc)
3818 {
3819     int tout = 50;
3820
3821     if (!sc->port.pmf) {
3822         return (0);
3823     }
3824
3825     /*
3826      * (assumption: No Attention from MCP at this stage)
3827      * PMF probably in the middle of TX disable/enable transaction
3828      * 1. Sync IRS for default SB
3829      * 2. Sync SP queue - this guarantees us that attention handling started
3830      * 3. Wait, that TX disable/enable transaction completes
3831      *
3832      * 1+2 guarantee that if DCBX attention was scheduled it already changed
3833      * pending bit of transaction from STARTED-->TX_STOPPED, if we already
3834      * received completion for the transaction the state is TX_STOPPED.
3835      * State will return to STARTED after completion of TX_STOPPED-->STARTED
3836      * transaction.
3837      */
3838
3839     /* XXX make sure default SB ISR is done */
3840     /* need a way to synchronize an irq (intr_mtx?) */
3841
3842     /* XXX flush any work queues */
3843
3844     while (ecore_func_get_state(sc, &sc->func_obj) !=
3845            ECORE_F_STATE_STARTED && tout--) {
3846         DELAY(20000);
3847     }
3848
3849     if (ecore_func_get_state(sc, &sc->func_obj) != ECORE_F_STATE_STARTED) {
3850         /*
3851          * Failed to complete the transaction in a "good way"
3852          * Force both transactions with CLR bit.
3853          */
3854         struct ecore_func_state_params func_params = { NULL };
3855
3856         BLOGE(sc, "Unexpected function state! "
3857                   "Forcing STARTED-->TX_STOPPED-->STARTED\n");
3858
3859         func_params.f_obj = &sc->func_obj;
3860         bxe_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
3861
3862         /* STARTED-->TX_STOPPED */
3863         func_params.cmd = ECORE_F_CMD_TX_STOP;
3864         ecore_func_state_change(sc, &func_params);
3865
3866         /* TX_STOPPED-->STARTED */
3867         func_params.cmd = ECORE_F_CMD_TX_START;
3868         return (ecore_func_state_change(sc, &func_params));
3869     }
3870
3871     return (0);
3872 }
3873
3874 static int
3875 bxe_stop_queue(struct bxe_softc *sc,
3876                int              index)
3877 {
3878     struct bxe_fastpath *fp = &sc->fp[index];
3879     struct ecore_queue_state_params q_params = { NULL };
3880     int rc;
3881
3882     BLOGD(sc, DBG_LOAD, "stopping queue %d cid %d\n", index, fp->index);
3883
3884     q_params.q_obj = &sc->sp_objs[fp->index].q_obj;
3885     /* We want to wait for completion in this context */
3886     bxe_set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
3887
3888     /* Stop the primary connection: */
3889
3890     /* ...halt the connection */
3891     q_params.cmd = ECORE_Q_CMD_HALT;
3892     rc = ecore_queue_state_change(sc, &q_params);
3893     if (rc) {
3894         return (rc);
3895     }
3896
3897     /* ...terminate the connection */
3898     q_params.cmd = ECORE_Q_CMD_TERMINATE;
3899     memset(&q_params.params.terminate, 0, sizeof(q_params.params.terminate));
3900     q_params.params.terminate.cid_index = FIRST_TX_COS_INDEX;
3901     rc = ecore_queue_state_change(sc, &q_params);
3902     if (rc) {
3903         return (rc);
3904     }
3905
3906     /* ...delete cfc entry */
3907     q_params.cmd = ECORE_Q_CMD_CFC_DEL;
3908     memset(&q_params.params.cfc_del, 0, sizeof(q_params.params.cfc_del));
3909     q_params.params.cfc_del.cid_index = FIRST_TX_COS_INDEX;
3910     return (ecore_queue_state_change(sc, &q_params));
3911 }
3912
3913 /* wait for the outstanding SP commands */
3914 static inline uint8_t
3915 bxe_wait_sp_comp(struct bxe_softc *sc,
3916                  unsigned long    mask)
3917 {
3918     unsigned long tmp;
3919     int tout = 5000; /* wait for 5 secs tops */
3920
3921     while (tout--) {
3922         mb();
3923         if (!(atomic_load_acq_long(&sc->sp_state) & mask)) {
3924             return (TRUE);
3925         }
3926
3927         DELAY(1000);
3928     }
3929
3930     mb();
3931
3932     tmp = atomic_load_acq_long(&sc->sp_state);
3933     if (tmp & mask) {
3934         BLOGE(sc, "Filtering completion timed out: "
3935                   "sp_state 0x%lx, mask 0x%lx\n",
3936               tmp, mask);
3937         return (FALSE);
3938     }
3939
3940     return (FALSE);
3941 }
3942
3943 static int
3944 bxe_func_stop(struct bxe_softc *sc)
3945 {
3946     struct ecore_func_state_params func_params = { NULL };
3947     int rc;
3948
3949     /* prepare parameters for function state transitions */
3950     bxe_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
3951     func_params.f_obj = &sc->func_obj;
3952     func_params.cmd = ECORE_F_CMD_STOP;
3953
3954     /*
3955      * Try to stop the function the 'good way'. If it fails (in case
3956      * of a parity error during bxe_chip_cleanup()) and we are
3957      * not in a debug mode, perform a state transaction in order to
3958      * enable further HW_RESET transaction.
3959      */
3960     rc = ecore_func_state_change(sc, &func_params);
3961     if (rc) {
3962         BLOGE(sc, "FUNC_STOP ramrod failed. "
3963                   "Running a dry transaction (%d)\n", rc);
3964         bxe_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
3965         return (ecore_func_state_change(sc, &func_params));
3966     }
3967
3968     return (0);
3969 }
3970
3971 static int
3972 bxe_reset_hw(struct bxe_softc *sc,
3973              uint32_t         load_code)
3974 {
3975     struct ecore_func_state_params func_params = { NULL };
3976
3977     /* Prepare parameters for function state transitions */
3978     bxe_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
3979
3980     func_params.f_obj = &sc->func_obj;
3981     func_params.cmd = ECORE_F_CMD_HW_RESET;
3982
3983     func_params.params.hw_init.load_phase = load_code;
3984
3985     return (ecore_func_state_change(sc, &func_params));
3986 }
3987
3988 static void
3989 bxe_int_disable_sync(struct bxe_softc *sc,
3990                      int              disable_hw)
3991 {
3992     if (disable_hw) {
3993         /* prevent the HW from sending interrupts */
3994         bxe_int_disable(sc);
3995     }
3996
3997     /* XXX need a way to synchronize ALL irqs (intr_mtx?) */
3998     /* make sure all ISRs are done */
3999
4000     /* XXX make sure sp_task is not running */
4001     /* cancel and flush work queues */
4002 }
4003
4004 static void
4005 bxe_chip_cleanup(struct bxe_softc *sc,
4006                  uint32_t         unload_mode,
4007                  uint8_t          keep_link)
4008 {
4009     int port = SC_PORT(sc);
4010     struct ecore_mcast_ramrod_params rparam = { NULL };
4011     uint32_t reset_code;
4012     int i, rc = 0;
4013
4014     bxe_drain_tx_queues(sc);
4015
4016     /* give HW time to discard old tx messages */
4017     DELAY(1000);
4018
4019     /* Clean all ETH MACs */
4020     rc = bxe_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_ETH_MAC, FALSE);
4021     if (rc < 0) {
4022         BLOGE(sc, "Failed to delete all ETH MACs (%d)\n", rc);
4023     }
4024
4025     /* Clean up UC list  */
4026     rc = bxe_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_UC_LIST_MAC, TRUE);
4027     if (rc < 0) {
4028         BLOGE(sc, "Failed to delete UC MACs list (%d)\n", rc);
4029     }
4030
4031     /* Disable LLH */
4032     if (!CHIP_IS_E1(sc)) {
4033         REG_WR(sc, NIG_REG_LLH0_FUNC_EN + port*8, 0);
4034     }
4035
4036     /* Set "drop all" to stop Rx */
4037
4038     /*
4039      * We need to take the BXE_MCAST_LOCK() here in order to prevent
4040      * a race between the completion code and this code.
4041      */
4042     BXE_MCAST_LOCK(sc);
4043
4044     if (bxe_test_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state)) {
4045         bxe_set_bit(ECORE_FILTER_RX_MODE_SCHED, &sc->sp_state);
4046     } else {
4047         bxe_set_storm_rx_mode(sc);
4048     }
4049
4050     /* Clean up multicast configuration */
4051     rparam.mcast_obj = &sc->mcast_obj;
4052     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
4053     if (rc < 0) {
4054         BLOGE(sc, "Failed to send DEL MCAST command (%d)\n", rc);
4055     }
4056
4057     BXE_MCAST_UNLOCK(sc);
4058
4059     // XXX bxe_iov_chip_cleanup(sc);
4060
4061     /*
4062      * Send the UNLOAD_REQUEST to the MCP. This will return if
4063      * this function should perform FUNCTION, PORT, or COMMON HW
4064      * reset.
4065      */
4066     reset_code = bxe_send_unload_req(sc, unload_mode);
4067
4068     /*
4069      * (assumption: No Attention from MCP at this stage)
4070      * PMF probably in the middle of TX disable/enable transaction
4071      */
4072     rc = bxe_func_wait_started(sc);
4073     if (rc) {
4074         BLOGE(sc, "bxe_func_wait_started failed (%d)\n", rc);
4075     }
4076
4077     /*
4078      * Close multi and leading connections
4079      * Completions for ramrods are collected in a synchronous way
4080      */
4081     for (i = 0; i < sc->num_queues; i++) {
4082         if (bxe_stop_queue(sc, i)) {
4083             goto unload_error;
4084         }
4085     }
4086
4087     /*
4088      * If SP settings didn't get completed so far - something
4089      * very wrong has happen.
4090      */
4091     if (!bxe_wait_sp_comp(sc, ~0x0UL)) {
4092         BLOGE(sc, "Common slow path ramrods got stuck!(%d)\n", rc);
4093     }
4094
4095 unload_error:
4096
4097     rc = bxe_func_stop(sc);
4098     if (rc) {
4099         BLOGE(sc, "Function stop failed!(%d)\n", rc);
4100     }
4101
4102     /* disable HW interrupts */
4103     bxe_int_disable_sync(sc, TRUE);
4104
4105     /* detach interrupts */
4106     bxe_interrupt_detach(sc);
4107
4108     /* Reset the chip */
4109     rc = bxe_reset_hw(sc, reset_code);
4110     if (rc) {
4111         BLOGE(sc, "Hardware reset failed(%d)\n", rc);
4112     }
4113
4114     /* Report UNLOAD_DONE to MCP */
4115     bxe_send_unload_done(sc, keep_link);
4116 }
4117
4118 static void
4119 bxe_disable_close_the_gate(struct bxe_softc *sc)
4120 {
4121     uint32_t val;
4122     int port = SC_PORT(sc);
4123
4124     BLOGD(sc, DBG_LOAD,
4125           "Disabling 'close the gates'\n");
4126
4127     if (CHIP_IS_E1(sc)) {
4128         uint32_t addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
4129                                MISC_REG_AEU_MASK_ATTN_FUNC_0;
4130         val = REG_RD(sc, addr);
4131         val &= ~(0x300);
4132         REG_WR(sc, addr, val);
4133     } else {
4134         val = REG_RD(sc, MISC_REG_AEU_GENERAL_MASK);
4135         val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
4136                  MISC_AEU_GENERAL_MASK_REG_AEU_NIG_CLOSE_MASK);
4137         REG_WR(sc, MISC_REG_AEU_GENERAL_MASK, val);
4138     }
4139 }
4140
4141 /*
4142  * Cleans the object that have internal lists without sending
4143  * ramrods. Should be run when interrutps are disabled.
4144  */
4145 static void
4146 bxe_squeeze_objects(struct bxe_softc *sc)
4147 {
4148     unsigned long ramrod_flags = 0, vlan_mac_flags = 0;
4149     struct ecore_mcast_ramrod_params rparam = { NULL };
4150     struct ecore_vlan_mac_obj *mac_obj = &sc->sp_objs->mac_obj;
4151     int rc;
4152
4153     /* Cleanup MACs' object first... */
4154
4155     /* Wait for completion of requested */
4156     bxe_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
4157     /* Perform a dry cleanup */
4158     bxe_set_bit(RAMROD_DRV_CLR_ONLY, &ramrod_flags);
4159
4160     /* Clean ETH primary MAC */
4161     bxe_set_bit(ECORE_ETH_MAC, &vlan_mac_flags);
4162     rc = mac_obj->delete_all(sc, &sc->sp_objs->mac_obj, &vlan_mac_flags,
4163                              &ramrod_flags);
4164     if (rc != 0) {
4165         BLOGE(sc, "Failed to clean ETH MACs (%d)\n", rc);
4166     }
4167
4168     /* Cleanup UC list */
4169     vlan_mac_flags = 0;
4170     bxe_set_bit(ECORE_UC_LIST_MAC, &vlan_mac_flags);
4171     rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags,
4172                              &ramrod_flags);
4173     if (rc != 0) {
4174         BLOGE(sc, "Failed to clean UC list MACs (%d)\n", rc);
4175     }
4176
4177     /* Now clean mcast object... */
4178
4179     rparam.mcast_obj = &sc->mcast_obj;
4180     bxe_set_bit(RAMROD_DRV_CLR_ONLY, &rparam.ramrod_flags);
4181
4182     /* Add a DEL command... */
4183     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
4184     if (rc < 0) {
4185         BLOGE(sc, "Failed to send DEL MCAST command (%d)\n", rc);
4186     }
4187
4188     /* now wait until all pending commands are cleared */
4189
4190     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
4191     while (rc != 0) {
4192         if (rc < 0) {
4193             BLOGE(sc, "Failed to clean MCAST object (%d)\n", rc);
4194             return;
4195         }
4196
4197         rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
4198     }
4199 }
4200
4201 /* stop the controller */
4202 static __noinline int
4203 bxe_nic_unload(struct bxe_softc *sc,
4204                uint32_t         unload_mode,
4205                uint8_t          keep_link)
4206 {
4207     uint8_t global = FALSE;
4208     uint32_t val;
4209     int i;
4210
4211     BXE_CORE_LOCK_ASSERT(sc);
4212
4213     sc->ifnet->if_drv_flags &= ~IFF_DRV_RUNNING;
4214
4215     for (i = 0; i < sc->num_queues; i++) {
4216         struct bxe_fastpath *fp;
4217
4218         fp = &sc->fp[i];
4219         BXE_FP_TX_LOCK(fp);
4220         BXE_FP_TX_UNLOCK(fp);
4221     }
4222
4223     BLOGD(sc, DBG_LOAD, "Starting NIC unload...\n");
4224
4225     /* mark driver as unloaded in shmem2 */
4226     if (IS_PF(sc) && SHMEM2_HAS(sc, drv_capabilities_flag)) {
4227         val = SHMEM2_RD(sc, drv_capabilities_flag[SC_FW_MB_IDX(sc)]);
4228         SHMEM2_WR(sc, drv_capabilities_flag[SC_FW_MB_IDX(sc)],
4229                   val & ~DRV_FLAGS_CAPABILITIES_LOADED_L2);
4230     }
4231
4232     if (IS_PF(sc) && sc->recovery_state != BXE_RECOVERY_DONE &&
4233         (sc->state == BXE_STATE_CLOSED || sc->state == BXE_STATE_ERROR)) {
4234         /*
4235          * We can get here if the driver has been unloaded
4236          * during parity error recovery and is either waiting for a
4237          * leader to complete or for other functions to unload and
4238          * then ifconfig down has been issued. In this case we want to
4239          * unload and let other functions to complete a recovery
4240          * process.
4241          */
4242         sc->recovery_state = BXE_RECOVERY_DONE;
4243         sc->is_leader = 0;
4244         bxe_release_leader_lock(sc);
4245         mb();
4246
4247         BLOGD(sc, DBG_LOAD, "Releasing a leadership...\n");
4248         BLOGE(sc, "Can't unload in closed or error state recover_state 0x%x"
4249             " state = 0x%x\n", sc->recovery_state, sc->state);
4250         return (-1);
4251     }
4252
4253     /*
4254      * Nothing to do during unload if previous bxe_nic_load()
4255      * did not completed succesfully - all resourses are released.
4256      */
4257     if ((sc->state == BXE_STATE_CLOSED) ||
4258         (sc->state == BXE_STATE_ERROR)) {
4259         return (0);
4260     }
4261
4262     sc->state = BXE_STATE_CLOSING_WAITING_HALT;
4263     mb();
4264
4265     /* stop tx */
4266     bxe_tx_disable(sc);
4267
4268     sc->rx_mode = BXE_RX_MODE_NONE;
4269     /* XXX set rx mode ??? */
4270
4271     if (IS_PF(sc) && !sc->grcdump_done) {
4272         /* set ALWAYS_ALIVE bit in shmem */
4273         sc->fw_drv_pulse_wr_seq |= DRV_PULSE_ALWAYS_ALIVE;
4274
4275         bxe_drv_pulse(sc);
4276
4277         bxe_stats_handle(sc, STATS_EVENT_STOP);
4278         bxe_save_statistics(sc);
4279     }
4280
4281     /* wait till consumers catch up with producers in all queues */
4282     bxe_drain_tx_queues(sc);
4283
4284     /* if VF indicate to PF this function is going down (PF will delete sp
4285      * elements and clear initializations
4286      */
4287     if (IS_VF(sc)) {
4288         ; /* bxe_vfpf_close_vf(sc); */
4289     } else if (unload_mode != UNLOAD_RECOVERY) {
4290         /* if this is a normal/close unload need to clean up chip */
4291         if (!sc->grcdump_done)
4292             bxe_chip_cleanup(sc, unload_mode, keep_link);
4293     } else {
4294         /* Send the UNLOAD_REQUEST to the MCP */
4295         bxe_send_unload_req(sc, unload_mode);
4296
4297         /*
4298          * Prevent transactions to host from the functions on the
4299          * engine that doesn't reset global blocks in case of global
4300          * attention once gloabl blocks are reset and gates are opened
4301          * (the engine which leader will perform the recovery
4302          * last).
4303          */
4304         if (!CHIP_IS_E1x(sc)) {
4305             bxe_pf_disable(sc);
4306         }
4307
4308         /* disable HW interrupts */
4309         bxe_int_disable_sync(sc, TRUE);
4310
4311         /* detach interrupts */
4312         bxe_interrupt_detach(sc);
4313
4314         /* Report UNLOAD_DONE to MCP */
4315         bxe_send_unload_done(sc, FALSE);
4316     }
4317
4318     /*
4319      * At this stage no more interrupts will arrive so we may safely clean
4320      * the queue'able objects here in case they failed to get cleaned so far.
4321      */
4322     if (IS_PF(sc)) {
4323         bxe_squeeze_objects(sc);
4324     }
4325
4326     /* There should be no more pending SP commands at this stage */
4327     sc->sp_state = 0;
4328
4329     sc->port.pmf = 0;
4330
4331     bxe_free_fp_buffers(sc);
4332
4333     if (IS_PF(sc)) {
4334         bxe_free_mem(sc);
4335     }
4336
4337     bxe_free_fw_stats_mem(sc);
4338
4339     sc->state = BXE_STATE_CLOSED;
4340
4341     /*
4342      * Check if there are pending parity attentions. If there are - set
4343      * RECOVERY_IN_PROGRESS.
4344      */
4345     if (IS_PF(sc) && bxe_chk_parity_attn(sc, &global, FALSE)) {
4346         bxe_set_reset_in_progress(sc);
4347
4348         /* Set RESET_IS_GLOBAL if needed */
4349         if (global) {
4350             bxe_set_reset_global(sc);
4351         }
4352     }
4353
4354     /*
4355      * The last driver must disable a "close the gate" if there is no
4356      * parity attention or "process kill" pending.
4357      */
4358     if (IS_PF(sc) && !bxe_clear_pf_load(sc) &&
4359         bxe_reset_is_done(sc, SC_PATH(sc))) {
4360         bxe_disable_close_the_gate(sc);
4361     }
4362
4363     BLOGD(sc, DBG_LOAD, "Ended NIC unload\n");
4364
4365     return (0);
4366 }
4367
4368 /*
4369  * Called by the OS to set various media options (i.e. link, speed, etc.) when
4370  * the user runs "ifconfig bxe media ..." or "ifconfig bxe mediaopt ...".
4371  */
4372 static int
4373 bxe_ifmedia_update(struct ifnet *ifp)
4374 {
4375     struct bxe_softc *sc = (struct bxe_softc *)ifp->if_softc;
4376     struct ifmedia *ifm;
4377
4378     ifm = &sc->ifmedia;
4379
4380     /* We only support Ethernet media type. */
4381     if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) {
4382         return (EINVAL);
4383     }
4384
4385     switch (IFM_SUBTYPE(ifm->ifm_media)) {
4386     case IFM_AUTO:
4387          break;
4388     case IFM_10G_CX4:
4389     case IFM_10G_SR:
4390     case IFM_10G_T:
4391     case IFM_10G_TWINAX:
4392     default:
4393         /* We don't support changing the media type. */
4394         BLOGD(sc, DBG_LOAD, "Invalid media type (%d)\n",
4395               IFM_SUBTYPE(ifm->ifm_media));
4396         return (EINVAL);
4397     }
4398
4399     return (0);
4400 }
4401
4402 /*
4403  * Called by the OS to get the current media status (i.e. link, speed, etc.).
4404  */
4405 static void
4406 bxe_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
4407 {
4408     struct bxe_softc *sc = ifp->if_softc;
4409
4410     /* Report link down if the driver isn't running. */
4411     if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
4412         ifmr->ifm_active |= IFM_NONE;
4413         return;
4414     }
4415
4416     /* Setup the default interface info. */
4417     ifmr->ifm_status = IFM_AVALID;
4418     ifmr->ifm_active = IFM_ETHER;
4419
4420     if (sc->link_vars.link_up) {
4421         ifmr->ifm_status |= IFM_ACTIVE;
4422     } else {
4423         ifmr->ifm_active |= IFM_NONE;
4424         return;
4425     }
4426
4427     ifmr->ifm_active |= sc->media;
4428
4429     if (sc->link_vars.duplex == DUPLEX_FULL) {
4430         ifmr->ifm_active |= IFM_FDX;
4431     } else {
4432         ifmr->ifm_active |= IFM_HDX;
4433     }
4434 }
4435
4436 static int
4437 bxe_ioctl_nvram(struct bxe_softc *sc,
4438                 uint32_t         priv_op,
4439                 struct ifreq     *ifr)
4440 {
4441     struct bxe_nvram_data nvdata_base;
4442     struct bxe_nvram_data *nvdata;
4443     int len;
4444     int error = 0;
4445
4446     copyin(ifr->ifr_data, &nvdata_base, sizeof(nvdata_base));
4447
4448     len = (sizeof(struct bxe_nvram_data) +
4449            nvdata_base.len -
4450            sizeof(uint32_t));
4451
4452     if (len > sizeof(struct bxe_nvram_data)) {
4453         if ((nvdata = (struct bxe_nvram_data *)
4454                  malloc(len, M_DEVBUF,
4455                         (M_NOWAIT | M_ZERO))) == NULL) {
4456             BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed priv_op 0x%x "
4457                 " len = 0x%x\n", priv_op, len);
4458             return (1);
4459         }
4460         memcpy(nvdata, &nvdata_base, sizeof(struct bxe_nvram_data));
4461     } else {
4462         nvdata = &nvdata_base;
4463     }
4464
4465     if (priv_op == BXE_IOC_RD_NVRAM) {
4466         BLOGD(sc, DBG_IOCTL, "IOC_RD_NVRAM 0x%x %d\n",
4467               nvdata->offset, nvdata->len);
4468         error = bxe_nvram_read(sc,
4469                                nvdata->offset,
4470                                (uint8_t *)nvdata->value,
4471                                nvdata->len);
4472         copyout(nvdata, ifr->ifr_data, len);
4473     } else { /* BXE_IOC_WR_NVRAM */
4474         BLOGD(sc, DBG_IOCTL, "IOC_WR_NVRAM 0x%x %d\n",
4475               nvdata->offset, nvdata->len);
4476         copyin(ifr->ifr_data, nvdata, len);
4477         error = bxe_nvram_write(sc,
4478                                 nvdata->offset,
4479                                 (uint8_t *)nvdata->value,
4480                                 nvdata->len);
4481     }
4482
4483     if (len > sizeof(struct bxe_nvram_data)) {
4484         free(nvdata, M_DEVBUF);
4485     }
4486
4487     return (error);
4488 }
4489
4490 static int
4491 bxe_ioctl_stats_show(struct bxe_softc *sc,
4492                      uint32_t         priv_op,
4493                      struct ifreq     *ifr)
4494 {
4495     const size_t str_size   = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);
4496     const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));
4497     caddr_t p_tmp;
4498     uint32_t *offset;
4499     int i;
4500
4501     switch (priv_op)
4502     {
4503     case BXE_IOC_STATS_SHOW_NUM:
4504         memset(ifr->ifr_data, 0, sizeof(union bxe_stats_show_data));
4505         ((union bxe_stats_show_data *)ifr->ifr_data)->desc.num =
4506             BXE_NUM_ETH_STATS;
4507         ((union bxe_stats_show_data *)ifr->ifr_data)->desc.len =
4508             STAT_NAME_LEN;
4509         return (0);
4510
4511     case BXE_IOC_STATS_SHOW_STR:
4512         memset(ifr->ifr_data, 0, str_size);
4513         p_tmp = ifr->ifr_data;
4514         for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
4515             strcpy(p_tmp, bxe_eth_stats_arr[i].string);
4516             p_tmp += STAT_NAME_LEN;
4517         }
4518         return (0);
4519
4520     case BXE_IOC_STATS_SHOW_CNT:
4521         memset(ifr->ifr_data, 0, stats_size);
4522         p_tmp = ifr->ifr_data;
4523         for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
4524             offset = ((uint32_t *)&sc->eth_stats +
4525                       bxe_eth_stats_arr[i].offset);
4526             switch (bxe_eth_stats_arr[i].size) {
4527             case 4:
4528                 *((uint64_t *)p_tmp) = (uint64_t)*offset;
4529                 break;
4530             case 8:
4531                 *((uint64_t *)p_tmp) = HILO_U64(*offset, *(offset + 1));
4532                 break;
4533             default:
4534                 *((uint64_t *)p_tmp) = 0;
4535             }
4536             p_tmp += sizeof(uint64_t);
4537         }
4538         return (0);
4539
4540     default:
4541         return (-1);
4542     }
4543 }
4544
4545 static void
4546 bxe_handle_chip_tq(void *context,
4547                    int  pending)
4548 {
4549     struct bxe_softc *sc = (struct bxe_softc *)context;
4550     long work = atomic_load_acq_long(&sc->chip_tq_flags);
4551
4552     switch (work)
4553     {
4554     case CHIP_TQ_REINIT:
4555         if (sc->ifnet->if_drv_flags & IFF_DRV_RUNNING) {
4556             /* restart the interface */
4557             BLOGD(sc, DBG_LOAD, "Restarting the interface...\n");
4558             bxe_periodic_stop(sc);
4559             BXE_CORE_LOCK(sc);
4560             bxe_stop_locked(sc);
4561             bxe_init_locked(sc);
4562             BXE_CORE_UNLOCK(sc);
4563         }
4564         break;
4565
4566     default:
4567         break;
4568     }
4569 }
4570
4571 /*
4572  * Handles any IOCTL calls from the operating system.
4573  *
4574  * Returns:
4575  *   0 = Success, >0 Failure
4576  */
4577 static int
4578 bxe_ioctl(struct ifnet *ifp,
4579           u_long       command,
4580           caddr_t      data)
4581 {
4582     struct bxe_softc *sc = ifp->if_softc;
4583     struct ifreq *ifr = (struct ifreq *)data;
4584     struct bxe_nvram_data *nvdata;
4585     uint32_t priv_op;
4586     int mask = 0;
4587     int reinit = 0;
4588     int error = 0;
4589
4590     int mtu_min = (ETH_MIN_PACKET_SIZE - ETH_HLEN);
4591     int mtu_max = (MJUM9BYTES - ETH_OVERHEAD - IP_HEADER_ALIGNMENT_PADDING);
4592
4593     switch (command)
4594     {
4595     case SIOCSIFMTU:
4596         BLOGD(sc, DBG_IOCTL, "Received SIOCSIFMTU ioctl (mtu=%d)\n",
4597               ifr->ifr_mtu);
4598
4599         if (sc->mtu == ifr->ifr_mtu) {
4600             /* nothing to change */
4601             break;
4602         }
4603
4604         if ((ifr->ifr_mtu < mtu_min) || (ifr->ifr_mtu > mtu_max)) {
4605             BLOGE(sc, "Unsupported MTU size %d (range is %d-%d)\n",
4606                   ifr->ifr_mtu, mtu_min, mtu_max);
4607             error = EINVAL;
4608             break;
4609         }
4610
4611         atomic_store_rel_int((volatile unsigned int *)&sc->mtu,
4612                              (unsigned long)ifr->ifr_mtu);
4613         atomic_store_rel_long((volatile unsigned long *)&ifp->if_mtu,
4614                               (unsigned long)ifr->ifr_mtu);
4615
4616         reinit = 1;
4617         break;
4618
4619     case SIOCSIFFLAGS:
4620         /* toggle the interface state up or down */
4621         BLOGD(sc, DBG_IOCTL, "Received SIOCSIFFLAGS ioctl\n");
4622
4623         BXE_CORE_LOCK(sc);
4624         /* check if the interface is up */
4625         if (ifp->if_flags & IFF_UP) {
4626             if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
4627                 /* set the receive mode flags */
4628                 bxe_set_rx_mode(sc);
4629             } else {
4630                 bxe_init_locked(sc);
4631             }
4632         } else {
4633             if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
4634                 bxe_periodic_stop(sc);
4635                 bxe_stop_locked(sc);
4636             }
4637         }
4638         BXE_CORE_UNLOCK(sc);
4639
4640         break;
4641
4642     case SIOCADDMULTI:
4643     case SIOCDELMULTI:
4644         /* add/delete multicast addresses */
4645         BLOGD(sc, DBG_IOCTL, "Received SIOCADDMULTI/SIOCDELMULTI ioctl\n");
4646
4647         /* check if the interface is up */
4648         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
4649             /* set the receive mode flags */
4650             BXE_CORE_LOCK(sc);
4651             bxe_set_rx_mode(sc);
4652             BXE_CORE_UNLOCK(sc);
4653         }
4654
4655         break;
4656
4657     case SIOCSIFCAP:
4658         /* find out which capabilities have changed */
4659         mask = (ifr->ifr_reqcap ^ ifp->if_capenable);
4660
4661         BLOGD(sc, DBG_IOCTL, "Received SIOCSIFCAP ioctl (mask=0x%08x)\n",
4662               mask);
4663
4664         /* toggle the LRO capabilites enable flag */
4665         if (mask & IFCAP_LRO) {
4666             ifp->if_capenable ^= IFCAP_LRO;
4667             BLOGD(sc, DBG_IOCTL, "Turning LRO %s\n",
4668                   (ifp->if_capenable & IFCAP_LRO) ? "ON" : "OFF");
4669             reinit = 1;
4670         }
4671
4672         /* toggle the TXCSUM checksum capabilites enable flag */
4673         if (mask & IFCAP_TXCSUM) {
4674             ifp->if_capenable ^= IFCAP_TXCSUM;
4675             BLOGD(sc, DBG_IOCTL, "Turning TXCSUM %s\n",
4676                   (ifp->if_capenable & IFCAP_TXCSUM) ? "ON" : "OFF");
4677             if (ifp->if_capenable & IFCAP_TXCSUM) {
4678                 ifp->if_hwassist = (CSUM_IP       |
4679                                     CSUM_TCP      |
4680                                     CSUM_UDP      |
4681                                     CSUM_TSO      |
4682                                     CSUM_TCP_IPV6 |
4683                                     CSUM_UDP_IPV6);
4684             } else {
4685                 ifp->if_hwassist = 0;
4686             }
4687         }
4688
4689         /* toggle the RXCSUM checksum capabilities enable flag */
4690         if (mask & IFCAP_RXCSUM) {
4691             ifp->if_capenable ^= IFCAP_RXCSUM;
4692             BLOGD(sc, DBG_IOCTL, "Turning RXCSUM %s\n",
4693                   (ifp->if_capenable & IFCAP_RXCSUM) ? "ON" : "OFF");
4694             if (ifp->if_capenable & IFCAP_RXCSUM) {
4695                 ifp->if_hwassist = (CSUM_IP       |
4696                                     CSUM_TCP      |
4697                                     CSUM_UDP      |
4698                                     CSUM_TSO      |
4699                                     CSUM_TCP_IPV6 |
4700                                     CSUM_UDP_IPV6);
4701             } else {
4702                 ifp->if_hwassist = 0;
4703             }
4704         }
4705
4706         /* toggle TSO4 capabilities enabled flag */
4707         if (mask & IFCAP_TSO4) {
4708             ifp->if_capenable ^= IFCAP_TSO4;
4709             BLOGD(sc, DBG_IOCTL, "Turning TSO4 %s\n",
4710                   (ifp->if_capenable & IFCAP_TSO4) ? "ON" : "OFF");
4711         }
4712
4713         /* toggle TSO6 capabilities enabled flag */
4714         if (mask & IFCAP_TSO6) {
4715             ifp->if_capenable ^= IFCAP_TSO6;
4716             BLOGD(sc, DBG_IOCTL, "Turning TSO6 %s\n",
4717                   (ifp->if_capenable & IFCAP_TSO6) ? "ON" : "OFF");
4718         }
4719
4720         /* toggle VLAN_HWTSO capabilities enabled flag */
4721         if (mask & IFCAP_VLAN_HWTSO) {
4722             ifp->if_capenable ^= IFCAP_VLAN_HWTSO;
4723             BLOGD(sc, DBG_IOCTL, "Turning VLAN_HWTSO %s\n",
4724                   (ifp->if_capenable & IFCAP_VLAN_HWTSO) ? "ON" : "OFF");
4725         }
4726
4727         /* toggle VLAN_HWCSUM capabilities enabled flag */
4728         if (mask & IFCAP_VLAN_HWCSUM) {
4729             /* XXX investigate this... */
4730             BLOGE(sc, "Changing VLAN_HWCSUM is not supported!\n");
4731             error = EINVAL;
4732         }
4733
4734         /* toggle VLAN_MTU capabilities enable flag */
4735         if (mask & IFCAP_VLAN_MTU) {
4736             /* XXX investigate this... */
4737             BLOGE(sc, "Changing VLAN_MTU is not supported!\n");
4738             error = EINVAL;
4739         }
4740
4741         /* toggle VLAN_HWTAGGING capabilities enabled flag */
4742         if (mask & IFCAP_VLAN_HWTAGGING) {
4743             /* XXX investigate this... */
4744             BLOGE(sc, "Changing VLAN_HWTAGGING is not supported!\n");
4745             error = EINVAL;
4746         }
4747
4748         /* toggle VLAN_HWFILTER capabilities enabled flag */
4749         if (mask & IFCAP_VLAN_HWFILTER) {
4750             /* XXX investigate this... */
4751             BLOGE(sc, "Changing VLAN_HWFILTER is not supported!\n");
4752             error = EINVAL;
4753         }
4754
4755         /* XXX not yet...
4756          * IFCAP_WOL_MAGIC
4757          */
4758
4759         break;
4760
4761     case SIOCSIFMEDIA:
4762     case SIOCGIFMEDIA:
4763         /* set/get interface media */
4764         BLOGD(sc, DBG_IOCTL,
4765               "Received SIOCSIFMEDIA/SIOCGIFMEDIA ioctl (cmd=%lu)\n",
4766               (command & 0xff));
4767         error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
4768         break;
4769
4770     case SIOCGPRIVATE_0:
4771         copyin(ifr->ifr_data, &priv_op, sizeof(priv_op));
4772
4773         switch (priv_op)
4774         {
4775         case BXE_IOC_RD_NVRAM:
4776         case BXE_IOC_WR_NVRAM:
4777             nvdata = (struct bxe_nvram_data *)ifr->ifr_data;
4778             BLOGD(sc, DBG_IOCTL,
4779                   "Received Private NVRAM ioctl addr=0x%x size=%u\n",
4780                   nvdata->offset, nvdata->len);
4781             error = bxe_ioctl_nvram(sc, priv_op, ifr);
4782             break;
4783
4784         case BXE_IOC_STATS_SHOW_NUM:
4785         case BXE_IOC_STATS_SHOW_STR:
4786         case BXE_IOC_STATS_SHOW_CNT:
4787             BLOGD(sc, DBG_IOCTL, "Received Private Stats ioctl (%d)\n",
4788                   priv_op);
4789             error = bxe_ioctl_stats_show(sc, priv_op, ifr);
4790             break;
4791
4792         default:
4793             BLOGW(sc, "Received Private Unknown ioctl (%d)\n", priv_op);
4794             error = EINVAL;
4795             break;
4796         }
4797
4798         break;
4799
4800     default:
4801         BLOGD(sc, DBG_IOCTL, "Received Unknown Ioctl (cmd=%lu)\n",
4802               (command & 0xff));
4803         error = ether_ioctl(ifp, command, data);
4804         break;
4805     }
4806
4807     if (reinit && (sc->ifnet->if_drv_flags & IFF_DRV_RUNNING)) {
4808         BLOGD(sc, DBG_LOAD | DBG_IOCTL,
4809               "Re-initializing hardware from IOCTL change\n");
4810         bxe_periodic_stop(sc);
4811         BXE_CORE_LOCK(sc);
4812         bxe_stop_locked(sc);
4813         bxe_init_locked(sc);
4814         BXE_CORE_UNLOCK(sc);
4815     }
4816
4817     return (error);
4818 }
4819
4820 static __noinline void
4821 bxe_dump_mbuf(struct bxe_softc *sc,
4822               struct mbuf      *m,
4823               uint8_t          contents)
4824 {
4825     char * type;
4826     int i = 0;
4827
4828     if (!(sc->debug & DBG_MBUF)) {
4829         return;
4830     }
4831
4832     if (m == NULL) {
4833         BLOGD(sc, DBG_MBUF, "mbuf: null pointer\n");
4834         return;
4835     }
4836
4837     while (m) {
4838         BLOGD(sc, DBG_MBUF,
4839               "%02d: mbuf=%p m_len=%d m_flags=0x%b m_data=%p\n",
4840               i, m, m->m_len, m->m_flags,
4841               "\20\1M_EXT\2M_PKTHDR\3M_EOR\4M_RDONLY", m->m_data);
4842
4843         if (m->m_flags & M_PKTHDR) {
4844              BLOGD(sc, DBG_MBUF,
4845                    "%02d: - m_pkthdr: tot_len=%d flags=0x%b csum_flags=%b\n",
4846                    i, m->m_pkthdr.len, m->m_flags,
4847                    "\20\12M_BCAST\13M_MCAST\14M_FRAG"
4848                    "\15M_FIRSTFRAG\16M_LASTFRAG\21M_VLANTAG"
4849                    "\22M_PROMISC\23M_NOFREE",
4850                    (int)m->m_pkthdr.csum_flags,
4851                    "\20\1CSUM_IP\2CSUM_TCP\3CSUM_UDP\4CSUM_IP_FRAGS"
4852                    "\5CSUM_FRAGMENT\6CSUM_TSO\11CSUM_IP_CHECKED"
4853                    "\12CSUM_IP_VALID\13CSUM_DATA_VALID"
4854                    "\14CSUM_PSEUDO_HDR");
4855         }
4856
4857         if (m->m_flags & M_EXT) {
4858             switch (m->m_ext.ext_type) {
4859             case EXT_CLUSTER:    type = "EXT_CLUSTER";    break;
4860             case EXT_SFBUF:      type = "EXT_SFBUF";      break;
4861             case EXT_JUMBOP:     type = "EXT_JUMBOP";     break;
4862             case EXT_JUMBO9:     type = "EXT_JUMBO9";     break;
4863             case EXT_JUMBO16:    type = "EXT_JUMBO16";    break;
4864             case EXT_PACKET:     type = "EXT_PACKET";     break;
4865             case EXT_MBUF:       type = "EXT_MBUF";       break;
4866             case EXT_NET_DRV:    type = "EXT_NET_DRV";    break;
4867             case EXT_MOD_TYPE:   type = "EXT_MOD_TYPE";   break;
4868             case EXT_DISPOSABLE: type = "EXT_DISPOSABLE"; break;
4869             case EXT_EXTREF:     type = "EXT_EXTREF";     break;
4870             default:             type = "UNKNOWN";        break;
4871             }
4872
4873             BLOGD(sc, DBG_MBUF,
4874                   "%02d: - m_ext: %p ext_size=%d type=%s\n",
4875                   i, m->m_ext.ext_buf, m->m_ext.ext_size, type);
4876         }
4877
4878         if (contents) {
4879             bxe_dump_mbuf_data(sc, "mbuf data", m, TRUE);
4880         }
4881
4882         m = m->m_next;
4883         i++;
4884     }
4885 }
4886
4887 /*
4888  * Checks to ensure the 13 bd sliding window is >= MSS for TSO.
4889  * Check that (13 total bds - 3 bds) = 10 bd window >= MSS.
4890  * The window: 3 bds are = 1 for headers BD + 2 for parse BD and last BD
4891  * The headers comes in a seperate bd in FreeBSD so 13-3=10.
4892  * Returns: 0 if OK to send, 1 if packet needs further defragmentation
4893  */
4894 static int
4895 bxe_chktso_window(struct bxe_softc  *sc,
4896                   int               nsegs,
4897                   bus_dma_segment_t *segs,
4898                   struct mbuf       *m)
4899 {
4900     uint32_t num_wnds, wnd_size, wnd_sum;
4901     int32_t frag_idx, wnd_idx;
4902     unsigned short lso_mss;
4903     int defrag;
4904
4905     defrag = 0;
4906     wnd_sum = 0;
4907     wnd_size = 10;
4908     num_wnds = nsegs - wnd_size;
4909     lso_mss = htole16(m->m_pkthdr.tso_segsz);
4910
4911     /*
4912      * Total header lengths Eth+IP+TCP in first FreeBSD mbuf so calculate the
4913      * first window sum of data while skipping the first assuming it is the
4914      * header in FreeBSD.
4915      */
4916     for (frag_idx = 1; (frag_idx <= wnd_size); frag_idx++) {
4917         wnd_sum += htole16(segs[frag_idx].ds_len);
4918     }
4919
4920     /* check the first 10 bd window size */
4921     if (wnd_sum < lso_mss) {
4922         return (1);
4923     }
4924
4925     /* run through the windows */
4926     for (wnd_idx = 0; wnd_idx < num_wnds; wnd_idx++, frag_idx++) {
4927         /* subtract the first mbuf->m_len of the last wndw(-header) */
4928         wnd_sum -= htole16(segs[wnd_idx+1].ds_len);
4929         /* add the next mbuf len to the len of our new window */
4930         wnd_sum += htole16(segs[frag_idx].ds_len);
4931         if (wnd_sum < lso_mss) {
4932             return (1);
4933         }
4934     }
4935
4936     return (0);
4937 }
4938
4939 static uint8_t
4940 bxe_set_pbd_csum_e2(struct bxe_fastpath *fp,
4941                     struct mbuf         *m,
4942                     uint32_t            *parsing_data)
4943 {
4944     struct ether_vlan_header *eh = NULL;
4945     struct ip *ip4 = NULL;
4946     struct ip6_hdr *ip6 = NULL;
4947     caddr_t ip = NULL;
4948     struct tcphdr *th = NULL;
4949     int e_hlen, ip_hlen, l4_off;
4950     uint16_t proto;
4951
4952     if (m->m_pkthdr.csum_flags == CSUM_IP) {
4953         /* no L4 checksum offload needed */
4954         return (0);
4955     }
4956
4957     /* get the Ethernet header */
4958     eh = mtod(m, struct ether_vlan_header *);
4959
4960     /* handle VLAN encapsulation if present */
4961     if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
4962         e_hlen = (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
4963         proto  = ntohs(eh->evl_proto);
4964     } else {
4965         e_hlen = ETHER_HDR_LEN;
4966         proto  = ntohs(eh->evl_encap_proto);
4967     }
4968
4969     switch (proto) {
4970     case ETHERTYPE_IP:
4971         /* get the IP header, if mbuf len < 20 then header in next mbuf */
4972         ip4 = (m->m_len < sizeof(struct ip)) ?
4973                   (struct ip *)m->m_next->m_data :
4974                   (struct ip *)(m->m_data + e_hlen);
4975         /* ip_hl is number of 32-bit words */
4976         ip_hlen = (ip4->ip_hl << 2);
4977         ip = (caddr_t)ip4;
4978         break;
4979     case ETHERTYPE_IPV6:
4980         /* get the IPv6 header, if mbuf len < 40 then header in next mbuf */
4981         ip6 = (m->m_len < sizeof(struct ip6_hdr)) ?
4982                   (struct ip6_hdr *)m->m_next->m_data :
4983                   (struct ip6_hdr *)(m->m_data + e_hlen);
4984         /* XXX cannot support offload with IPv6 extensions */
4985         ip_hlen = sizeof(struct ip6_hdr);
4986         ip = (caddr_t)ip6;
4987         break;
4988     default:
4989         /* We can't offload in this case... */
4990         /* XXX error stat ??? */
4991         return (0);
4992     }
4993
4994     /* XXX assuming L4 header is contiguous to IPv4/IPv6 in the same mbuf */
4995     l4_off = (e_hlen + ip_hlen);
4996
4997     *parsing_data |=
4998         (((l4_off >> 1) << ETH_TX_PARSE_BD_E2_L4_HDR_START_OFFSET_W_SHIFT) &
4999          ETH_TX_PARSE_BD_E2_L4_HDR_START_OFFSET_W);
5000
5001     if (m->m_pkthdr.csum_flags & (CSUM_TCP |
5002                                   CSUM_TSO |
5003                                   CSUM_TCP_IPV6)) {
5004         fp->eth_q_stats.tx_ofld_frames_csum_tcp++;
5005         th = (struct tcphdr *)(ip + ip_hlen);
5006         /* th_off is number of 32-bit words */
5007         *parsing_data |= ((th->th_off <<
5008                            ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW_SHIFT) &
5009                           ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW);
5010         return (l4_off + (th->th_off << 2)); /* entire header length */
5011     } else if (m->m_pkthdr.csum_flags & (CSUM_UDP |
5012                                          CSUM_UDP_IPV6)) {
5013         fp->eth_q_stats.tx_ofld_frames_csum_udp++;
5014         return (l4_off + sizeof(struct udphdr)); /* entire header length */
5015     } else {
5016         /* XXX error stat ??? */
5017         return (0);
5018     }
5019 }
5020
5021 static uint8_t
5022 bxe_set_pbd_csum(struct bxe_fastpath        *fp,
5023                  struct mbuf                *m,
5024                  struct eth_tx_parse_bd_e1x *pbd)
5025 {
5026     struct ether_vlan_header *eh = NULL;
5027     struct ip *ip4 = NULL;
5028     struct ip6_hdr *ip6 = NULL;
5029     caddr_t ip = NULL;
5030     struct tcphdr *th = NULL;
5031     struct udphdr *uh = NULL;
5032     int e_hlen, ip_hlen;
5033     uint16_t proto;
5034     uint8_t hlen;
5035     uint16_t tmp_csum;
5036     uint32_t *tmp_uh;
5037
5038     /* get the Ethernet header */
5039     eh = mtod(m, struct ether_vlan_header *);
5040
5041     /* handle VLAN encapsulation if present */
5042     if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
5043         e_hlen = (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN);
5044         proto  = ntohs(eh->evl_proto);
5045     } else {
5046         e_hlen = ETHER_HDR_LEN;
5047         proto  = ntohs(eh->evl_encap_proto);
5048     }
5049
5050     switch (proto) {
5051     case ETHERTYPE_IP:
5052         /* get the IP header, if mbuf len < 20 then header in next mbuf */
5053         ip4 = (m->m_len < sizeof(struct ip)) ?
5054                   (struct ip *)m->m_next->m_data :
5055                   (struct ip *)(m->m_data + e_hlen);
5056         /* ip_hl is number of 32-bit words */
5057         ip_hlen = (ip4->ip_hl << 1);
5058         ip = (caddr_t)ip4;
5059         break;
5060     case ETHERTYPE_IPV6:
5061         /* get the IPv6 header, if mbuf len < 40 then header in next mbuf */
5062         ip6 = (m->m_len < sizeof(struct ip6_hdr)) ?
5063                   (struct ip6_hdr *)m->m_next->m_data :
5064                   (struct ip6_hdr *)(m->m_data + e_hlen);
5065         /* XXX cannot support offload with IPv6 extensions */
5066         ip_hlen = (sizeof(struct ip6_hdr) >> 1);
5067         ip = (caddr_t)ip6;
5068         break;
5069     default:
5070         /* We can't offload in this case... */
5071         /* XXX error stat ??? */
5072         return (0);
5073     }
5074
5075     hlen = (e_hlen >> 1);
5076
5077     /* note that rest of global_data is indirectly zeroed here */
5078     if (m->m_flags & M_VLANTAG) {
5079         pbd->global_data =
5080             htole16(hlen | (1 << ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT));
5081     } else {
5082         pbd->global_data = htole16(hlen);
5083     }
5084
5085     pbd->ip_hlen_w = ip_hlen;
5086
5087     hlen += pbd->ip_hlen_w;
5088
5089     /* XXX assuming L4 header is contiguous to IPv4/IPv6 in the same mbuf */
5090
5091     if (m->m_pkthdr.csum_flags & (CSUM_TCP |
5092                                   CSUM_TSO |
5093                                   CSUM_TCP_IPV6)) {
5094         th = (struct tcphdr *)(ip + (ip_hlen << 1));
5095         /* th_off is number of 32-bit words */
5096         hlen += (uint16_t)(th->th_off << 1);
5097     } else if (m->m_pkthdr.csum_flags & (CSUM_UDP |
5098                                          CSUM_UDP_IPV6)) {
5099         uh = (struct udphdr *)(ip + (ip_hlen << 1));
5100         hlen += (sizeof(struct udphdr) / 2);
5101     } else {
5102         /* valid case as only CSUM_IP was set */
5103         return (0);
5104     }
5105
5106     pbd->total_hlen_w = htole16(hlen);
5107
5108     if (m->m_pkthdr.csum_flags & (CSUM_TCP |
5109                                   CSUM_TSO |
5110                                   CSUM_TCP_IPV6)) {
5111         fp->eth_q_stats.tx_ofld_frames_csum_tcp++;
5112         pbd->tcp_pseudo_csum = ntohs(th->th_sum);
5113     } else if (m->m_pkthdr.csum_flags & (CSUM_UDP |
5114                                          CSUM_UDP_IPV6)) {
5115         fp->eth_q_stats.tx_ofld_frames_csum_udp++;
5116
5117         /*
5118          * Everest1 (i.e. 57710, 57711, 57711E) does not natively support UDP
5119          * checksums and does not know anything about the UDP header and where
5120          * the checksum field is located. It only knows about TCP. Therefore
5121          * we "lie" to the hardware for outgoing UDP packets w/ checksum
5122          * offload. Since the checksum field offset for TCP is 16 bytes and
5123          * for UDP it is 6 bytes we pass a pointer to the hardware that is 10
5124          * bytes less than the start of the UDP header. This allows the
5125          * hardware to write the checksum in the correct spot. But the
5126          * hardware will compute a checksum which includes the last 10 bytes
5127          * of the IP header. To correct this we tweak the stack computed
5128          * pseudo checksum by folding in the calculation of the inverse
5129          * checksum for those final 10 bytes of the IP header. This allows
5130          * the correct checksum to be computed by the hardware.
5131          */
5132
5133         /* set pointer 10 bytes before UDP header */
5134         tmp_uh = (uint32_t *)((uint8_t *)uh - 10);
5135
5136         /* calculate a pseudo header checksum over the first 10 bytes */
5137         tmp_csum = in_pseudo(*tmp_uh,
5138                              *(tmp_uh + 1),
5139                              *(uint16_t *)(tmp_uh + 2));
5140
5141         pbd->tcp_pseudo_csum = ntohs(in_addword(uh->uh_sum, ~tmp_csum));
5142     }
5143
5144     return (hlen * 2); /* entire header length, number of bytes */
5145 }
5146
5147 static void
5148 bxe_set_pbd_lso_e2(struct mbuf *m,
5149                    uint32_t    *parsing_data)
5150 {
5151     *parsing_data |= ((m->m_pkthdr.tso_segsz <<
5152                        ETH_TX_PARSE_BD_E2_LSO_MSS_SHIFT) &
5153                       ETH_TX_PARSE_BD_E2_LSO_MSS);
5154
5155     /* XXX test for IPv6 with extension header... */
5156 }
5157
5158 static void
5159 bxe_set_pbd_lso(struct mbuf                *m,
5160                 struct eth_tx_parse_bd_e1x *pbd)
5161 {
5162     struct ether_vlan_header *eh = NULL;
5163     struct ip *ip = NULL;
5164     struct tcphdr *th = NULL;
5165     int e_hlen;
5166
5167     /* get the Ethernet header */
5168     eh = mtod(m, struct ether_vlan_header *);
5169
5170     /* handle VLAN encapsulation if present */
5171     e_hlen = (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) ?
5172                  (ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN) : ETHER_HDR_LEN;
5173
5174     /* get the IP and TCP header, with LSO entire header in first mbuf */
5175     /* XXX assuming IPv4 */
5176     ip = (struct ip *)(m->m_data + e_hlen);
5177     th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
5178
5179     pbd->lso_mss = htole16(m->m_pkthdr.tso_segsz);
5180     pbd->tcp_send_seq = ntohl(th->th_seq);
5181     pbd->tcp_flags = ((ntohl(((uint32_t *)th)[3]) >> 16) & 0xff);
5182
5183 #if 1
5184         /* XXX IPv4 */
5185         pbd->ip_id = ntohs(ip->ip_id);
5186         pbd->tcp_pseudo_csum =
5187             ntohs(in_pseudo(ip->ip_src.s_addr,
5188                             ip->ip_dst.s_addr,
5189                             htons(IPPROTO_TCP)));
5190 #else
5191         /* XXX IPv6 */
5192         pbd->tcp_pseudo_csum =
5193             ntohs(in_pseudo(&ip6->ip6_src,
5194                             &ip6->ip6_dst,
5195                             htons(IPPROTO_TCP)));
5196 #endif
5197
5198     pbd->global_data |=
5199         htole16(ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN);
5200 }
5201
5202 /*
5203  * Encapsulte an mbuf cluster into the tx bd chain and makes the memory
5204  * visible to the controller.
5205  *
5206  * If an mbuf is submitted to this routine and cannot be given to the
5207  * controller (e.g. it has too many fragments) then the function may free
5208  * the mbuf and return to the caller.
5209  *
5210  * Returns:
5211  *   0 = Success, !0 = Failure
5212  *   Note the side effect that an mbuf may be freed if it causes a problem.
5213  */
5214 static int
5215 bxe_tx_encap(struct bxe_fastpath *fp, struct mbuf **m_head)
5216 {
5217     bus_dma_segment_t segs[32];
5218     struct mbuf *m0;
5219     struct bxe_sw_tx_bd *tx_buf;
5220     struct eth_tx_parse_bd_e1x *pbd_e1x = NULL;
5221     struct eth_tx_parse_bd_e2 *pbd_e2 = NULL;
5222     /* struct eth_tx_parse_2nd_bd *pbd2 = NULL; */
5223     struct eth_tx_bd *tx_data_bd;
5224     struct eth_tx_bd *tx_total_pkt_size_bd;
5225     struct eth_tx_start_bd *tx_start_bd;
5226     uint16_t bd_prod, pkt_prod, total_pkt_size;
5227     uint8_t mac_type;
5228     int defragged, error, nsegs, rc, nbds, vlan_off, ovlan;
5229     struct bxe_softc *sc;
5230     uint16_t tx_bd_avail;
5231     struct ether_vlan_header *eh;
5232     uint32_t pbd_e2_parsing_data = 0;
5233     uint8_t hlen = 0;
5234     int tmp_bd;
5235     int i;
5236
5237     sc = fp->sc;
5238
5239     M_ASSERTPKTHDR(*m_head);
5240
5241     m0 = *m_head;
5242     rc = defragged = nbds = ovlan = vlan_off = total_pkt_size = 0;
5243     tx_start_bd = NULL;
5244     tx_data_bd = NULL;
5245     tx_total_pkt_size_bd = NULL;
5246
5247     /* get the H/W pointer for packets and BDs */
5248     pkt_prod = fp->tx_pkt_prod;
5249     bd_prod = fp->tx_bd_prod;
5250
5251     mac_type = UNICAST_ADDRESS;
5252
5253     /* map the mbuf into the next open DMAable memory */
5254     tx_buf = &fp->tx_mbuf_chain[TX_BD(pkt_prod)];
5255     error = bus_dmamap_load_mbuf_sg(fp->tx_mbuf_tag,
5256                                     tx_buf->m_map, m0,
5257                                     segs, &nsegs, BUS_DMA_NOWAIT);
5258
5259     /* mapping errors */
5260     if(__predict_false(error != 0)) {
5261         fp->eth_q_stats.tx_dma_mapping_failure++;
5262         if (error == ENOMEM) {
5263             /* resource issue, try again later */
5264             rc = ENOMEM;
5265         } else if (error == EFBIG) {
5266             /* possibly recoverable with defragmentation */
5267             fp->eth_q_stats.mbuf_defrag_attempts++;
5268             m0 = m_defrag(*m_head, M_DONTWAIT);
5269             if (m0 == NULL) {
5270                 fp->eth_q_stats.mbuf_defrag_failures++;
5271                 rc = ENOBUFS;
5272             } else {
5273                 /* defrag successful, try mapping again */
5274                 *m_head = m0;
5275                 error = bus_dmamap_load_mbuf_sg(fp->tx_mbuf_tag,
5276                                                 tx_buf->m_map, m0,
5277                                                 segs, &nsegs, BUS_DMA_NOWAIT);
5278                 if (error) {
5279                     fp->eth_q_stats.tx_dma_mapping_failure++;
5280                     rc = error;
5281                 }
5282             }
5283         } else {
5284             /* unknown, unrecoverable mapping error */
5285             BLOGE(sc, "Unknown TX mapping error rc=%d\n", error);
5286             bxe_dump_mbuf(sc, m0, FALSE);
5287             rc = error;
5288         }
5289
5290         goto bxe_tx_encap_continue;
5291     }
5292
5293     tx_bd_avail = bxe_tx_avail(sc, fp);
5294
5295     /* make sure there is enough room in the send queue */
5296     if (__predict_false(tx_bd_avail < (nsegs + 2))) {
5297         /* Recoverable, try again later. */
5298         fp->eth_q_stats.tx_hw_queue_full++;
5299         bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5300         rc = ENOMEM;
5301         goto bxe_tx_encap_continue;
5302     }
5303
5304     /* capture the current H/W TX chain high watermark */
5305     if (__predict_false(fp->eth_q_stats.tx_hw_max_queue_depth <
5306                         (TX_BD_USABLE - tx_bd_avail))) {
5307         fp->eth_q_stats.tx_hw_max_queue_depth = (TX_BD_USABLE - tx_bd_avail);
5308     }
5309
5310     /* make sure it fits in the packet window */
5311     if (__predict_false(nsegs > BXE_MAX_SEGMENTS)) {
5312         /*
5313          * The mbuf may be to big for the controller to handle. If the frame
5314          * is a TSO frame we'll need to do an additional check.
5315          */
5316         if (m0->m_pkthdr.csum_flags & CSUM_TSO) {
5317             if (bxe_chktso_window(sc, nsegs, segs, m0) == 0) {
5318                 goto bxe_tx_encap_continue; /* OK to send */
5319             } else {
5320                 fp->eth_q_stats.tx_window_violation_tso++;
5321             }
5322         } else {
5323             fp->eth_q_stats.tx_window_violation_std++;
5324         }
5325
5326         /* lets try to defragment this mbuf and remap it */
5327         fp->eth_q_stats.mbuf_defrag_attempts++;
5328         bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5329
5330         m0 = m_defrag(*m_head, M_DONTWAIT);
5331         if (m0 == NULL) {
5332             fp->eth_q_stats.mbuf_defrag_failures++;
5333             /* Ugh, just drop the frame... :( */
5334             rc = ENOBUFS;
5335         } else {
5336             /* defrag successful, try mapping again */
5337             *m_head = m0;
5338             error = bus_dmamap_load_mbuf_sg(fp->tx_mbuf_tag,
5339                                             tx_buf->m_map, m0,
5340                                             segs, &nsegs, BUS_DMA_NOWAIT);
5341             if (error) {
5342                 fp->eth_q_stats.tx_dma_mapping_failure++;
5343                 /* No sense in trying to defrag/copy chain, drop it. :( */
5344                 rc = error;
5345             }
5346             else {
5347                 /* if the chain is still too long then drop it */
5348                 if (__predict_false(nsegs > BXE_MAX_SEGMENTS)) {
5349                     bus_dmamap_unload(fp->tx_mbuf_tag, tx_buf->m_map);
5350                     rc = ENODEV;
5351                 }
5352             }
5353         }
5354     }
5355
5356 bxe_tx_encap_continue:
5357
5358     /* Check for errors */
5359     if (rc) {
5360         if (rc == ENOMEM) {
5361             /* recoverable try again later  */
5362         } else {
5363             fp->eth_q_stats.tx_soft_errors++;
5364             fp->eth_q_stats.mbuf_alloc_tx--;
5365             m_freem(*m_head);
5366             *m_head = NULL;
5367         }
5368
5369         return (rc);
5370     }
5371
5372     /* set flag according to packet type (UNICAST_ADDRESS is default) */
5373     if (m0->m_flags & M_BCAST) {
5374         mac_type = BROADCAST_ADDRESS;
5375     } else if (m0->m_flags & M_MCAST) {
5376         mac_type = MULTICAST_ADDRESS;
5377     }
5378
5379     /* store the mbuf into the mbuf ring */
5380     tx_buf->m        = m0;
5381     tx_buf->first_bd = fp->tx_bd_prod;
5382     tx_buf->flags    = 0;
5383
5384     /* prepare the first transmit (start) BD for the mbuf */
5385     tx_start_bd = &fp->tx_chain[TX_BD(bd_prod)].start_bd;
5386
5387     BLOGD(sc, DBG_TX,
5388           "sending pkt_prod=%u tx_buf=%p next_idx=%u bd=%u tx_start_bd=%p\n",
5389           pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_start_bd);
5390
5391     tx_start_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr));
5392     tx_start_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr));
5393     tx_start_bd->nbytes  = htole16(segs[0].ds_len);
5394     total_pkt_size += tx_start_bd->nbytes;
5395     tx_start_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
5396
5397     tx_start_bd->general_data = (1 << ETH_TX_START_BD_HDR_NBDS_SHIFT);
5398
5399     /* all frames have at least Start BD + Parsing BD */
5400     nbds = nsegs + 1;
5401     tx_start_bd->nbd = htole16(nbds);
5402
5403     if (m0->m_flags & M_VLANTAG) {
5404         tx_start_bd->vlan_or_ethertype = htole16(m0->m_pkthdr.ether_vtag);
5405         tx_start_bd->bd_flags.as_bitfield |=
5406             (X_ETH_OUTBAND_VLAN << ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
5407     } else {
5408         /* vf tx, start bd must hold the ethertype for fw to enforce it */
5409         if (IS_VF(sc)) {
5410             /* map ethernet header to find type and header length */
5411             eh = mtod(m0, struct ether_vlan_header *);
5412             tx_start_bd->vlan_or_ethertype = eh->evl_encap_proto;
5413         } else {
5414             /* used by FW for packet accounting */
5415             tx_start_bd->vlan_or_ethertype = htole16(fp->tx_pkt_prod);
5416         }
5417     }
5418
5419     /*
5420      * add a parsing BD from the chain. The parsing BD is always added
5421      * though it is only used for TSO and chksum
5422      */
5423     bd_prod = TX_BD_NEXT(bd_prod);
5424
5425     if (m0->m_pkthdr.csum_flags) {
5426         if (m0->m_pkthdr.csum_flags & CSUM_IP) {
5427             fp->eth_q_stats.tx_ofld_frames_csum_ip++;
5428             tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_IP_CSUM;
5429         }
5430
5431         if (m0->m_pkthdr.csum_flags & CSUM_TCP_IPV6) {
5432             tx_start_bd->bd_flags.as_bitfield |= (ETH_TX_BD_FLAGS_IPV6 |
5433                                                   ETH_TX_BD_FLAGS_L4_CSUM);
5434         } else if (m0->m_pkthdr.csum_flags & CSUM_UDP_IPV6) {
5435             tx_start_bd->bd_flags.as_bitfield |= (ETH_TX_BD_FLAGS_IPV6   |
5436                                                   ETH_TX_BD_FLAGS_IS_UDP |
5437                                                   ETH_TX_BD_FLAGS_L4_CSUM);
5438         } else if ((m0->m_pkthdr.csum_flags & CSUM_TCP) ||
5439                    (m0->m_pkthdr.csum_flags & CSUM_TSO)) {
5440             tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_L4_CSUM;
5441         } else if (m0->m_pkthdr.csum_flags & CSUM_UDP) {
5442             tx_start_bd->bd_flags.as_bitfield |= (ETH_TX_BD_FLAGS_L4_CSUM |
5443                                                   ETH_TX_BD_FLAGS_IS_UDP);
5444         }
5445     }
5446
5447     if (!CHIP_IS_E1x(sc)) {
5448         pbd_e2 = &fp->tx_chain[TX_BD(bd_prod)].parse_bd_e2;
5449         memset(pbd_e2, 0, sizeof(struct eth_tx_parse_bd_e2));
5450
5451         if (m0->m_pkthdr.csum_flags) {
5452             hlen = bxe_set_pbd_csum_e2(fp, m0, &pbd_e2_parsing_data);
5453         }
5454
5455         SET_FLAG(pbd_e2_parsing_data, ETH_TX_PARSE_BD_E2_ETH_ADDR_TYPE,
5456                  mac_type);
5457     } else {
5458         uint16_t global_data = 0;
5459
5460         pbd_e1x = &fp->tx_chain[TX_BD(bd_prod)].parse_bd_e1x;
5461         memset(pbd_e1x, 0, sizeof(struct eth_tx_parse_bd_e1x));
5462
5463         if (m0->m_pkthdr.csum_flags) {
5464             hlen = bxe_set_pbd_csum(fp, m0, pbd_e1x);
5465         }
5466
5467         SET_FLAG(global_data,
5468                  ETH_TX_PARSE_BD_E1X_ETH_ADDR_TYPE, mac_type);
5469         pbd_e1x->global_data |= htole16(global_data);
5470     }
5471
5472     /* setup the parsing BD with TSO specific info */
5473     if (m0->m_pkthdr.csum_flags & CSUM_TSO) {
5474         fp->eth_q_stats.tx_ofld_frames_lso++;
5475         tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
5476
5477         if (__predict_false(tx_start_bd->nbytes > hlen)) {
5478             fp->eth_q_stats.tx_ofld_frames_lso_hdr_splits++;
5479
5480             /* split the first BD into header/data making the fw job easy */
5481             nbds++;
5482             tx_start_bd->nbd = htole16(nbds);
5483             tx_start_bd->nbytes = htole16(hlen);
5484
5485             bd_prod = TX_BD_NEXT(bd_prod);
5486
5487             /* new transmit BD after the tx_parse_bd */
5488             tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
5489             tx_data_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr + hlen));
5490             tx_data_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr + hlen));
5491             tx_data_bd->nbytes  = htole16(segs[0].ds_len - hlen);
5492             if (tx_total_pkt_size_bd == NULL) {
5493                 tx_total_pkt_size_bd = tx_data_bd;
5494             }
5495
5496             BLOGD(sc, DBG_TX,
5497                   "TSO split header size is %d (%x:%x) nbds %d\n",
5498                   le16toh(tx_start_bd->nbytes),
5499                   le32toh(tx_start_bd->addr_hi),
5500                   le32toh(tx_start_bd->addr_lo),
5501                   nbds);
5502         }
5503
5504         if (!CHIP_IS_E1x(sc)) {
5505             bxe_set_pbd_lso_e2(m0, &pbd_e2_parsing_data);
5506         } else {
5507             bxe_set_pbd_lso(m0, pbd_e1x);
5508         }
5509     }
5510
5511     if (pbd_e2_parsing_data) {
5512         pbd_e2->parsing_data = htole32(pbd_e2_parsing_data);
5513     }
5514
5515     /* prepare remaining BDs, start tx bd contains first seg/frag */
5516     for (i = 1; i < nsegs ; i++) {
5517         bd_prod = TX_BD_NEXT(bd_prod);
5518         tx_data_bd = &fp->tx_chain[TX_BD(bd_prod)].reg_bd;
5519         tx_data_bd->addr_lo = htole32(U64_LO(segs[i].ds_addr));
5520         tx_data_bd->addr_hi = htole32(U64_HI(segs[i].ds_addr));
5521         tx_data_bd->nbytes  = htole16(segs[i].ds_len);
5522         if (tx_total_pkt_size_bd == NULL) {
5523             tx_total_pkt_size_bd = tx_data_bd;
5524         }
5525         total_pkt_size += tx_data_bd->nbytes;
5526     }
5527
5528     BLOGD(sc, DBG_TX, "last bd %p\n", tx_data_bd);
5529
5530     if (tx_total_pkt_size_bd != NULL) {
5531         tx_total_pkt_size_bd->total_pkt_bytes = total_pkt_size;
5532     }
5533
5534     if (__predict_false(sc->debug & DBG_TX)) {
5535         tmp_bd = tx_buf->first_bd;
5536         for (i = 0; i < nbds; i++)
5537         {
5538             if (i == 0) {
5539                 BLOGD(sc, DBG_TX,
5540                       "TX Strt: %p bd=%d nbd=%d vlan=0x%x "
5541                       "bd_flags=0x%x hdr_nbds=%d\n",
5542                       tx_start_bd,
5543                       tmp_bd,
5544                       le16toh(tx_start_bd->nbd),
5545                       le16toh(tx_start_bd->vlan_or_ethertype),
5546                       tx_start_bd->bd_flags.as_bitfield,
5547                       (tx_start_bd->general_data & ETH_TX_START_BD_HDR_NBDS));
5548             } else if (i == 1) {
5549                 if (pbd_e1x) {
5550                     BLOGD(sc, DBG_TX,
5551                           "-> Prse: %p bd=%d global=0x%x ip_hlen_w=%u "
5552                           "ip_id=%u lso_mss=%u tcp_flags=0x%x csum=0x%x "
5553                           "tcp_seq=%u total_hlen_w=%u\n",
5554                           pbd_e1x,
5555                           tmp_bd,
5556                           pbd_e1x->global_data,
5557                           pbd_e1x->ip_hlen_w,
5558                           pbd_e1x->ip_id,
5559                           pbd_e1x->lso_mss,
5560                           pbd_e1x->tcp_flags,
5561                           pbd_e1x->tcp_pseudo_csum,
5562                           pbd_e1x->tcp_send_seq,
5563                           le16toh(pbd_e1x->total_hlen_w));
5564                 } else { /* if (pbd_e2) */
5565                     BLOGD(sc, DBG_TX,
5566                           "-> Parse: %p bd=%d dst=%02x:%02x:%02x "
5567                           "src=%02x:%02x:%02x parsing_data=0x%x\n",
5568                           pbd_e2,
5569                           tmp_bd,
5570                           pbd_e2->data.mac_addr.dst_hi,
5571                           pbd_e2->data.mac_addr.dst_mid,
5572                           pbd_e2->data.mac_addr.dst_lo,
5573                           pbd_e2->data.mac_addr.src_hi,
5574                           pbd_e2->data.mac_addr.src_mid,
5575                           pbd_e2->data.mac_addr.src_lo,
5576                           pbd_e2->parsing_data);
5577                 }
5578             }
5579
5580             if (i != 1) { /* skip parse db as it doesn't hold data */
5581                 tx_data_bd = &fp->tx_chain[TX_BD(tmp_bd)].reg_bd;
5582                 BLOGD(sc, DBG_TX,
5583                       "-> Frag: %p bd=%d nbytes=%d hi=0x%x lo: 0x%x\n",
5584                       tx_data_bd,
5585                       tmp_bd,
5586                       le16toh(tx_data_bd->nbytes),
5587                       le32toh(tx_data_bd->addr_hi),
5588                       le32toh(tx_data_bd->addr_lo));
5589             }
5590
5591             tmp_bd = TX_BD_NEXT(tmp_bd);
5592         }
5593     }
5594
5595     BLOGD(sc, DBG_TX, "doorbell: nbds=%d bd=%u\n", nbds, bd_prod);
5596
5597     /* update TX BD producer index value for next TX */
5598     bd_prod = TX_BD_NEXT(bd_prod);
5599
5600     /*
5601      * If the chain of tx_bd's describing this frame is adjacent to or spans
5602      * an eth_tx_next_bd element then we need to increment the nbds value.
5603      */
5604     if (TX_BD_IDX(bd_prod) < nbds) {
5605         nbds++;
5606     }
5607
5608     /* don't allow reordering of writes for nbd and packets */
5609     mb();
5610
5611     fp->tx_db.data.prod += nbds;
5612
5613     /* producer points to the next free tx_bd at this point */
5614     fp->tx_pkt_prod++;
5615     fp->tx_bd_prod = bd_prod;
5616
5617     DOORBELL(sc, fp->index, fp->tx_db.raw);
5618
5619     fp->eth_q_stats.tx_pkts++;
5620
5621     /* Prevent speculative reads from getting ahead of the status block. */
5622     bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle,
5623                       0, 0, BUS_SPACE_BARRIER_READ);
5624
5625     /* Prevent speculative reads from getting ahead of the doorbell. */
5626     bus_space_barrier(sc->bar[BAR2].tag, sc->bar[BAR2].handle,
5627                       0, 0, BUS_SPACE_BARRIER_READ);
5628
5629     return (0);
5630 }
5631
5632 static void
5633 bxe_tx_start_locked(struct bxe_softc    *sc,
5634                     struct ifnet        *ifp,
5635                     struct bxe_fastpath *fp)
5636 {
5637     struct mbuf *m = NULL;
5638     int tx_count = 0;
5639     uint16_t tx_bd_avail;
5640
5641     BXE_FP_TX_LOCK_ASSERT(fp);
5642
5643     /* keep adding entries while there are frames to send */
5644     while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) {
5645
5646         /*
5647          * check for any frames to send
5648          * dequeue can still be NULL even if queue is not empty
5649          */
5650         IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
5651         if (__predict_false(m == NULL)) {
5652             break;
5653         }
5654
5655         /* the mbuf now belongs to us */
5656         fp->eth_q_stats.mbuf_alloc_tx++;
5657
5658         /*
5659          * Put the frame into the transmit ring. If we don't have room,
5660          * place the mbuf back at the head of the TX queue, set the
5661          * OACTIVE flag, and wait for the NIC to drain the chain.
5662          */
5663         if (__predict_false(bxe_tx_encap(fp, &m))) {
5664             fp->eth_q_stats.tx_encap_failures++;
5665             if (m != NULL) {
5666                 /* mark the TX queue as full and return the frame */
5667                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
5668                 IFQ_DRV_PREPEND(&ifp->if_snd, m);
5669                 fp->eth_q_stats.mbuf_alloc_tx--;
5670                 fp->eth_q_stats.tx_queue_xoff++;
5671             }
5672
5673             /* stop looking for more work */
5674             break;
5675         }
5676
5677         /* the frame was enqueued successfully */
5678         tx_count++;
5679
5680         /* send a copy of the frame to any BPF listeners. */
5681         BPF_MTAP(ifp, m);
5682
5683         tx_bd_avail = bxe_tx_avail(sc, fp);
5684
5685         /* handle any completions if we're running low */
5686         if (tx_bd_avail < BXE_TX_CLEANUP_THRESHOLD) {
5687             /* bxe_txeof will set IFF_DRV_OACTIVE appropriately */
5688             bxe_txeof(sc, fp);
5689             if (ifp->if_drv_flags & IFF_DRV_OACTIVE) {
5690                 break;
5691             }
5692         }
5693     }
5694
5695     /* all TX packets were dequeued and/or the tx ring is full */
5696     if (tx_count > 0) {
5697         /* reset the TX watchdog timeout timer */
5698         fp->watchdog_timer = BXE_TX_TIMEOUT;
5699     }
5700 }
5701
5702 /* Legacy (non-RSS) dispatch routine */
5703 static void
5704 bxe_tx_start(struct ifnet *ifp)
5705 {
5706     struct bxe_softc *sc;
5707     struct bxe_fastpath *fp;
5708
5709     sc = ifp->if_softc;
5710
5711     if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
5712         BLOGW(sc, "Interface not running, ignoring transmit request\n");
5713         return;
5714     }
5715
5716     if (ifp->if_drv_flags & IFF_DRV_OACTIVE) {
5717         BLOGW(sc, "Interface TX queue is full, ignoring transmit request\n");
5718         return;
5719     }
5720
5721     if (!sc->link_vars.link_up) {
5722         BLOGW(sc, "Interface link is down, ignoring transmit request\n");
5723         return;
5724     }
5725
5726     fp = &sc->fp[0];
5727
5728     BXE_FP_TX_LOCK(fp);
5729     bxe_tx_start_locked(sc, ifp, fp);
5730     BXE_FP_TX_UNLOCK(fp);
5731 }
5732
5733 #if __FreeBSD_version >= 800000
5734
5735 static int
5736 bxe_tx_mq_start_locked(struct bxe_softc    *sc,
5737                        struct ifnet        *ifp,
5738                        struct bxe_fastpath *fp,
5739                        struct mbuf         *m)
5740 {
5741     struct buf_ring *tx_br = fp->tx_br;
5742     struct mbuf *next;
5743     int depth, rc, tx_count;
5744     uint16_t tx_bd_avail;
5745
5746     rc = tx_count = 0;
5747
5748     BXE_FP_TX_LOCK_ASSERT(fp);
5749
5750     if (!tx_br) {
5751         BLOGE(sc, "Multiqueue TX and no buf_ring!\n");
5752         return (EINVAL);
5753     }
5754
5755     if (!sc->link_vars.link_up ||
5756         (ifp->if_drv_flags &
5757         (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) != IFF_DRV_RUNNING) {
5758         rc = drbr_enqueue(ifp, tx_br, m);
5759         goto bxe_tx_mq_start_locked_exit;
5760     }
5761
5762     /* fetch the depth of the driver queue */
5763     depth = drbr_inuse(ifp, tx_br);
5764     if (depth > fp->eth_q_stats.tx_max_drbr_queue_depth) {
5765         fp->eth_q_stats.tx_max_drbr_queue_depth = depth;
5766     }
5767
5768     if (m == NULL) {
5769         /* no new work, check for pending frames */
5770         next = drbr_dequeue(ifp, tx_br);
5771     } else if (drbr_needs_enqueue(ifp, tx_br)) {
5772         /* have both new and pending work, maintain packet order */
5773         rc = drbr_enqueue(ifp, tx_br, m);
5774         if (rc != 0) {
5775             fp->eth_q_stats.tx_soft_errors++;
5776             goto bxe_tx_mq_start_locked_exit;
5777         }
5778         next = drbr_dequeue(ifp, tx_br);
5779     } else {
5780         /* new work only and nothing pending */
5781         next = m;
5782     }
5783
5784     /* keep adding entries while there are frames to send */
5785     while (next != NULL) {
5786
5787         /* the mbuf now belongs to us */
5788         fp->eth_q_stats.mbuf_alloc_tx++;
5789
5790         /*
5791          * Put the frame into the transmit ring. If we don't have room,
5792          * place the mbuf back at the head of the TX queue, set the
5793          * OACTIVE flag, and wait for the NIC to drain the chain.
5794          */
5795         rc = bxe_tx_encap(fp, &next);
5796         if (__predict_false(rc != 0)) {
5797             fp->eth_q_stats.tx_encap_failures++;
5798             if (next != NULL) {
5799                 /* mark the TX queue as full and save the frame */
5800                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
5801                 /* XXX this may reorder the frame */
5802                 rc = drbr_enqueue(ifp, tx_br, next);
5803                 fp->eth_q_stats.mbuf_alloc_tx--;
5804                 fp->eth_q_stats.tx_frames_deferred++;
5805             }
5806
5807             /* stop looking for more work */
5808             break;
5809         }
5810
5811         /* the transmit frame was enqueued successfully */
5812         tx_count++;
5813
5814         /* send a copy of the frame to any BPF listeners */
5815         BPF_MTAP(ifp, next);
5816
5817         tx_bd_avail = bxe_tx_avail(sc, fp);
5818
5819         /* handle any completions if we're running low */
5820         if (tx_bd_avail < BXE_TX_CLEANUP_THRESHOLD) {
5821             /* bxe_txeof will set IFF_DRV_OACTIVE appropriately */
5822             bxe_txeof(sc, fp);
5823             if (ifp->if_drv_flags & IFF_DRV_OACTIVE) {
5824                 break;
5825             }
5826         }
5827
5828         next = drbr_dequeue(ifp, tx_br);
5829     }
5830
5831     /* all TX packets were dequeued and/or the tx ring is full */
5832     if (tx_count > 0) {
5833         /* reset the TX watchdog timeout timer */
5834         fp->watchdog_timer = BXE_TX_TIMEOUT;
5835     }
5836
5837 bxe_tx_mq_start_locked_exit:
5838
5839     return (rc);
5840 }
5841
5842 /* Multiqueue (TSS) dispatch routine. */
5843 static int
5844 bxe_tx_mq_start(struct ifnet *ifp,
5845                 struct mbuf  *m)
5846 {
5847     struct bxe_softc *sc = ifp->if_softc;
5848     struct bxe_fastpath *fp;
5849     int fp_index, rc;
5850
5851     fp_index = 0; /* default is the first queue */
5852
5853     /* change the queue if using flow ID */
5854     if ((m->m_flags & M_FLOWID) != 0) {
5855         fp_index = (m->m_pkthdr.flowid % sc->num_queues);
5856     }
5857
5858     fp = &sc->fp[fp_index];
5859
5860     if (BXE_FP_TX_TRYLOCK(fp)) {
5861         rc = bxe_tx_mq_start_locked(sc, ifp, fp, m);
5862         BXE_FP_TX_UNLOCK(fp);
5863     } else
5864         rc = drbr_enqueue(ifp, fp->tx_br, m);
5865
5866     return (rc);
5867 }
5868
5869 static void
5870 bxe_mq_flush(struct ifnet *ifp)
5871 {
5872     struct bxe_softc *sc = ifp->if_softc;
5873     struct bxe_fastpath *fp;
5874     struct mbuf *m;
5875     int i;
5876
5877     for (i = 0; i < sc->num_queues; i++) {
5878         fp = &sc->fp[i];
5879
5880         if (fp->state != BXE_FP_STATE_OPEN) {
5881             BLOGD(sc, DBG_LOAD, "Not clearing fp[%02d] buf_ring (state=%d)\n",
5882                   fp->index, fp->state);
5883             continue;
5884         }
5885
5886         if (fp->tx_br != NULL) {
5887             BLOGD(sc, DBG_LOAD, "Clearing fp[%02d] buf_ring\n", fp->index);
5888             BXE_FP_TX_LOCK(fp);
5889             while ((m = buf_ring_dequeue_sc(fp->tx_br)) != NULL) {
5890                 m_freem(m);
5891             }
5892             BXE_FP_TX_UNLOCK(fp);
5893         }
5894     }
5895
5896     if_qflush(ifp);
5897 }
5898
5899 #endif /* FreeBSD_version >= 800000 */
5900
5901 static uint16_t
5902 bxe_cid_ilt_lines(struct bxe_softc *sc)
5903 {
5904     if (IS_SRIOV(sc)) {
5905         return ((BXE_FIRST_VF_CID + BXE_VF_CIDS) / ILT_PAGE_CIDS);
5906     }
5907     return (L2_ILT_LINES(sc));
5908 }
5909
5910 static void
5911 bxe_ilt_set_info(struct bxe_softc *sc)
5912 {
5913     struct ilt_client_info *ilt_client;
5914     struct ecore_ilt *ilt = sc->ilt;
5915     uint16_t line = 0;
5916
5917     ilt->start_line = FUNC_ILT_BASE(SC_FUNC(sc));
5918     BLOGD(sc, DBG_LOAD, "ilt starts at line %d\n", ilt->start_line);
5919
5920     /* CDU */
5921     ilt_client = &ilt->clients[ILT_CLIENT_CDU];
5922     ilt_client->client_num = ILT_CLIENT_CDU;
5923     ilt_client->page_size = CDU_ILT_PAGE_SZ;
5924     ilt_client->flags = ILT_CLIENT_SKIP_MEM;
5925     ilt_client->start = line;
5926     line += bxe_cid_ilt_lines(sc);
5927
5928     if (CNIC_SUPPORT(sc)) {
5929         line += CNIC_ILT_LINES;
5930     }
5931
5932     ilt_client->end = (line - 1);
5933
5934     BLOGD(sc, DBG_LOAD,
5935           "ilt client[CDU]: start %d, end %d, "
5936           "psz 0x%x, flags 0x%x, hw psz %d\n",
5937           ilt_client->start, ilt_client->end,
5938           ilt_client->page_size,
5939           ilt_client->flags,
5940           ilog2(ilt_client->page_size >> 12));
5941
5942     /* QM */
5943     if (QM_INIT(sc->qm_cid_count)) {
5944         ilt_client = &ilt->clients[ILT_CLIENT_QM];
5945         ilt_client->client_num = ILT_CLIENT_QM;
5946         ilt_client->page_size = QM_ILT_PAGE_SZ;
5947         ilt_client->flags = 0;
5948         ilt_client->start = line;
5949
5950         /* 4 bytes for each cid */
5951         line += DIV_ROUND_UP(sc->qm_cid_count * QM_QUEUES_PER_FUNC * 4,
5952                              QM_ILT_PAGE_SZ);
5953
5954         ilt_client->end = (line - 1);
5955
5956         BLOGD(sc, DBG_LOAD,
5957               "ilt client[QM]: start %d, end %d, "
5958               "psz 0x%x, flags 0x%x, hw psz %d\n",
5959               ilt_client->start, ilt_client->end,
5960               ilt_client->page_size, ilt_client->flags,
5961               ilog2(ilt_client->page_size >> 12));
5962     }
5963
5964     if (CNIC_SUPPORT(sc)) {
5965         /* SRC */
5966         ilt_client = &ilt->clients[ILT_CLIENT_SRC];
5967         ilt_client->client_num = ILT_CLIENT_SRC;
5968         ilt_client->page_size = SRC_ILT_PAGE_SZ;
5969         ilt_client->flags = 0;
5970         ilt_client->start = line;
5971         line += SRC_ILT_LINES;
5972         ilt_client->end = (line - 1);
5973
5974         BLOGD(sc, DBG_LOAD,
5975               "ilt client[SRC]: start %d, end %d, "
5976               "psz 0x%x, flags 0x%x, hw psz %d\n",
5977               ilt_client->start, ilt_client->end,
5978               ilt_client->page_size, ilt_client->flags,
5979               ilog2(ilt_client->page_size >> 12));
5980
5981         /* TM */
5982         ilt_client = &ilt->clients[ILT_CLIENT_TM];
5983         ilt_client->client_num = ILT_CLIENT_TM;
5984         ilt_client->page_size = TM_ILT_PAGE_SZ;
5985         ilt_client->flags = 0;
5986         ilt_client->start = line;
5987         line += TM_ILT_LINES;
5988         ilt_client->end = (line - 1);
5989
5990         BLOGD(sc, DBG_LOAD,
5991               "ilt client[TM]: start %d, end %d, "
5992               "psz 0x%x, flags 0x%x, hw psz %d\n",
5993               ilt_client->start, ilt_client->end,
5994               ilt_client->page_size, ilt_client->flags,
5995               ilog2(ilt_client->page_size >> 12));
5996     }
5997
5998     KASSERT((line <= ILT_MAX_LINES), ("Invalid number of ILT lines!"));
5999 }
6000
6001 static void
6002 bxe_set_fp_rx_buf_size(struct bxe_softc *sc)
6003 {
6004     int i;
6005     uint32_t rx_buf_size;
6006
6007     rx_buf_size = (IP_HEADER_ALIGNMENT_PADDING + ETH_OVERHEAD + sc->mtu);
6008
6009     for (i = 0; i < sc->num_queues; i++) {
6010         if(rx_buf_size <= MCLBYTES){
6011             sc->fp[i].rx_buf_size = rx_buf_size;
6012             sc->fp[i].mbuf_alloc_size = MCLBYTES;
6013         }else if (rx_buf_size <= MJUMPAGESIZE){
6014             sc->fp[i].rx_buf_size = rx_buf_size;
6015             sc->fp[i].mbuf_alloc_size = MJUMPAGESIZE;
6016         }else if (rx_buf_size <= (MJUMPAGESIZE + MCLBYTES)){
6017             sc->fp[i].rx_buf_size = MCLBYTES;
6018             sc->fp[i].mbuf_alloc_size = MCLBYTES;
6019         }else if (rx_buf_size <= (2 * MJUMPAGESIZE)){
6020             sc->fp[i].rx_buf_size = MJUMPAGESIZE;
6021             sc->fp[i].mbuf_alloc_size = MJUMPAGESIZE;
6022         }else {
6023             sc->fp[i].rx_buf_size = MCLBYTES;
6024             sc->fp[i].mbuf_alloc_size = MCLBYTES;
6025         }
6026     }
6027 }
6028
6029 static int
6030 bxe_alloc_ilt_mem(struct bxe_softc *sc)
6031 {
6032     int rc = 0;
6033
6034     if ((sc->ilt =
6035          (struct ecore_ilt *)malloc(sizeof(struct ecore_ilt),
6036                                     M_BXE_ILT,
6037                                     (M_NOWAIT | M_ZERO))) == NULL) {
6038         rc = 1;
6039     }
6040
6041     return (rc);
6042 }
6043
6044 static int
6045 bxe_alloc_ilt_lines_mem(struct bxe_softc *sc)
6046 {
6047     int rc = 0;
6048
6049     if ((sc->ilt->lines =
6050          (struct ilt_line *)malloc((sizeof(struct ilt_line) * ILT_MAX_LINES),
6051                                     M_BXE_ILT,
6052                                     (M_NOWAIT | M_ZERO))) == NULL) {
6053         rc = 1;
6054     }
6055
6056     return (rc);
6057 }
6058
6059 static void
6060 bxe_free_ilt_mem(struct bxe_softc *sc)
6061 {
6062     if (sc->ilt != NULL) {
6063         free(sc->ilt, M_BXE_ILT);
6064         sc->ilt = NULL;
6065     }
6066 }
6067
6068 static void
6069 bxe_free_ilt_lines_mem(struct bxe_softc *sc)
6070 {
6071     if (sc->ilt->lines != NULL) {
6072         free(sc->ilt->lines, M_BXE_ILT);
6073         sc->ilt->lines = NULL;
6074     }
6075 }
6076
6077 static void
6078 bxe_free_mem(struct bxe_softc *sc)
6079 {
6080     int i;
6081
6082     for (i = 0; i < L2_ILT_LINES(sc); i++) {
6083         bxe_dma_free(sc, &sc->context[i].vcxt_dma);
6084         sc->context[i].vcxt = NULL;
6085         sc->context[i].size = 0;
6086     }
6087
6088     ecore_ilt_mem_op(sc, ILT_MEMOP_FREE);
6089
6090     bxe_free_ilt_lines_mem(sc);
6091
6092 }
6093
6094 static int
6095 bxe_alloc_mem(struct bxe_softc *sc)
6096 {
6097     int context_size;
6098     int allocated;
6099     int i;
6100
6101     /*
6102      * Allocate memory for CDU context:
6103      * This memory is allocated separately and not in the generic ILT
6104      * functions because CDU differs in few aspects:
6105      * 1. There can be multiple entities allocating memory for context -
6106      * regular L2, CNIC, and SRIOV drivers. Each separately controls
6107      * its own ILT lines.
6108      * 2. Since CDU page-size is not a single 4KB page (which is the case
6109      * for the other ILT clients), to be efficient we want to support
6110      * allocation of sub-page-size in the last entry.
6111      * 3. Context pointers are used by the driver to pass to FW / update
6112      * the context (for the other ILT clients the pointers are used just to
6113      * free the memory during unload).
6114      */
6115     context_size = (sizeof(union cdu_context) * BXE_L2_CID_COUNT(sc));
6116     for (i = 0, allocated = 0; allocated < context_size; i++) {
6117         sc->context[i].size = min(CDU_ILT_PAGE_SZ,
6118                                   (context_size - allocated));
6119
6120         if (bxe_dma_alloc(sc, sc->context[i].size,
6121                           &sc->context[i].vcxt_dma,
6122                           "cdu context") != 0) {
6123             bxe_free_mem(sc);
6124             return (-1);
6125         }
6126
6127         sc->context[i].vcxt =
6128             (union cdu_context *)sc->context[i].vcxt_dma.vaddr;
6129
6130         allocated += sc->context[i].size;
6131     }
6132
6133     bxe_alloc_ilt_lines_mem(sc);
6134
6135     BLOGD(sc, DBG_LOAD, "ilt=%p start_line=%u lines=%p\n",
6136           sc->ilt, sc->ilt->start_line, sc->ilt->lines);
6137     {
6138         for (i = 0; i < 4; i++) {
6139             BLOGD(sc, DBG_LOAD,
6140                   "c%d page_size=%u start=%u end=%u num=%u flags=0x%x\n",
6141                   i,
6142                   sc->ilt->clients[i].page_size,
6143                   sc->ilt->clients[i].start,
6144                   sc->ilt->clients[i].end,
6145                   sc->ilt->clients[i].client_num,
6146                   sc->ilt->clients[i].flags);
6147         }
6148     }
6149     if (ecore_ilt_mem_op(sc, ILT_MEMOP_ALLOC)) {
6150         BLOGE(sc, "ecore_ilt_mem_op ILT_MEMOP_ALLOC failed\n");
6151         bxe_free_mem(sc);
6152         return (-1);
6153     }
6154
6155     return (0);
6156 }
6157
6158 static void
6159 bxe_free_rx_bd_chain(struct bxe_fastpath *fp)
6160 {
6161     struct bxe_softc *sc;
6162     int i;
6163
6164     sc = fp->sc;
6165
6166     if (fp->rx_mbuf_tag == NULL) {
6167         return;
6168     }
6169
6170     /* free all mbufs and unload all maps */
6171     for (i = 0; i < RX_BD_TOTAL; i++) {
6172         if (fp->rx_mbuf_chain[i].m_map != NULL) {
6173             bus_dmamap_sync(fp->rx_mbuf_tag,
6174                             fp->rx_mbuf_chain[i].m_map,
6175                             BUS_DMASYNC_POSTREAD);
6176             bus_dmamap_unload(fp->rx_mbuf_tag,
6177                               fp->rx_mbuf_chain[i].m_map);
6178         }
6179
6180         if (fp->rx_mbuf_chain[i].m != NULL) {
6181             m_freem(fp->rx_mbuf_chain[i].m);
6182             fp->rx_mbuf_chain[i].m = NULL;
6183             fp->eth_q_stats.mbuf_alloc_rx--;
6184         }
6185     }
6186 }
6187
6188 static void
6189 bxe_free_tpa_pool(struct bxe_fastpath *fp)
6190 {
6191     struct bxe_softc *sc;
6192     int i, max_agg_queues;
6193
6194     sc = fp->sc;
6195
6196     if (fp->rx_mbuf_tag == NULL) {
6197         return;
6198     }
6199
6200     max_agg_queues = MAX_AGG_QS(sc);
6201
6202     /* release all mbufs and unload all DMA maps in the TPA pool */
6203     for (i = 0; i < max_agg_queues; i++) {
6204         if (fp->rx_tpa_info[i].bd.m_map != NULL) {
6205             bus_dmamap_sync(fp->rx_mbuf_tag,
6206                             fp->rx_tpa_info[i].bd.m_map,
6207                             BUS_DMASYNC_POSTREAD);
6208             bus_dmamap_unload(fp->rx_mbuf_tag,
6209                               fp->rx_tpa_info[i].bd.m_map);
6210         }
6211
6212         if (fp->rx_tpa_info[i].bd.m != NULL) {
6213             m_freem(fp->rx_tpa_info[i].bd.m);
6214             fp->rx_tpa_info[i].bd.m = NULL;
6215             fp->eth_q_stats.mbuf_alloc_tpa--;
6216         }
6217     }
6218 }
6219
6220 static void
6221 bxe_free_sge_chain(struct bxe_fastpath *fp)
6222 {
6223     struct bxe_softc *sc;
6224     int i;
6225
6226     sc = fp->sc;
6227
6228     if (fp->rx_sge_mbuf_tag == NULL) {
6229         return;
6230     }
6231
6232     /* rree all mbufs and unload all maps */
6233     for (i = 0; i < RX_SGE_TOTAL; i++) {
6234         if (fp->rx_sge_mbuf_chain[i].m_map != NULL) {
6235             bus_dmamap_sync(fp->rx_sge_mbuf_tag,
6236                             fp->rx_sge_mbuf_chain[i].m_map,
6237                             BUS_DMASYNC_POSTREAD);
6238             bus_dmamap_unload(fp->rx_sge_mbuf_tag,
6239                               fp->rx_sge_mbuf_chain[i].m_map);
6240         }
6241
6242         if (fp->rx_sge_mbuf_chain[i].m != NULL) {
6243             m_freem(fp->rx_sge_mbuf_chain[i].m);
6244             fp->rx_sge_mbuf_chain[i].m = NULL;
6245             fp->eth_q_stats.mbuf_alloc_sge--;
6246         }
6247     }
6248 }
6249
6250 static void
6251 bxe_free_fp_buffers(struct bxe_softc *sc)
6252 {
6253     struct bxe_fastpath *fp;
6254     int i;
6255
6256     for (i = 0; i < sc->num_queues; i++) {
6257         fp = &sc->fp[i];
6258
6259 #if __FreeBSD_version >= 800000
6260         if (fp->tx_br != NULL) {
6261             /* just in case bxe_mq_flush() wasn't called */
6262             if (mtx_initialized(&fp->tx_mtx)) {
6263                 struct mbuf *m;
6264
6265                 BXE_FP_TX_LOCK(fp);
6266                 while ((m = buf_ring_dequeue_sc(fp->tx_br)) != NULL)
6267                     m_freem(m);
6268                 BXE_FP_TX_UNLOCK(fp);
6269             }
6270         }
6271 #endif
6272
6273         /* free all RX buffers */
6274         bxe_free_rx_bd_chain(fp);
6275         bxe_free_tpa_pool(fp);
6276         bxe_free_sge_chain(fp);
6277
6278         if (fp->eth_q_stats.mbuf_alloc_rx != 0) {
6279             BLOGE(sc, "failed to claim all rx mbufs (%d left)\n",
6280                   fp->eth_q_stats.mbuf_alloc_rx);
6281         }
6282
6283         if (fp->eth_q_stats.mbuf_alloc_sge != 0) {
6284             BLOGE(sc, "failed to claim all sge mbufs (%d left)\n",
6285                   fp->eth_q_stats.mbuf_alloc_sge);
6286         }
6287
6288         if (fp->eth_q_stats.mbuf_alloc_tpa != 0) {
6289             BLOGE(sc, "failed to claim all sge mbufs (%d left)\n",
6290                   fp->eth_q_stats.mbuf_alloc_tpa);
6291         }
6292
6293         if (fp->eth_q_stats.mbuf_alloc_tx != 0) {
6294             BLOGE(sc, "failed to release tx mbufs (%d left)\n",
6295                   fp->eth_q_stats.mbuf_alloc_tx);
6296         }
6297
6298         /* XXX verify all mbufs were reclaimed */
6299     }
6300 }
6301
6302 static int
6303 bxe_alloc_rx_bd_mbuf(struct bxe_fastpath *fp,
6304                      uint16_t            prev_index,
6305                      uint16_t            index)
6306 {
6307     struct bxe_sw_rx_bd *rx_buf;
6308     struct eth_rx_bd *rx_bd;
6309     bus_dma_segment_t segs[1];
6310     bus_dmamap_t map;
6311     struct mbuf *m;
6312     int nsegs, rc;
6313
6314     rc = 0;
6315
6316     /* allocate the new RX BD mbuf */
6317     m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, fp->mbuf_alloc_size);
6318     if (__predict_false(m == NULL)) {
6319         fp->eth_q_stats.mbuf_rx_bd_alloc_failed++;
6320         return (ENOBUFS);
6321     }
6322
6323     fp->eth_q_stats.mbuf_alloc_rx++;
6324
6325     /* initialize the mbuf buffer length */
6326     m->m_pkthdr.len = m->m_len = fp->rx_buf_size;
6327
6328     /* map the mbuf into non-paged pool */
6329     rc = bus_dmamap_load_mbuf_sg(fp->rx_mbuf_tag,
6330                                  fp->rx_mbuf_spare_map,
6331                                  m, segs, &nsegs, BUS_DMA_NOWAIT);
6332     if (__predict_false(rc != 0)) {
6333         fp->eth_q_stats.mbuf_rx_bd_mapping_failed++;
6334         m_freem(m);
6335         fp->eth_q_stats.mbuf_alloc_rx--;
6336         return (rc);
6337     }
6338
6339     /* all mbufs must map to a single segment */
6340     KASSERT((nsegs == 1), ("Too many segments, %d returned!", nsegs));
6341
6342     /* release any existing RX BD mbuf mappings */
6343
6344     if (prev_index != index) {
6345         rx_buf = &fp->rx_mbuf_chain[prev_index];
6346
6347         if (rx_buf->m_map != NULL) {
6348             bus_dmamap_sync(fp->rx_mbuf_tag, rx_buf->m_map,
6349                             BUS_DMASYNC_POSTREAD);
6350             bus_dmamap_unload(fp->rx_mbuf_tag, rx_buf->m_map);
6351         }
6352
6353         /*
6354          * We only get here from bxe_rxeof() when the maximum number
6355          * of rx buffers is less than RX_BD_USABLE. bxe_rxeof() already
6356          * holds the mbuf in the prev_index so it's OK to NULL it out
6357          * here without concern of a memory leak.
6358          */
6359         fp->rx_mbuf_chain[prev_index].m = NULL;
6360     }
6361
6362     rx_buf = &fp->rx_mbuf_chain[index];
6363
6364     if (rx_buf->m_map != NULL) {
6365         bus_dmamap_sync(fp->rx_mbuf_tag, rx_buf->m_map,
6366                         BUS_DMASYNC_POSTREAD);
6367         bus_dmamap_unload(fp->rx_mbuf_tag, rx_buf->m_map);
6368     }
6369
6370     /* save the mbuf and mapping info for a future packet */
6371     map = (prev_index != index) ?
6372               fp->rx_mbuf_chain[prev_index].m_map : rx_buf->m_map;
6373     rx_buf->m_map = fp->rx_mbuf_spare_map;
6374     fp->rx_mbuf_spare_map = map;
6375     bus_dmamap_sync(fp->rx_mbuf_tag, rx_buf->m_map,
6376                     BUS_DMASYNC_PREREAD);
6377     rx_buf->m = m;
6378
6379     rx_bd = &fp->rx_chain[index];
6380     rx_bd->addr_hi = htole32(U64_HI(segs[0].ds_addr));
6381     rx_bd->addr_lo = htole32(U64_LO(segs[0].ds_addr));
6382
6383     return (rc);
6384 }
6385
6386 static int
6387 bxe_alloc_rx_tpa_mbuf(struct bxe_fastpath *fp,
6388                       int                 queue)
6389 {
6390     struct bxe_sw_tpa_info *tpa_info = &fp->rx_tpa_info[queue];
6391     bus_dma_segment_t segs[1];
6392     bus_dmamap_t map;
6393     struct mbuf *m;
6394     int nsegs;
6395     int rc = 0;
6396
6397     /* allocate the new TPA mbuf */
6398     m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, fp->mbuf_alloc_size);
6399     if (__predict_false(m == NULL)) {
6400         fp->eth_q_stats.mbuf_rx_tpa_alloc_failed++;
6401         return (ENOBUFS);
6402     }
6403
6404     fp->eth_q_stats.mbuf_alloc_tpa++;
6405
6406     /* initialize the mbuf buffer length */
6407     m->m_pkthdr.len = m->m_len = fp->rx_buf_size;
6408
6409     /* map the mbuf into non-paged pool */
6410     rc = bus_dmamap_load_mbuf_sg(fp->rx_mbuf_tag,
6411                                  fp->rx_tpa_info_mbuf_spare_map,
6412                                  m, segs, &nsegs, BUS_DMA_NOWAIT);
6413     if (__predict_false(rc != 0)) {
6414         fp->eth_q_stats.mbuf_rx_tpa_mapping_failed++;
6415         m_free(m);
6416         fp->eth_q_stats.mbuf_alloc_tpa--;
6417         return (rc);
6418     }
6419
6420     /* all mbufs must map to a single segment */
6421     KASSERT((nsegs == 1), ("Too many segments, %d returned!", nsegs));
6422
6423     /* release any existing TPA mbuf mapping */
6424     if (tpa_info->bd.m_map != NULL) {
6425         bus_dmamap_sync(fp->rx_mbuf_tag, tpa_info->bd.m_map,
6426                         BUS_DMASYNC_POSTREAD);
6427         bus_dmamap_unload(fp->rx_mbuf_tag, tpa_info->bd.m_map);
6428     }
6429
6430     /* save the mbuf and mapping info for the TPA mbuf */
6431     map = tpa_info->bd.m_map;
6432     tpa_info->bd.m_map = fp->rx_tpa_info_mbuf_spare_map;
6433     fp->rx_tpa_info_mbuf_spare_map = map;
6434     bus_dmamap_sync(fp->rx_mbuf_tag, tpa_info->bd.m_map,
6435                     BUS_DMASYNC_PREREAD);
6436     tpa_info->bd.m = m;
6437     tpa_info->seg = segs[0];
6438
6439     return (rc);
6440 }
6441
6442 /*
6443  * Allocate an mbuf and assign it to the receive scatter gather chain. The
6444  * caller must take care to save a copy of the existing mbuf in the SG mbuf
6445  * chain.
6446  */
6447 static int
6448 bxe_alloc_rx_sge_mbuf(struct bxe_fastpath *fp,
6449                       uint16_t            index)
6450 {
6451     struct bxe_sw_rx_bd *sge_buf;
6452     struct eth_rx_sge *sge;
6453     bus_dma_segment_t segs[1];
6454     bus_dmamap_t map;
6455     struct mbuf *m;
6456     int nsegs;
6457     int rc = 0;
6458
6459     /* allocate a new SGE mbuf */
6460     m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, SGE_PAGE_SIZE);
6461     if (__predict_false(m == NULL)) {
6462         fp->eth_q_stats.mbuf_rx_sge_alloc_failed++;
6463         return (ENOMEM);
6464     }
6465
6466     fp->eth_q_stats.mbuf_alloc_sge++;
6467
6468     /* initialize the mbuf buffer length */
6469     m->m_pkthdr.len = m->m_len = SGE_PAGE_SIZE;
6470
6471     /* map the SGE mbuf into non-paged pool */
6472     rc = bus_dmamap_load_mbuf_sg(fp->rx_sge_mbuf_tag,
6473                                  fp->rx_sge_mbuf_spare_map,
6474                                  m, segs, &nsegs, BUS_DMA_NOWAIT);
6475     if (__predict_false(rc != 0)) {
6476         fp->eth_q_stats.mbuf_rx_sge_mapping_failed++;
6477         m_freem(m);
6478         fp->eth_q_stats.mbuf_alloc_sge--;
6479         return (rc);
6480     }
6481
6482     /* all mbufs must map to a single segment */
6483     KASSERT((nsegs == 1), ("Too many segments, %d returned!", nsegs));
6484
6485     sge_buf = &fp->rx_sge_mbuf_chain[index];
6486
6487     /* release any existing SGE mbuf mapping */
6488     if (sge_buf->m_map != NULL) {
6489         bus_dmamap_sync(fp->rx_sge_mbuf_tag, sge_buf->m_map,
6490                         BUS_DMASYNC_POSTREAD);
6491         bus_dmamap_unload(fp->rx_sge_mbuf_tag, sge_buf->m_map);
6492     }
6493
6494     /* save the mbuf and mapping info for a future packet */
6495     map = sge_buf->m_map;
6496     sge_buf->m_map = fp->rx_sge_mbuf_spare_map;
6497     fp->rx_sge_mbuf_spare_map = map;
6498     bus_dmamap_sync(fp->rx_sge_mbuf_tag, sge_buf->m_map,
6499                     BUS_DMASYNC_PREREAD);
6500     sge_buf->m = m;
6501
6502     sge = &fp->rx_sge_chain[index];
6503     sge->addr_hi = htole32(U64_HI(segs[0].ds_addr));
6504     sge->addr_lo = htole32(U64_LO(segs[0].ds_addr));
6505
6506     return (rc);
6507 }
6508
6509 static __noinline int
6510 bxe_alloc_fp_buffers(struct bxe_softc *sc)
6511 {
6512     struct bxe_fastpath *fp;
6513     int i, j, rc = 0;
6514     int ring_prod, cqe_ring_prod;
6515     int max_agg_queues;
6516
6517     for (i = 0; i < sc->num_queues; i++) {
6518         fp = &sc->fp[i];
6519
6520         ring_prod = cqe_ring_prod = 0;
6521         fp->rx_bd_cons = 0;
6522         fp->rx_cq_cons = 0;
6523
6524         /* allocate buffers for the RX BDs in RX BD chain */
6525         for (j = 0; j < sc->max_rx_bufs; j++) {
6526             rc = bxe_alloc_rx_bd_mbuf(fp, ring_prod, ring_prod);
6527             if (rc != 0) {
6528                 BLOGE(sc, "mbuf alloc fail for fp[%02d] rx chain (%d)\n",
6529                       i, rc);
6530                 goto bxe_alloc_fp_buffers_error;
6531             }
6532
6533             ring_prod     = RX_BD_NEXT(ring_prod);
6534             cqe_ring_prod = RCQ_NEXT(cqe_ring_prod);
6535         }
6536
6537         fp->rx_bd_prod = ring_prod;
6538         fp->rx_cq_prod = cqe_ring_prod;
6539         fp->eth_q_stats.rx_calls = fp->eth_q_stats.rx_pkts = 0;
6540
6541         max_agg_queues = MAX_AGG_QS(sc);
6542
6543         fp->tpa_enable = TRUE;
6544
6545         /* fill the TPA pool */
6546         for (j = 0; j < max_agg_queues; j++) {
6547             rc = bxe_alloc_rx_tpa_mbuf(fp, j);
6548             if (rc != 0) {
6549                 BLOGE(sc, "mbuf alloc fail for fp[%02d] TPA queue %d\n",
6550                           i, j);
6551                 fp->tpa_enable = FALSE;
6552                 goto bxe_alloc_fp_buffers_error;
6553             }
6554
6555             fp->rx_tpa_info[j].state = BXE_TPA_STATE_STOP;
6556         }
6557
6558         if (fp->tpa_enable) {
6559             /* fill the RX SGE chain */
6560             ring_prod = 0;
6561             for (j = 0; j < RX_SGE_USABLE; j++) {
6562                 rc = bxe_alloc_rx_sge_mbuf(fp, ring_prod);
6563                 if (rc != 0) {
6564                     BLOGE(sc, "mbuf alloc fail for fp[%02d] SGE %d\n",
6565                               i, ring_prod);
6566                     fp->tpa_enable = FALSE;
6567                     ring_prod = 0;
6568                     goto bxe_alloc_fp_buffers_error;
6569                 }
6570
6571                 ring_prod = RX_SGE_NEXT(ring_prod);
6572             }
6573
6574             fp->rx_sge_prod = ring_prod;
6575         }
6576     }
6577
6578     return (0);
6579
6580 bxe_alloc_fp_buffers_error:
6581
6582     /* unwind what was already allocated */
6583     bxe_free_rx_bd_chain(fp);
6584     bxe_free_tpa_pool(fp);
6585     bxe_free_sge_chain(fp);
6586
6587     return (ENOBUFS);
6588 }
6589
6590 static void
6591 bxe_free_fw_stats_mem(struct bxe_softc *sc)
6592 {
6593     bxe_dma_free(sc, &sc->fw_stats_dma);
6594
6595     sc->fw_stats_num = 0;
6596
6597     sc->fw_stats_req_size = 0;
6598     sc->fw_stats_req = NULL;
6599     sc->fw_stats_req_mapping = 0;
6600
6601     sc->fw_stats_data_size = 0;
6602     sc->fw_stats_data = NULL;
6603     sc->fw_stats_data_mapping = 0;
6604 }
6605
6606 static int
6607 bxe_alloc_fw_stats_mem(struct bxe_softc *sc)
6608 {
6609     uint8_t num_queue_stats;
6610     int num_groups;
6611
6612     /* number of queues for statistics is number of eth queues */
6613     num_queue_stats = BXE_NUM_ETH_QUEUES(sc);
6614
6615     /*
6616      * Total number of FW statistics requests =
6617      *   1 for port stats + 1 for PF stats + num of queues
6618      */
6619     sc->fw_stats_num = (2 + num_queue_stats);
6620
6621     /*
6622      * Request is built from stats_query_header and an array of
6623      * stats_query_cmd_group each of which contains STATS_QUERY_CMD_COUNT
6624      * rules. The real number or requests is configured in the
6625      * stats_query_header.
6626      */
6627     num_groups =
6628         ((sc->fw_stats_num / STATS_QUERY_CMD_COUNT) +
6629          ((sc->fw_stats_num % STATS_QUERY_CMD_COUNT) ? 1 : 0));
6630
6631     BLOGD(sc, DBG_LOAD, "stats fw_stats_num %d num_groups %d\n",
6632           sc->fw_stats_num, num_groups);
6633
6634     sc->fw_stats_req_size =
6635         (sizeof(struct stats_query_header) +
6636          (num_groups * sizeof(struct stats_query_cmd_group)));
6637
6638     /*
6639      * Data for statistics requests + stats_counter.
6640      * stats_counter holds per-STORM counters that are incremented when
6641      * STORM has finished with the current request. Memory for FCoE
6642      * offloaded statistics are counted anyway, even if they will not be sent.
6643      * VF stats are not accounted for here as the data of VF stats is stored
6644      * in memory allocated by the VF, not here.
6645      */
6646     sc->fw_stats_data_size =
6647         (sizeof(struct stats_counter) +
6648          sizeof(struct per_port_stats) +
6649          sizeof(struct per_pf_stats) +
6650          /* sizeof(struct fcoe_statistics_params) + */
6651          (sizeof(struct per_queue_stats) * num_queue_stats));
6652
6653     if (bxe_dma_alloc(sc, (sc->fw_stats_req_size + sc->fw_stats_data_size),
6654                       &sc->fw_stats_dma, "fw stats") != 0) {
6655         bxe_free_fw_stats_mem(sc);
6656         return (-1);
6657     }
6658
6659     /* set up the shortcuts */
6660
6661     sc->fw_stats_req =
6662         (struct bxe_fw_stats_req *)sc->fw_stats_dma.vaddr;
6663     sc->fw_stats_req_mapping = sc->fw_stats_dma.paddr;
6664
6665     sc->fw_stats_data =
6666         (struct bxe_fw_stats_data *)((uint8_t *)sc->fw_stats_dma.vaddr +
6667                                      sc->fw_stats_req_size);
6668     sc->fw_stats_data_mapping = (sc->fw_stats_dma.paddr +
6669                                  sc->fw_stats_req_size);
6670
6671     BLOGD(sc, DBG_LOAD, "statistics request base address set to %#jx\n",
6672           (uintmax_t)sc->fw_stats_req_mapping);
6673
6674     BLOGD(sc, DBG_LOAD, "statistics data base address set to %#jx\n",
6675           (uintmax_t)sc->fw_stats_data_mapping);
6676
6677     return (0);
6678 }
6679
6680 /*
6681  * Bits map:
6682  * 0-7  - Engine0 load counter.
6683  * 8-15 - Engine1 load counter.
6684  * 16   - Engine0 RESET_IN_PROGRESS bit.
6685  * 17   - Engine1 RESET_IN_PROGRESS bit.
6686  * 18   - Engine0 ONE_IS_LOADED. Set when there is at least one active
6687  *        function on the engine
6688  * 19   - Engine1 ONE_IS_LOADED.
6689  * 20   - Chip reset flow bit. When set none-leader must wait for both engines
6690  *        leader to complete (check for both RESET_IN_PROGRESS bits and not
6691  *        for just the one belonging to its engine).
6692  */
6693 #define BXE_RECOVERY_GLOB_REG     MISC_REG_GENERIC_POR_1
6694 #define BXE_PATH0_LOAD_CNT_MASK   0x000000ff
6695 #define BXE_PATH0_LOAD_CNT_SHIFT  0
6696 #define BXE_PATH1_LOAD_CNT_MASK   0x0000ff00
6697 #define BXE_PATH1_LOAD_CNT_SHIFT  8
6698 #define BXE_PATH0_RST_IN_PROG_BIT 0x00010000
6699 #define BXE_PATH1_RST_IN_PROG_BIT 0x00020000
6700 #define BXE_GLOBAL_RESET_BIT      0x00040000
6701
6702 /* set the GLOBAL_RESET bit, should be run under rtnl lock */
6703 static void
6704 bxe_set_reset_global(struct bxe_softc *sc)
6705 {
6706     uint32_t val;
6707     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6708     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6709     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val | BXE_GLOBAL_RESET_BIT);
6710     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6711 }
6712
6713 /* clear the GLOBAL_RESET bit, should be run under rtnl lock */
6714 static void
6715 bxe_clear_reset_global(struct bxe_softc *sc)
6716 {
6717     uint32_t val;
6718     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6719     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6720     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val & (~BXE_GLOBAL_RESET_BIT));
6721     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6722 }
6723
6724 /* checks the GLOBAL_RESET bit, should be run under rtnl lock */
6725 static uint8_t
6726 bxe_reset_is_global(struct bxe_softc *sc)
6727 {
6728     uint32_t val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6729     BLOGD(sc, DBG_LOAD, "GLOB_REG=0x%08x\n", val);
6730     return (val & BXE_GLOBAL_RESET_BIT) ? TRUE : FALSE;
6731 }
6732
6733 /* clear RESET_IN_PROGRESS bit for the engine, should be run under rtnl lock */
6734 static void
6735 bxe_set_reset_done(struct bxe_softc *sc)
6736 {
6737     uint32_t val;
6738     uint32_t bit = SC_PATH(sc) ? BXE_PATH1_RST_IN_PROG_BIT :
6739                                  BXE_PATH0_RST_IN_PROG_BIT;
6740
6741     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6742
6743     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6744     /* Clear the bit */
6745     val &= ~bit;
6746     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val);
6747
6748     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6749 }
6750
6751 /* set RESET_IN_PROGRESS for the engine, should be run under rtnl lock */
6752 static void
6753 bxe_set_reset_in_progress(struct bxe_softc *sc)
6754 {
6755     uint32_t val;
6756     uint32_t bit = SC_PATH(sc) ? BXE_PATH1_RST_IN_PROG_BIT :
6757                                  BXE_PATH0_RST_IN_PROG_BIT;
6758
6759     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6760
6761     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6762     /* Set the bit */
6763     val |= bit;
6764     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val);
6765
6766     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6767 }
6768
6769 /* check RESET_IN_PROGRESS bit for an engine, should be run under rtnl lock */
6770 static uint8_t
6771 bxe_reset_is_done(struct bxe_softc *sc,
6772                   int              engine)
6773 {
6774     uint32_t val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6775     uint32_t bit = engine ? BXE_PATH1_RST_IN_PROG_BIT :
6776                             BXE_PATH0_RST_IN_PROG_BIT;
6777
6778     /* return false if bit is set */
6779     return (val & bit) ? FALSE : TRUE;
6780 }
6781
6782 /* get the load status for an engine, should be run under rtnl lock */
6783 static uint8_t
6784 bxe_get_load_status(struct bxe_softc *sc,
6785                     int              engine)
6786 {
6787     uint32_t mask = engine ? BXE_PATH1_LOAD_CNT_MASK :
6788                              BXE_PATH0_LOAD_CNT_MASK;
6789     uint32_t shift = engine ? BXE_PATH1_LOAD_CNT_SHIFT :
6790                               BXE_PATH0_LOAD_CNT_SHIFT;
6791     uint32_t val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6792
6793     BLOGD(sc, DBG_LOAD, "Old value for GLOB_REG=0x%08x\n", val);
6794
6795     val = ((val & mask) >> shift);
6796
6797     BLOGD(sc, DBG_LOAD, "Load mask engine %d = 0x%08x\n", engine, val);
6798
6799     return (val != 0);
6800 }
6801
6802 /* set pf load mark */
6803 /* XXX needs to be under rtnl lock */
6804 static void
6805 bxe_set_pf_load(struct bxe_softc *sc)
6806 {
6807     uint32_t val;
6808     uint32_t val1;
6809     uint32_t mask = SC_PATH(sc) ? BXE_PATH1_LOAD_CNT_MASK :
6810                                   BXE_PATH0_LOAD_CNT_MASK;
6811     uint32_t shift = SC_PATH(sc) ? BXE_PATH1_LOAD_CNT_SHIFT :
6812                                    BXE_PATH0_LOAD_CNT_SHIFT;
6813
6814     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6815
6816     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6817     BLOGD(sc, DBG_LOAD, "Old value for GLOB_REG=0x%08x\n", val);
6818
6819     /* get the current counter value */
6820     val1 = ((val & mask) >> shift);
6821
6822     /* set bit of this PF */
6823     val1 |= (1 << SC_ABS_FUNC(sc));
6824
6825     /* clear the old value */
6826     val &= ~mask;
6827
6828     /* set the new one */
6829     val |= ((val1 << shift) & mask);
6830
6831     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val);
6832
6833     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6834 }
6835
6836 /* clear pf load mark */
6837 /* XXX needs to be under rtnl lock */
6838 static uint8_t
6839 bxe_clear_pf_load(struct bxe_softc *sc)
6840 {
6841     uint32_t val1, val;
6842     uint32_t mask = SC_PATH(sc) ? BXE_PATH1_LOAD_CNT_MASK :
6843                                   BXE_PATH0_LOAD_CNT_MASK;
6844     uint32_t shift = SC_PATH(sc) ? BXE_PATH1_LOAD_CNT_SHIFT :
6845                                    BXE_PATH0_LOAD_CNT_SHIFT;
6846
6847     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6848     val = REG_RD(sc, BXE_RECOVERY_GLOB_REG);
6849     BLOGD(sc, DBG_LOAD, "Old GEN_REG_VAL=0x%08x\n", val);
6850
6851     /* get the current counter value */
6852     val1 = (val & mask) >> shift;
6853
6854     /* clear bit of that PF */
6855     val1 &= ~(1 << SC_ABS_FUNC(sc));
6856
6857     /* clear the old value */
6858     val &= ~mask;
6859
6860     /* set the new one */
6861     val |= ((val1 << shift) & mask);
6862
6863     REG_WR(sc, BXE_RECOVERY_GLOB_REG, val);
6864     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
6865     return (val1 != 0);
6866 }
6867
6868 /* send load requrest to mcp and analyze response */
6869 static int
6870 bxe_nic_load_request(struct bxe_softc *sc,
6871                      uint32_t         *load_code)
6872 {
6873     /* init fw_seq */
6874     sc->fw_seq =
6875         (SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_mb_header) &
6876          DRV_MSG_SEQ_NUMBER_MASK);
6877
6878     BLOGD(sc, DBG_LOAD, "initial fw_seq 0x%04x\n", sc->fw_seq);
6879
6880     /* get the current FW pulse sequence */
6881     sc->fw_drv_pulse_wr_seq =
6882         (SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_pulse_mb) &
6883          DRV_PULSE_SEQ_MASK);
6884
6885     BLOGD(sc, DBG_LOAD, "initial drv_pulse 0x%04x\n",
6886           sc->fw_drv_pulse_wr_seq);
6887
6888     /* load request */
6889     (*load_code) = bxe_fw_command(sc, DRV_MSG_CODE_LOAD_REQ,
6890                                   DRV_MSG_CODE_LOAD_REQ_WITH_LFA);
6891
6892     /* if the MCP fails to respond we must abort */
6893     if (!(*load_code)) {
6894         BLOGE(sc, "MCP response failure!\n");
6895         return (-1);
6896     }
6897
6898     /* if MCP refused then must abort */
6899     if ((*load_code) == FW_MSG_CODE_DRV_LOAD_REFUSED) {
6900         BLOGE(sc, "MCP refused load request\n");
6901         return (-1);
6902     }
6903
6904     return (0);
6905 }
6906
6907 /*
6908  * Check whether another PF has already loaded FW to chip. In virtualized
6909  * environments a pf from anoth VM may have already initialized the device
6910  * including loading FW.
6911  */
6912 static int
6913 bxe_nic_load_analyze_req(struct bxe_softc *sc,
6914                          uint32_t         load_code)
6915 {
6916     uint32_t my_fw, loaded_fw;
6917
6918     /* is another pf loaded on this engine? */
6919     if ((load_code != FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) &&
6920         (load_code != FW_MSG_CODE_DRV_LOAD_COMMON)) {
6921         /* build my FW version dword */
6922         my_fw = (BCM_5710_FW_MAJOR_VERSION +
6923                  (BCM_5710_FW_MINOR_VERSION << 8 ) +
6924                  (BCM_5710_FW_REVISION_VERSION << 16) +
6925                  (BCM_5710_FW_ENGINEERING_VERSION << 24));
6926
6927         /* read loaded FW from chip */
6928         loaded_fw = REG_RD(sc, XSEM_REG_PRAM);
6929         BLOGD(sc, DBG_LOAD, "loaded FW 0x%08x / my FW 0x%08x\n",
6930               loaded_fw, my_fw);
6931
6932         /* abort nic load if version mismatch */
6933         if (my_fw != loaded_fw) {
6934             BLOGE(sc, "FW 0x%08x already loaded (mine is 0x%08x)",
6935                   loaded_fw, my_fw);
6936             return (-1);
6937         }
6938     }
6939
6940     return (0);
6941 }
6942
6943 /* mark PMF if applicable */
6944 static void
6945 bxe_nic_load_pmf(struct bxe_softc *sc,
6946                  uint32_t         load_code)
6947 {
6948     uint32_t ncsi_oem_data_addr;
6949
6950     if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
6951         (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
6952         (load_code == FW_MSG_CODE_DRV_LOAD_PORT)) {
6953         /*
6954          * Barrier here for ordering between the writing to sc->port.pmf here
6955          * and reading it from the periodic task.
6956          */
6957         sc->port.pmf = 1;
6958         mb();
6959     } else {
6960         sc->port.pmf = 0;
6961     }
6962
6963     BLOGD(sc, DBG_LOAD, "pmf %d\n", sc->port.pmf);
6964
6965     /* XXX needed? */
6966     if (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) {
6967         if (SHMEM2_HAS(sc, ncsi_oem_data_addr)) {
6968             ncsi_oem_data_addr = SHMEM2_RD(sc, ncsi_oem_data_addr);
6969             if (ncsi_oem_data_addr) {
6970                 REG_WR(sc,
6971                        (ncsi_oem_data_addr +
6972                         offsetof(struct glob_ncsi_oem_data, driver_version)),
6973                        0);
6974             }
6975         }
6976     }
6977 }
6978
6979 static void
6980 bxe_read_mf_cfg(struct bxe_softc *sc)
6981 {
6982     int n = (CHIP_IS_MODE_4_PORT(sc) ? 2 : 1);
6983     int abs_func;
6984     int vn;
6985
6986     if (BXE_NOMCP(sc)) {
6987         return; /* what should be the default bvalue in this case */
6988     }
6989
6990     /*
6991      * The formula for computing the absolute function number is...
6992      * For 2 port configuration (4 functions per port):
6993      *   abs_func = 2 * vn + SC_PORT + SC_PATH
6994      * For 4 port configuration (2 functions per port):
6995      *   abs_func = 4 * vn + 2 * SC_PORT + SC_PATH
6996      */
6997     for (vn = VN_0; vn < SC_MAX_VN_NUM(sc); vn++) {
6998         abs_func = (n * (2 * vn + SC_PORT(sc)) + SC_PATH(sc));
6999         if (abs_func >= E1H_FUNC_MAX) {
7000             break;
7001         }
7002         sc->devinfo.mf_info.mf_config[vn] =
7003             MFCFG_RD(sc, func_mf_config[abs_func].config);
7004     }
7005
7006     if (sc->devinfo.mf_info.mf_config[SC_VN(sc)] &
7007         FUNC_MF_CFG_FUNC_DISABLED) {
7008         BLOGD(sc, DBG_LOAD, "mf_cfg function disabled\n");
7009         sc->flags |= BXE_MF_FUNC_DIS;
7010     } else {
7011         BLOGD(sc, DBG_LOAD, "mf_cfg function enabled\n");
7012         sc->flags &= ~BXE_MF_FUNC_DIS;
7013     }
7014 }
7015
7016 /* acquire split MCP access lock register */
7017 static int bxe_acquire_alr(struct bxe_softc *sc)
7018 {
7019     uint32_t j, val;
7020
7021     for (j = 0; j < 1000; j++) {
7022         val = (1UL << 31);
7023         REG_WR(sc, GRCBASE_MCP + 0x9c, val);
7024         val = REG_RD(sc, GRCBASE_MCP + 0x9c);
7025         if (val & (1L << 31))
7026             break;
7027
7028         DELAY(5000);
7029     }
7030
7031     if (!(val & (1L << 31))) {
7032         BLOGE(sc, "Cannot acquire MCP access lock register\n");
7033         return (-1);
7034     }
7035
7036     return (0);
7037 }
7038
7039 /* release split MCP access lock register */
7040 static void bxe_release_alr(struct bxe_softc *sc)
7041 {
7042     REG_WR(sc, GRCBASE_MCP + 0x9c, 0);
7043 }
7044
7045 static void
7046 bxe_fan_failure(struct bxe_softc *sc)
7047 {
7048     int port = SC_PORT(sc);
7049     uint32_t ext_phy_config;
7050
7051     /* mark the failure */
7052     ext_phy_config =
7053         SHMEM_RD(sc, dev_info.port_hw_config[port].external_phy_config);
7054
7055     ext_phy_config &= ~PORT_HW_CFG_XGXS_EXT_PHY_TYPE_MASK;
7056     ext_phy_config |= PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE;
7057     SHMEM_WR(sc, dev_info.port_hw_config[port].external_phy_config,
7058              ext_phy_config);
7059
7060     /* log the failure */
7061     BLOGW(sc, "Fan Failure has caused the driver to shutdown "
7062               "the card to prevent permanent damage. "
7063               "Please contact OEM Support for assistance\n");
7064
7065     /* XXX */
7066 #if 1
7067     bxe_panic(sc, ("Schedule task to handle fan failure\n"));
7068 #else
7069     /*
7070      * Schedule device reset (unload)
7071      * This is due to some boards consuming sufficient power when driver is
7072      * up to overheat if fan fails.
7073      */
7074     bxe_set_bit(BXE_SP_RTNL_FAN_FAILURE, &sc->sp_rtnl_state);
7075     schedule_delayed_work(&sc->sp_rtnl_task, 0);
7076 #endif
7077 }
7078
7079 /* this function is called upon a link interrupt */
7080 static void
7081 bxe_link_attn(struct bxe_softc *sc)
7082 {
7083     uint32_t pause_enabled = 0;
7084     struct host_port_stats *pstats;
7085     int cmng_fns;
7086
7087     /* Make sure that we are synced with the current statistics */
7088     bxe_stats_handle(sc, STATS_EVENT_STOP);
7089
7090     elink_link_update(&sc->link_params, &sc->link_vars);
7091
7092     if (sc->link_vars.link_up) {
7093
7094         /* dropless flow control */
7095         if (!CHIP_IS_E1(sc) && sc->dropless_fc) {
7096             pause_enabled = 0;
7097
7098             if (sc->link_vars.flow_ctrl & ELINK_FLOW_CTRL_TX) {
7099                 pause_enabled = 1;
7100             }
7101
7102             REG_WR(sc,
7103                    (BAR_USTRORM_INTMEM +
7104                     USTORM_ETH_PAUSE_ENABLED_OFFSET(SC_PORT(sc))),
7105                    pause_enabled);
7106         }
7107
7108         if (sc->link_vars.mac_type != ELINK_MAC_TYPE_EMAC) {
7109             pstats = BXE_SP(sc, port_stats);
7110             /* reset old mac stats */
7111             memset(&(pstats->mac_stx[0]), 0, sizeof(struct mac_stx));
7112         }
7113
7114         if (sc->state == BXE_STATE_OPEN) {
7115             bxe_stats_handle(sc, STATS_EVENT_LINK_UP);
7116         }
7117     }
7118
7119     if (sc->link_vars.link_up && sc->link_vars.line_speed) {
7120         cmng_fns = bxe_get_cmng_fns_mode(sc);
7121
7122         if (cmng_fns != CMNG_FNS_NONE) {
7123             bxe_cmng_fns_init(sc, FALSE, cmng_fns);
7124             storm_memset_cmng(sc, &sc->cmng, SC_PORT(sc));
7125         } else {
7126             /* rate shaping and fairness are disabled */
7127             BLOGD(sc, DBG_LOAD, "single function mode without fairness\n");
7128         }
7129     }
7130
7131     bxe_link_report_locked(sc);
7132
7133     if (IS_MF(sc)) {
7134         ; // XXX bxe_link_sync_notify(sc);
7135     }
7136 }
7137
7138 static void
7139 bxe_attn_int_asserted(struct bxe_softc *sc,
7140                       uint32_t         asserted)
7141 {
7142     int port = SC_PORT(sc);
7143     uint32_t aeu_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
7144                                MISC_REG_AEU_MASK_ATTN_FUNC_0;
7145     uint32_t nig_int_mask_addr = port ? NIG_REG_MASK_INTERRUPT_PORT1 :
7146                                         NIG_REG_MASK_INTERRUPT_PORT0;
7147     uint32_t aeu_mask;
7148     uint32_t nig_mask = 0;
7149     uint32_t reg_addr;
7150     uint32_t igu_acked;
7151     uint32_t cnt;
7152
7153     if (sc->attn_state & asserted) {
7154         BLOGE(sc, "IGU ERROR attn=0x%08x\n", asserted);
7155     }
7156
7157     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
7158
7159     aeu_mask = REG_RD(sc, aeu_addr);
7160
7161     BLOGD(sc, DBG_INTR, "aeu_mask 0x%08x newly asserted 0x%08x\n",
7162           aeu_mask, asserted);
7163
7164     aeu_mask &= ~(asserted & 0x3ff);
7165
7166     BLOGD(sc, DBG_INTR, "new mask 0x%08x\n", aeu_mask);
7167
7168     REG_WR(sc, aeu_addr, aeu_mask);
7169
7170     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
7171
7172     BLOGD(sc, DBG_INTR, "attn_state 0x%08x\n", sc->attn_state);
7173     sc->attn_state |= asserted;
7174     BLOGD(sc, DBG_INTR, "new state 0x%08x\n", sc->attn_state);
7175
7176     if (asserted & ATTN_HARD_WIRED_MASK) {
7177         if (asserted & ATTN_NIG_FOR_FUNC) {
7178
7179             bxe_acquire_phy_lock(sc);
7180             /* save nig interrupt mask */
7181             nig_mask = REG_RD(sc, nig_int_mask_addr);
7182
7183             /* If nig_mask is not set, no need to call the update function */
7184             if (nig_mask) {
7185                 REG_WR(sc, nig_int_mask_addr, 0);
7186
7187                 bxe_link_attn(sc);
7188             }
7189
7190             /* handle unicore attn? */
7191         }
7192
7193         if (asserted & ATTN_SW_TIMER_4_FUNC) {
7194             BLOGD(sc, DBG_INTR, "ATTN_SW_TIMER_4_FUNC!\n");
7195         }
7196
7197         if (asserted & GPIO_2_FUNC) {
7198             BLOGD(sc, DBG_INTR, "GPIO_2_FUNC!\n");
7199         }
7200
7201         if (asserted & GPIO_3_FUNC) {
7202             BLOGD(sc, DBG_INTR, "GPIO_3_FUNC!\n");
7203         }
7204
7205         if (asserted & GPIO_4_FUNC) {
7206             BLOGD(sc, DBG_INTR, "GPIO_4_FUNC!\n");
7207         }
7208
7209         if (port == 0) {
7210             if (asserted & ATTN_GENERAL_ATTN_1) {
7211                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_1!\n");
7212                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
7213             }
7214             if (asserted & ATTN_GENERAL_ATTN_2) {
7215                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_2!\n");
7216                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
7217             }
7218             if (asserted & ATTN_GENERAL_ATTN_3) {
7219                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_3!\n");
7220                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
7221             }
7222         } else {
7223             if (asserted & ATTN_GENERAL_ATTN_4) {
7224                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_4!\n");
7225                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
7226             }
7227             if (asserted & ATTN_GENERAL_ATTN_5) {
7228                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_5!\n");
7229                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
7230             }
7231             if (asserted & ATTN_GENERAL_ATTN_6) {
7232                 BLOGD(sc, DBG_INTR, "ATTN_GENERAL_ATTN_6!\n");
7233                 REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
7234             }
7235         }
7236     } /* hardwired */
7237
7238     if (sc->devinfo.int_block == INT_BLOCK_HC) {
7239         reg_addr = (HC_REG_COMMAND_REG + port*32 + COMMAND_REG_ATTN_BITS_SET);
7240     } else {
7241         reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER*8);
7242     }
7243
7244     BLOGD(sc, DBG_INTR, "about to mask 0x%08x at %s addr 0x%08x\n",
7245           asserted,
7246           (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
7247     REG_WR(sc, reg_addr, asserted);
7248
7249     /* now set back the mask */
7250     if (asserted & ATTN_NIG_FOR_FUNC) {
7251         /*
7252          * Verify that IGU ack through BAR was written before restoring
7253          * NIG mask. This loop should exit after 2-3 iterations max.
7254          */
7255         if (sc->devinfo.int_block != INT_BLOCK_HC) {
7256             cnt = 0;
7257
7258             do {
7259                 igu_acked = REG_RD(sc, IGU_REG_ATTENTION_ACK_BITS);
7260             } while (((igu_acked & ATTN_NIG_FOR_FUNC) == 0) &&
7261                      (++cnt < MAX_IGU_ATTN_ACK_TO));
7262
7263             if (!igu_acked) {
7264                 BLOGE(sc, "Failed to verify IGU ack on time\n");
7265             }
7266
7267             mb();
7268         }
7269
7270         REG_WR(sc, nig_int_mask_addr, nig_mask);
7271
7272         bxe_release_phy_lock(sc);
7273     }
7274 }
7275
7276 static void
7277 bxe_print_next_block(struct bxe_softc *sc,
7278                      int              idx,
7279                      const char       *blk)
7280 {
7281     BLOGI(sc, "%s%s", idx ? ", " : "", blk);
7282 }
7283
7284 static int
7285 bxe_check_blocks_with_parity0(struct bxe_softc *sc,
7286                               uint32_t         sig,
7287                               int              par_num,
7288                               uint8_t          print)
7289 {
7290     uint32_t cur_bit = 0;
7291     int i = 0;
7292
7293     for (i = 0; sig; i++) {
7294         cur_bit = ((uint32_t)0x1 << i);
7295         if (sig & cur_bit) {
7296             switch (cur_bit) {
7297             case AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR:
7298                 if (print)
7299                     bxe_print_next_block(sc, par_num++, "BRB");
7300                 break;
7301             case AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR:
7302                 if (print)
7303                     bxe_print_next_block(sc, par_num++, "PARSER");
7304                 break;
7305             case AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR:
7306                 if (print)
7307                     bxe_print_next_block(sc, par_num++, "TSDM");
7308                 break;
7309             case AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR:
7310                 if (print)
7311                     bxe_print_next_block(sc, par_num++, "SEARCHER");
7312                 break;
7313             case AEU_INPUTS_ATTN_BITS_TCM_PARITY_ERROR:
7314                 if (print)
7315                     bxe_print_next_block(sc, par_num++, "TCM");
7316                 break;
7317             case AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR:
7318                 if (print)
7319                     bxe_print_next_block(sc, par_num++, "TSEMI");
7320                 break;
7321             case AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR:
7322                 if (print)
7323                     bxe_print_next_block(sc, par_num++, "XPB");
7324                 break;
7325             }
7326
7327             /* Clear the bit */
7328             sig &= ~cur_bit;
7329         }
7330     }
7331
7332     return (par_num);
7333 }
7334
7335 static int
7336 bxe_check_blocks_with_parity1(struct bxe_softc *sc,
7337                               uint32_t         sig,
7338                               int              par_num,
7339                               uint8_t          *global,
7340                               uint8_t          print)
7341 {
7342     int i = 0;
7343     uint32_t cur_bit = 0;
7344     for (i = 0; sig; i++) {
7345         cur_bit = ((uint32_t)0x1 << i);
7346         if (sig & cur_bit) {
7347             switch (cur_bit) {
7348             case AEU_INPUTS_ATTN_BITS_PBF_PARITY_ERROR:
7349                 if (print)
7350                     bxe_print_next_block(sc, par_num++, "PBF");
7351                 break;
7352             case AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR:
7353                 if (print)
7354                     bxe_print_next_block(sc, par_num++, "QM");
7355                 break;
7356             case AEU_INPUTS_ATTN_BITS_TIMERS_PARITY_ERROR:
7357                 if (print)
7358                     bxe_print_next_block(sc, par_num++, "TM");
7359                 break;
7360             case AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR:
7361                 if (print)
7362                     bxe_print_next_block(sc, par_num++, "XSDM");
7363                 break;
7364             case AEU_INPUTS_ATTN_BITS_XCM_PARITY_ERROR:
7365                 if (print)
7366                     bxe_print_next_block(sc, par_num++, "XCM");
7367                 break;
7368             case AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR:
7369                 if (print)
7370                     bxe_print_next_block(sc, par_num++, "XSEMI");
7371                 break;
7372             case AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR:
7373                 if (print)
7374                     bxe_print_next_block(sc, par_num++, "DOORBELLQ");
7375                 break;
7376             case AEU_INPUTS_ATTN_BITS_NIG_PARITY_ERROR:
7377                 if (print)
7378                     bxe_print_next_block(sc, par_num++, "NIG");
7379                 break;
7380             case AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR:
7381                 if (print)
7382                     bxe_print_next_block(sc, par_num++, "VAUX PCI CORE");
7383                 *global = TRUE;
7384                 break;
7385             case AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR:
7386                 if (print)
7387                     bxe_print_next_block(sc, par_num++, "DEBUG");
7388                 break;
7389             case AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR:
7390                 if (print)
7391                     bxe_print_next_block(sc, par_num++, "USDM");
7392                 break;
7393             case AEU_INPUTS_ATTN_BITS_UCM_PARITY_ERROR:
7394                 if (print)
7395                     bxe_print_next_block(sc, par_num++, "UCM");
7396                 break;
7397             case AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR:
7398                 if (print)
7399                     bxe_print_next_block(sc, par_num++, "USEMI");
7400                 break;
7401             case AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR:
7402                 if (print)
7403                     bxe_print_next_block(sc, par_num++, "UPB");
7404                 break;
7405             case AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR:
7406                 if (print)
7407                     bxe_print_next_block(sc, par_num++, "CSDM");
7408                 break;
7409             case AEU_INPUTS_ATTN_BITS_CCM_PARITY_ERROR:
7410                 if (print)
7411                     bxe_print_next_block(sc, par_num++, "CCM");
7412                 break;
7413             }
7414
7415             /* Clear the bit */
7416             sig &= ~cur_bit;
7417         }
7418     }
7419
7420     return (par_num);
7421 }
7422
7423 static int
7424 bxe_check_blocks_with_parity2(struct bxe_softc *sc,
7425                               uint32_t         sig,
7426                               int              par_num,
7427                               uint8_t          print)
7428 {
7429     uint32_t cur_bit = 0;
7430     int i = 0;
7431
7432     for (i = 0; sig; i++) {
7433         cur_bit = ((uint32_t)0x1 << i);
7434         if (sig & cur_bit) {
7435             switch (cur_bit) {
7436             case AEU_INPUTS_ATTN_BITS_CSEMI_PARITY_ERROR:
7437                 if (print)
7438                     bxe_print_next_block(sc, par_num++, "CSEMI");
7439                 break;
7440             case AEU_INPUTS_ATTN_BITS_PXP_PARITY_ERROR:
7441                 if (print)
7442                     bxe_print_next_block(sc, par_num++, "PXP");
7443                 break;
7444             case AEU_IN_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR:
7445                 if (print)
7446                     bxe_print_next_block(sc, par_num++, "PXPPCICLOCKCLIENT");
7447                 break;
7448             case AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR:
7449                 if (print)
7450                     bxe_print_next_block(sc, par_num++, "CFC");
7451                 break;
7452             case AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR:
7453                 if (print)
7454                     bxe_print_next_block(sc, par_num++, "CDU");
7455                 break;
7456             case AEU_INPUTS_ATTN_BITS_DMAE_PARITY_ERROR:
7457                 if (print)
7458                     bxe_print_next_block(sc, par_num++, "DMAE");
7459                 break;
7460             case AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR:
7461                 if (print)
7462                     bxe_print_next_block(sc, par_num++, "IGU");
7463                 break;
7464             case AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR:
7465                 if (print)
7466                     bxe_print_next_block(sc, par_num++, "MISC");
7467                 break;
7468             }
7469
7470             /* Clear the bit */
7471             sig &= ~cur_bit;
7472         }
7473     }
7474
7475     return (par_num);
7476 }
7477
7478 static int
7479 bxe_check_blocks_with_parity3(struct bxe_softc *sc,
7480                               uint32_t         sig,
7481                               int              par_num,
7482                               uint8_t          *global,
7483                               uint8_t          print)
7484 {
7485     uint32_t cur_bit = 0;
7486     int i = 0;
7487
7488     for (i = 0; sig; i++) {
7489         cur_bit = ((uint32_t)0x1 << i);
7490         if (sig & cur_bit) {
7491             switch (cur_bit) {
7492             case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_ROM_PARITY:
7493                 if (print)
7494                     bxe_print_next_block(sc, par_num++, "MCP ROM");
7495                 *global = TRUE;
7496                 break;
7497             case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_RX_PARITY:
7498                 if (print)
7499                     bxe_print_next_block(sc, par_num++,
7500                               "MCP UMP RX");
7501                 *global = TRUE;
7502                 break;
7503             case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_UMP_TX_PARITY:
7504                 if (print)
7505                     bxe_print_next_block(sc, par_num++,
7506                               "MCP UMP TX");
7507                 *global = TRUE;
7508                 break;
7509             case AEU_INPUTS_ATTN_BITS_MCP_LATCHED_SCPAD_PARITY:
7510                 if (print)
7511                     bxe_print_next_block(sc, par_num++,
7512                               "MCP SCPAD");
7513                 *global = TRUE;
7514                 break;
7515             }
7516
7517             /* Clear the bit */
7518             sig &= ~cur_bit;
7519         }
7520     }
7521
7522     return (par_num);
7523 }
7524
7525 static int
7526 bxe_check_blocks_with_parity4(struct bxe_softc *sc,
7527                               uint32_t         sig,
7528                               int              par_num,
7529                               uint8_t          print)
7530 {
7531     uint32_t cur_bit = 0;
7532     int i = 0;
7533
7534     for (i = 0; sig; i++) {
7535         cur_bit = ((uint32_t)0x1 << i);
7536         if (sig & cur_bit) {
7537             switch (cur_bit) {
7538             case AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR:
7539                 if (print)
7540                     bxe_print_next_block(sc, par_num++, "PGLUE_B");
7541                 break;
7542             case AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR:
7543                 if (print)
7544                     bxe_print_next_block(sc, par_num++, "ATC");
7545                 break;
7546             }
7547
7548             /* Clear the bit */
7549             sig &= ~cur_bit;
7550         }
7551     }
7552
7553     return (par_num);
7554 }
7555
7556 static uint8_t
7557 bxe_parity_attn(struct bxe_softc *sc,
7558                 uint8_t          *global,
7559                 uint8_t          print,
7560                 uint32_t         *sig)
7561 {
7562     int par_num = 0;
7563
7564     if ((sig[0] & HW_PRTY_ASSERT_SET_0) ||
7565         (sig[1] & HW_PRTY_ASSERT_SET_1) ||
7566         (sig[2] & HW_PRTY_ASSERT_SET_2) ||
7567         (sig[3] & HW_PRTY_ASSERT_SET_3) ||
7568         (sig[4] & HW_PRTY_ASSERT_SET_4)) {
7569         BLOGE(sc, "Parity error: HW block parity attention:\n"
7570                   "[0]:0x%08x [1]:0x%08x [2]:0x%08x [3]:0x%08x [4]:0x%08x\n",
7571               (uint32_t)(sig[0] & HW_PRTY_ASSERT_SET_0),
7572               (uint32_t)(sig[1] & HW_PRTY_ASSERT_SET_1),
7573               (uint32_t)(sig[2] & HW_PRTY_ASSERT_SET_2),
7574               (uint32_t)(sig[3] & HW_PRTY_ASSERT_SET_3),
7575               (uint32_t)(sig[4] & HW_PRTY_ASSERT_SET_4));
7576
7577         if (print)
7578             BLOGI(sc, "Parity errors detected in blocks: ");
7579
7580         par_num =
7581             bxe_check_blocks_with_parity0(sc, sig[0] &
7582                                           HW_PRTY_ASSERT_SET_0,
7583                                           par_num, print);
7584         par_num =
7585             bxe_check_blocks_with_parity1(sc, sig[1] &
7586                                           HW_PRTY_ASSERT_SET_1,
7587                                           par_num, global, print);
7588         par_num =
7589             bxe_check_blocks_with_parity2(sc, sig[2] &
7590                                           HW_PRTY_ASSERT_SET_2,
7591                                           par_num, print);
7592         par_num =
7593             bxe_check_blocks_with_parity3(sc, sig[3] &
7594                                           HW_PRTY_ASSERT_SET_3,
7595                                           par_num, global, print);
7596         par_num =
7597             bxe_check_blocks_with_parity4(sc, sig[4] &
7598                                           HW_PRTY_ASSERT_SET_4,
7599                                           par_num, print);
7600
7601         if (print)
7602             BLOGI(sc, "\n");
7603
7604         return (TRUE);
7605     }
7606
7607     return (FALSE);
7608 }
7609
7610 static uint8_t
7611 bxe_chk_parity_attn(struct bxe_softc *sc,
7612                     uint8_t          *global,
7613                     uint8_t          print)
7614 {
7615     struct attn_route attn = { {0} };
7616     int port = SC_PORT(sc);
7617
7618     attn.sig[0] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
7619     attn.sig[1] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
7620     attn.sig[2] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
7621     attn.sig[3] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
7622
7623     /*
7624      * Since MCP attentions can't be disabled inside the block, we need to
7625      * read AEU registers to see whether they're currently disabled
7626      */
7627     attn.sig[3] &= ((REG_RD(sc, (!port ? MISC_REG_AEU_ENABLE4_FUNC_0_OUT_0
7628                                       : MISC_REG_AEU_ENABLE4_FUNC_1_OUT_0)) &
7629                          MISC_AEU_ENABLE_MCP_PRTY_BITS) |
7630                         ~MISC_AEU_ENABLE_MCP_PRTY_BITS);
7631
7632
7633     if (!CHIP_IS_E1x(sc))
7634         attn.sig[4] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
7635
7636     return (bxe_parity_attn(sc, global, print, attn.sig));
7637 }
7638
7639 static void
7640 bxe_attn_int_deasserted4(struct bxe_softc *sc,
7641                          uint32_t         attn)
7642 {
7643     uint32_t val;
7644
7645     if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
7646         val = REG_RD(sc, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
7647         BLOGE(sc, "PGLUE hw attention 0x%08x\n", val);
7648         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
7649             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR\n");
7650         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
7651             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR\n");
7652         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
7653             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN\n");
7654         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
7655             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN\n");
7656         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
7657             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN\n");
7658         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
7659             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN\n");
7660         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
7661             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN\n");
7662         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
7663             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN\n");
7664         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
7665             BLOGE(sc, "PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW\n");
7666     }
7667
7668     if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
7669         val = REG_RD(sc, ATC_REG_ATC_INT_STS_CLR);
7670         BLOGE(sc, "ATC hw attention 0x%08x\n", val);
7671         if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
7672             BLOGE(sc, "ATC_ATC_INT_STS_REG_ADDRESS_ERROR\n");
7673         if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
7674             BLOGE(sc, "ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND\n");
7675         if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
7676             BLOGE(sc, "ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS\n");
7677         if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
7678             BLOGE(sc, "ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT\n");
7679         if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
7680             BLOGE(sc, "ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR\n");
7681         if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
7682             BLOGE(sc, "ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU\n");
7683     }
7684
7685     if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
7686                 AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
7687         BLOGE(sc, "FATAL parity attention set4 0x%08x\n",
7688               (uint32_t)(attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
7689                                  AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)));
7690     }
7691 }
7692
7693 static void
7694 bxe_e1h_disable(struct bxe_softc *sc)
7695 {
7696     int port = SC_PORT(sc);
7697
7698     bxe_tx_disable(sc);
7699
7700     REG_WR(sc, NIG_REG_LLH0_FUNC_EN + port*8, 0);
7701 }
7702
7703 static void
7704 bxe_e1h_enable(struct bxe_softc *sc)
7705 {
7706     int port = SC_PORT(sc);
7707
7708     REG_WR(sc, NIG_REG_LLH0_FUNC_EN + port*8, 1);
7709
7710     // XXX bxe_tx_enable(sc);
7711 }
7712
7713 /*
7714  * called due to MCP event (on pmf):
7715  *   reread new bandwidth configuration
7716  *   configure FW
7717  *   notify others function about the change
7718  */
7719 static void
7720 bxe_config_mf_bw(struct bxe_softc *sc)
7721 {
7722     if (sc->link_vars.link_up) {
7723         bxe_cmng_fns_init(sc, TRUE, CMNG_FNS_MINMAX);
7724         // XXX bxe_link_sync_notify(sc);
7725     }
7726
7727     storm_memset_cmng(sc, &sc->cmng, SC_PORT(sc));
7728 }
7729
7730 static void
7731 bxe_set_mf_bw(struct bxe_softc *sc)
7732 {
7733     bxe_config_mf_bw(sc);
7734     bxe_fw_command(sc, DRV_MSG_CODE_SET_MF_BW_ACK, 0);
7735 }
7736
7737 static void
7738 bxe_handle_eee_event(struct bxe_softc *sc)
7739 {
7740     BLOGD(sc, DBG_INTR, "EEE - LLDP event\n");
7741     bxe_fw_command(sc, DRV_MSG_CODE_EEE_RESULTS_ACK, 0);
7742 }
7743
7744 #define DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED 3
7745
7746 static void
7747 bxe_drv_info_ether_stat(struct bxe_softc *sc)
7748 {
7749     struct eth_stats_info *ether_stat =
7750         &sc->sp->drv_info_to_mcp.ether_stat;
7751
7752     strlcpy(ether_stat->version, BXE_DRIVER_VERSION,
7753             ETH_STAT_INFO_VERSION_LEN);
7754
7755     /* XXX (+ MAC_PAD) taken from other driver... verify this is right */
7756     sc->sp_objs[0].mac_obj.get_n_elements(sc, &sc->sp_objs[0].mac_obj,
7757                                           DRV_INFO_ETH_STAT_NUM_MACS_REQUIRED,
7758                                           ether_stat->mac_local + MAC_PAD,
7759                                           MAC_PAD, ETH_ALEN);
7760
7761     ether_stat->mtu_size = sc->mtu;
7762
7763     ether_stat->feature_flags |= FEATURE_ETH_CHKSUM_OFFLOAD_MASK;
7764     if (sc->ifnet->if_capenable & (IFCAP_TSO4 | IFCAP_TSO6)) {
7765         ether_stat->feature_flags |= FEATURE_ETH_LSO_MASK;
7766     }
7767
7768     // XXX ether_stat->feature_flags |= ???;
7769
7770     ether_stat->promiscuous_mode = 0; // (flags & PROMISC) ? 1 : 0;
7771
7772     ether_stat->txq_size = sc->tx_ring_size;
7773     ether_stat->rxq_size = sc->rx_ring_size;
7774 }
7775
7776 static void
7777 bxe_handle_drv_info_req(struct bxe_softc *sc)
7778 {
7779     enum drv_info_opcode op_code;
7780     uint32_t drv_info_ctl = SHMEM2_RD(sc, drv_info_control);
7781
7782     /* if drv_info version supported by MFW doesn't match - send NACK */
7783     if ((drv_info_ctl & DRV_INFO_CONTROL_VER_MASK) != DRV_INFO_CUR_VER) {
7784         bxe_fw_command(sc, DRV_MSG_CODE_DRV_INFO_NACK, 0);
7785         return;
7786     }
7787
7788     op_code = ((drv_info_ctl & DRV_INFO_CONTROL_OP_CODE_MASK) >>
7789                DRV_INFO_CONTROL_OP_CODE_SHIFT);
7790
7791     memset(&sc->sp->drv_info_to_mcp, 0, sizeof(union drv_info_to_mcp));
7792
7793     switch (op_code) {
7794     case ETH_STATS_OPCODE:
7795         bxe_drv_info_ether_stat(sc);
7796         break;
7797     case FCOE_STATS_OPCODE:
7798     case ISCSI_STATS_OPCODE:
7799     default:
7800         /* if op code isn't supported - send NACK */
7801         bxe_fw_command(sc, DRV_MSG_CODE_DRV_INFO_NACK, 0);
7802         return;
7803     }
7804
7805     /*
7806      * If we got drv_info attn from MFW then these fields are defined in
7807      * shmem2 for sure
7808      */
7809     SHMEM2_WR(sc, drv_info_host_addr_lo,
7810               U64_LO(BXE_SP_MAPPING(sc, drv_info_to_mcp)));
7811     SHMEM2_WR(sc, drv_info_host_addr_hi,
7812               U64_HI(BXE_SP_MAPPING(sc, drv_info_to_mcp)));
7813
7814     bxe_fw_command(sc, DRV_MSG_CODE_DRV_INFO_ACK, 0);
7815 }
7816
7817 static void
7818 bxe_dcc_event(struct bxe_softc *sc,
7819               uint32_t         dcc_event)
7820 {
7821     BLOGD(sc, DBG_INTR, "dcc_event 0x%08x\n", dcc_event);
7822
7823     if (dcc_event & DRV_STATUS_DCC_DISABLE_ENABLE_PF) {
7824         /*
7825          * This is the only place besides the function initialization
7826          * where the sc->flags can change so it is done without any
7827          * locks
7828          */
7829         if (sc->devinfo.mf_info.mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_DISABLED) {
7830             BLOGD(sc, DBG_INTR, "mf_cfg function disabled\n");
7831             sc->flags |= BXE_MF_FUNC_DIS;
7832             bxe_e1h_disable(sc);
7833         } else {
7834             BLOGD(sc, DBG_INTR, "mf_cfg function enabled\n");
7835             sc->flags &= ~BXE_MF_FUNC_DIS;
7836             bxe_e1h_enable(sc);
7837         }
7838         dcc_event &= ~DRV_STATUS_DCC_DISABLE_ENABLE_PF;
7839     }
7840
7841     if (dcc_event & DRV_STATUS_DCC_BANDWIDTH_ALLOCATION) {
7842         bxe_config_mf_bw(sc);
7843         dcc_event &= ~DRV_STATUS_DCC_BANDWIDTH_ALLOCATION;
7844     }
7845
7846     /* Report results to MCP */
7847     if (dcc_event)
7848         bxe_fw_command(sc, DRV_MSG_CODE_DCC_FAILURE, 0);
7849     else
7850         bxe_fw_command(sc, DRV_MSG_CODE_DCC_OK, 0);
7851 }
7852
7853 static void
7854 bxe_pmf_update(struct bxe_softc *sc)
7855 {
7856     int port = SC_PORT(sc);
7857     uint32_t val;
7858
7859     sc->port.pmf = 1;
7860     BLOGD(sc, DBG_INTR, "pmf %d\n", sc->port.pmf);
7861
7862     /*
7863      * We need the mb() to ensure the ordering between the writing to
7864      * sc->port.pmf here and reading it from the bxe_periodic_task().
7865      */
7866     mb();
7867
7868     /* queue a periodic task */
7869     // XXX schedule task...
7870
7871     // XXX bxe_dcbx_pmf_update(sc);
7872
7873     /* enable nig attention */
7874     val = (0xff0f | (1 << (SC_VN(sc) + 4)));
7875     if (sc->devinfo.int_block == INT_BLOCK_HC) {
7876         REG_WR(sc, HC_REG_TRAILING_EDGE_0 + port*8, val);
7877         REG_WR(sc, HC_REG_LEADING_EDGE_0 + port*8, val);
7878     } else if (!CHIP_IS_E1x(sc)) {
7879         REG_WR(sc, IGU_REG_TRAILING_EDGE_LATCH, val);
7880         REG_WR(sc, IGU_REG_LEADING_EDGE_LATCH, val);
7881     }
7882
7883     bxe_stats_handle(sc, STATS_EVENT_PMF);
7884 }
7885
7886 static int
7887 bxe_mc_assert(struct bxe_softc *sc)
7888 {
7889     char last_idx;
7890     int i, rc = 0;
7891     uint32_t row0, row1, row2, row3;
7892
7893     /* XSTORM */
7894     last_idx = REG_RD8(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_INDEX_OFFSET);
7895     if (last_idx)
7896         BLOGE(sc, "XSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
7897
7898     /* print the asserts */
7899     for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
7900
7901         row0 = REG_RD(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_OFFSET(i));
7902         row1 = REG_RD(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_OFFSET(i) + 4);
7903         row2 = REG_RD(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_OFFSET(i) + 8);
7904         row3 = REG_RD(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_OFFSET(i) + 12);
7905
7906         if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
7907             BLOGE(sc, "XSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
7908                   i, row3, row2, row1, row0);
7909             rc++;
7910         } else {
7911             break;
7912         }
7913     }
7914
7915     /* TSTORM */
7916     last_idx = REG_RD8(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_INDEX_OFFSET);
7917     if (last_idx) {
7918         BLOGE(sc, "TSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
7919     }
7920
7921     /* print the asserts */
7922     for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
7923
7924         row0 = REG_RD(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_OFFSET(i));
7925         row1 = REG_RD(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_OFFSET(i) + 4);
7926         row2 = REG_RD(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_OFFSET(i) + 8);
7927         row3 = REG_RD(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_OFFSET(i) + 12);
7928
7929         if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
7930             BLOGE(sc, "TSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
7931                   i, row3, row2, row1, row0);
7932             rc++;
7933         } else {
7934             break;
7935         }
7936     }
7937
7938     /* CSTORM */
7939     last_idx = REG_RD8(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_INDEX_OFFSET);
7940     if (last_idx) {
7941         BLOGE(sc, "CSTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
7942     }
7943
7944     /* print the asserts */
7945     for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
7946
7947         row0 = REG_RD(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_OFFSET(i));
7948         row1 = REG_RD(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_OFFSET(i) + 4);
7949         row2 = REG_RD(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_OFFSET(i) + 8);
7950         row3 = REG_RD(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_OFFSET(i) + 12);
7951
7952         if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
7953             BLOGE(sc, "CSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
7954                   i, row3, row2, row1, row0);
7955             rc++;
7956         } else {
7957             break;
7958         }
7959     }
7960
7961     /* USTORM */
7962     last_idx = REG_RD8(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_INDEX_OFFSET);
7963     if (last_idx) {
7964         BLOGE(sc, "USTORM_ASSERT_LIST_INDEX 0x%x\n", last_idx);
7965     }
7966
7967     /* print the asserts */
7968     for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
7969
7970         row0 = REG_RD(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_OFFSET(i));
7971         row1 = REG_RD(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_OFFSET(i) + 4);
7972         row2 = REG_RD(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_OFFSET(i) + 8);
7973         row3 = REG_RD(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_OFFSET(i) + 12);
7974
7975         if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
7976             BLOGE(sc, "USTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x\n",
7977                   i, row3, row2, row1, row0);
7978             rc++;
7979         } else {
7980             break;
7981         }
7982     }
7983
7984     return (rc);
7985 }
7986
7987 static void
7988 bxe_attn_int_deasserted3(struct bxe_softc *sc,
7989                          uint32_t         attn)
7990 {
7991     int func = SC_FUNC(sc);
7992     uint32_t val;
7993
7994     if (attn & EVEREST_GEN_ATTN_IN_USE_MASK) {
7995
7996         if (attn & BXE_PMF_LINK_ASSERT(sc)) {
7997
7998             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
7999             bxe_read_mf_cfg(sc);
8000             sc->devinfo.mf_info.mf_config[SC_VN(sc)] =
8001                 MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].config);
8002             val = SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_status);
8003
8004             if (val & DRV_STATUS_DCC_EVENT_MASK)
8005                 bxe_dcc_event(sc, (val & DRV_STATUS_DCC_EVENT_MASK));
8006
8007             if (val & DRV_STATUS_SET_MF_BW)
8008                 bxe_set_mf_bw(sc);
8009
8010             if (val & DRV_STATUS_DRV_INFO_REQ)
8011                 bxe_handle_drv_info_req(sc);
8012
8013             if ((sc->port.pmf == 0) && (val & DRV_STATUS_PMF))
8014                 bxe_pmf_update(sc);
8015
8016             if (val & DRV_STATUS_EEE_NEGOTIATION_RESULTS)
8017                 bxe_handle_eee_event(sc);
8018
8019             if (sc->link_vars.periodic_flags &
8020                 ELINK_PERIODIC_FLAGS_LINK_EVENT) {
8021                 /* sync with link */
8022                 bxe_acquire_phy_lock(sc);
8023                 sc->link_vars.periodic_flags &=
8024                     ~ELINK_PERIODIC_FLAGS_LINK_EVENT;
8025                 bxe_release_phy_lock(sc);
8026                 if (IS_MF(sc))
8027                     ; // XXX bxe_link_sync_notify(sc);
8028                 bxe_link_report(sc);
8029             }
8030
8031             /*
8032              * Always call it here: bxe_link_report() will
8033              * prevent the link indication duplication.
8034              */
8035             bxe_link_status_update(sc);
8036
8037         } else if (attn & BXE_MC_ASSERT_BITS) {
8038
8039             BLOGE(sc, "MC assert!\n");
8040             bxe_mc_assert(sc);
8041             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_10, 0);
8042             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_9, 0);
8043             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_8, 0);
8044             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_7, 0);
8045             bxe_panic(sc, ("MC assert!\n"));
8046
8047         } else if (attn & BXE_MCP_ASSERT) {
8048
8049             BLOGE(sc, "MCP assert!\n");
8050             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_11, 0);
8051             // XXX bxe_fw_dump(sc);
8052
8053         } else {
8054             BLOGE(sc, "Unknown HW assert! (attn 0x%08x)\n", attn);
8055         }
8056     }
8057
8058     if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
8059         BLOGE(sc, "LATCHED attention 0x%08x (masked)\n", attn);
8060         if (attn & BXE_GRC_TIMEOUT) {
8061             val = CHIP_IS_E1(sc) ? 0 : REG_RD(sc, MISC_REG_GRC_TIMEOUT_ATTN);
8062             BLOGE(sc, "GRC time-out 0x%08x\n", val);
8063         }
8064         if (attn & BXE_GRC_RSV) {
8065             val = CHIP_IS_E1(sc) ? 0 : REG_RD(sc, MISC_REG_GRC_RSV_ATTN);
8066             BLOGE(sc, "GRC reserved 0x%08x\n", val);
8067         }
8068         REG_WR(sc, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
8069     }
8070 }
8071
8072 static void
8073 bxe_attn_int_deasserted2(struct bxe_softc *sc,
8074                          uint32_t         attn)
8075 {
8076     int port = SC_PORT(sc);
8077     int reg_offset;
8078     uint32_t val0, mask0, val1, mask1;
8079     uint32_t val;
8080
8081     if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
8082         val = REG_RD(sc, CFC_REG_CFC_INT_STS_CLR);
8083         BLOGE(sc, "CFC hw attention 0x%08x\n", val);
8084         /* CFC error attention */
8085         if (val & 0x2) {
8086             BLOGE(sc, "FATAL error from CFC\n");
8087         }
8088     }
8089
8090     if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
8091         val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_0);
8092         BLOGE(sc, "PXP hw attention-0 0x%08x\n", val);
8093         /* RQ_USDMDP_FIFO_OVERFLOW */
8094         if (val & 0x18000) {
8095             BLOGE(sc, "FATAL error from PXP\n");
8096         }
8097
8098         if (!CHIP_IS_E1x(sc)) {
8099             val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_1);
8100             BLOGE(sc, "PXP hw attention-1 0x%08x\n", val);
8101         }
8102     }
8103
8104 #define PXP2_EOP_ERROR_BIT  PXP2_PXP2_INT_STS_CLR_0_REG_WR_PGLUE_EOP_ERROR
8105 #define AEU_PXP2_HW_INT_BIT AEU_INPUTS_ATTN_BITS_PXPPCICLOCKCLIENT_HW_INTERRUPT
8106
8107     if (attn & AEU_PXP2_HW_INT_BIT) {
8108         /*  CQ47854 workaround do not panic on
8109          *  PXP2_PXP2_INT_STS_0_REG_WR_PGLUE_EOP_ERROR
8110          */
8111         if (!CHIP_IS_E1x(sc)) {
8112             mask0 = REG_RD(sc, PXP2_REG_PXP2_INT_MASK_0);
8113             val1 = REG_RD(sc, PXP2_REG_PXP2_INT_STS_1);
8114             mask1 = REG_RD(sc, PXP2_REG_PXP2_INT_MASK_1);
8115             val0 = REG_RD(sc, PXP2_REG_PXP2_INT_STS_0);
8116             /*
8117              * If the olny PXP2_EOP_ERROR_BIT is set in
8118              * STS0 and STS1 - clear it
8119              *
8120              * probably we lose additional attentions between
8121              * STS0 and STS_CLR0, in this case user will not
8122              * be notified about them
8123              */
8124             if (val0 & mask0 & PXP2_EOP_ERROR_BIT &&
8125                 !(val1 & mask1))
8126                 val0 = REG_RD(sc, PXP2_REG_PXP2_INT_STS_CLR_0);
8127
8128             /* print the register, since no one can restore it */
8129             BLOGE(sc, "PXP2_REG_PXP2_INT_STS_CLR_0 0x%08x\n", val0);
8130
8131             /*
8132              * if PXP2_PXP2_INT_STS_0_REG_WR_PGLUE_EOP_ERROR
8133              * then notify
8134              */
8135             if (val0 & PXP2_EOP_ERROR_BIT) {
8136                 BLOGE(sc, "PXP2_WR_PGLUE_EOP_ERROR\n");
8137
8138                 /*
8139                  * if only PXP2_PXP2_INT_STS_0_REG_WR_PGLUE_EOP_ERROR is
8140                  * set then clear attention from PXP2 block without panic
8141                  */
8142                 if (((val0 & mask0) == PXP2_EOP_ERROR_BIT) &&
8143                     ((val1 & mask1) == 0))
8144                     attn &= ~AEU_PXP2_HW_INT_BIT;
8145             }
8146         }
8147     }
8148
8149     if (attn & HW_INTERRUT_ASSERT_SET_2) {
8150         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_2 :
8151                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_2);
8152
8153         val = REG_RD(sc, reg_offset);
8154         val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
8155         REG_WR(sc, reg_offset, val);
8156
8157         BLOGE(sc, "FATAL HW block attention set2 0x%x\n",
8158               (uint32_t)(attn & HW_INTERRUT_ASSERT_SET_2));
8159         bxe_panic(sc, ("HW block attention set2\n"));
8160     }
8161 }
8162
8163 static void
8164 bxe_attn_int_deasserted1(struct bxe_softc *sc,
8165                          uint32_t         attn)
8166 {
8167     int port = SC_PORT(sc);
8168     int reg_offset;
8169     uint32_t val;
8170
8171     if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
8172         val = REG_RD(sc, DORQ_REG_DORQ_INT_STS_CLR);
8173         BLOGE(sc, "DB hw attention 0x%08x\n", val);
8174         /* DORQ discard attention */
8175         if (val & 0x2) {
8176             BLOGE(sc, "FATAL error from DORQ\n");
8177         }
8178     }
8179
8180     if (attn & HW_INTERRUT_ASSERT_SET_1) {
8181         reg_offset = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_1 :
8182                              MISC_REG_AEU_ENABLE1_FUNC_0_OUT_1);
8183
8184         val = REG_RD(sc, reg_offset);
8185         val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
8186         REG_WR(sc, reg_offset, val);
8187
8188         BLOGE(sc, "FATAL HW block attention set1 0x%08x\n",
8189               (uint32_t)(attn & HW_INTERRUT_ASSERT_SET_1));
8190         bxe_panic(sc, ("HW block attention set1\n"));
8191     }
8192 }
8193
8194 static void
8195 bxe_attn_int_deasserted0(struct bxe_softc *sc,
8196                          uint32_t         attn)
8197 {
8198     int port = SC_PORT(sc);
8199     int reg_offset;
8200     uint32_t val;
8201
8202     reg_offset = (port) ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
8203                           MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0;
8204
8205     if (attn & AEU_INPUTS_ATTN_BITS_SPIO5) {
8206         val = REG_RD(sc, reg_offset);
8207         val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
8208         REG_WR(sc, reg_offset, val);
8209
8210         BLOGW(sc, "SPIO5 hw attention\n");
8211
8212         /* Fan failure attention */
8213         elink_hw_reset_phy(&sc->link_params);
8214         bxe_fan_failure(sc);
8215     }
8216
8217     if ((attn & sc->link_vars.aeu_int_mask) && sc->port.pmf) {
8218         bxe_acquire_phy_lock(sc);
8219         elink_handle_module_detect_int(&sc->link_params);
8220         bxe_release_phy_lock(sc);
8221     }
8222
8223     if (attn & HW_INTERRUT_ASSERT_SET_0) {
8224         val = REG_RD(sc, reg_offset);
8225         val &= ~(attn & HW_INTERRUT_ASSERT_SET_0);
8226         REG_WR(sc, reg_offset, val);
8227
8228         bxe_panic(sc, ("FATAL HW block attention set0 0x%lx\n",
8229                        (attn & HW_INTERRUT_ASSERT_SET_0)));
8230     }
8231 }
8232
8233 static void
8234 bxe_attn_int_deasserted(struct bxe_softc *sc,
8235                         uint32_t         deasserted)
8236 {
8237     struct attn_route attn;
8238     struct attn_route *group_mask;
8239     int port = SC_PORT(sc);
8240     int index;
8241     uint32_t reg_addr;
8242     uint32_t val;
8243     uint32_t aeu_mask;
8244     uint8_t global = FALSE;
8245
8246     /*
8247      * Need to take HW lock because MCP or other port might also
8248      * try to handle this event.
8249      */
8250     bxe_acquire_alr(sc);
8251
8252     if (bxe_chk_parity_attn(sc, &global, TRUE)) {
8253         /* XXX
8254          * In case of parity errors don't handle attentions so that
8255          * other function would "see" parity errors.
8256          */
8257         sc->recovery_state = BXE_RECOVERY_INIT;
8258         // XXX schedule a recovery task...
8259         /* disable HW interrupts */
8260         bxe_int_disable(sc);
8261         bxe_release_alr(sc);
8262         return;
8263     }
8264
8265     attn.sig[0] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 + port*4);
8266     attn.sig[1] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_2_FUNC_0 + port*4);
8267     attn.sig[2] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_3_FUNC_0 + port*4);
8268     attn.sig[3] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_4_FUNC_0 + port*4);
8269     if (!CHIP_IS_E1x(sc)) {
8270         attn.sig[4] = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_5_FUNC_0 + port*4);
8271     } else {
8272         attn.sig[4] = 0;
8273     }
8274
8275     BLOGD(sc, DBG_INTR, "attn: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
8276           attn.sig[0], attn.sig[1], attn.sig[2], attn.sig[3], attn.sig[4]);
8277
8278     for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
8279         if (deasserted & (1 << index)) {
8280             group_mask = &sc->attn_group[index];
8281
8282             BLOGD(sc, DBG_INTR,
8283                   "group[%d]: 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n", index,
8284                   group_mask->sig[0], group_mask->sig[1],
8285                   group_mask->sig[2], group_mask->sig[3],
8286                   group_mask->sig[4]);
8287
8288             bxe_attn_int_deasserted4(sc, attn.sig[4] & group_mask->sig[4]);
8289             bxe_attn_int_deasserted3(sc, attn.sig[3] & group_mask->sig[3]);
8290             bxe_attn_int_deasserted1(sc, attn.sig[1] & group_mask->sig[1]);
8291             bxe_attn_int_deasserted2(sc, attn.sig[2] & group_mask->sig[2]);
8292             bxe_attn_int_deasserted0(sc, attn.sig[0] & group_mask->sig[0]);
8293         }
8294     }
8295
8296     bxe_release_alr(sc);
8297
8298     if (sc->devinfo.int_block == INT_BLOCK_HC) {
8299         reg_addr = (HC_REG_COMMAND_REG + port*32 +
8300                     COMMAND_REG_ATTN_BITS_CLR);
8301     } else {
8302         reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_CLR_UPPER*8);
8303     }
8304
8305     val = ~deasserted;
8306     BLOGD(sc, DBG_INTR,
8307           "about to mask 0x%08x at %s addr 0x%08x\n", val,
8308           (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU", reg_addr);
8309     REG_WR(sc, reg_addr, val);
8310
8311     if (~sc->attn_state & deasserted) {
8312         BLOGE(sc, "IGU error\n");
8313     }
8314
8315     reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
8316                       MISC_REG_AEU_MASK_ATTN_FUNC_0;
8317
8318     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
8319
8320     aeu_mask = REG_RD(sc, reg_addr);
8321
8322     BLOGD(sc, DBG_INTR, "aeu_mask 0x%08x newly deasserted 0x%08x\n",
8323           aeu_mask, deasserted);
8324     aeu_mask |= (deasserted & 0x3ff);
8325     BLOGD(sc, DBG_INTR, "new mask 0x%08x\n", aeu_mask);
8326
8327     REG_WR(sc, reg_addr, aeu_mask);
8328     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
8329
8330     BLOGD(sc, DBG_INTR, "attn_state 0x%08x\n", sc->attn_state);
8331     sc->attn_state &= ~deasserted;
8332     BLOGD(sc, DBG_INTR, "new state 0x%08x\n", sc->attn_state);
8333 }
8334
8335 static void
8336 bxe_attn_int(struct bxe_softc *sc)
8337 {
8338     /* read local copy of bits */
8339     uint32_t attn_bits = le32toh(sc->def_sb->atten_status_block.attn_bits);
8340     uint32_t attn_ack = le32toh(sc->def_sb->atten_status_block.attn_bits_ack);
8341     uint32_t attn_state = sc->attn_state;
8342
8343     /* look for changed bits */
8344     uint32_t asserted   =  attn_bits & ~attn_ack & ~attn_state;
8345     uint32_t deasserted = ~attn_bits &  attn_ack &  attn_state;
8346
8347     BLOGD(sc, DBG_INTR,
8348           "attn_bits 0x%08x attn_ack 0x%08x asserted 0x%08x deasserted 0x%08x\n",
8349           attn_bits, attn_ack, asserted, deasserted);
8350
8351     if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state)) {
8352         BLOGE(sc, "BAD attention state\n");
8353     }
8354
8355     /* handle bits that were raised */
8356     if (asserted) {
8357         bxe_attn_int_asserted(sc, asserted);
8358     }
8359
8360     if (deasserted) {
8361         bxe_attn_int_deasserted(sc, deasserted);
8362     }
8363 }
8364
8365 static uint16_t
8366 bxe_update_dsb_idx(struct bxe_softc *sc)
8367 {
8368     struct host_sp_status_block *def_sb = sc->def_sb;
8369     uint16_t rc = 0;
8370
8371     mb(); /* status block is written to by the chip */
8372
8373     if (sc->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
8374         sc->def_att_idx = def_sb->atten_status_block.attn_bits_index;
8375         rc |= BXE_DEF_SB_ATT_IDX;
8376     }
8377
8378     if (sc->def_idx != def_sb->sp_sb.running_index) {
8379         sc->def_idx = def_sb->sp_sb.running_index;
8380         rc |= BXE_DEF_SB_IDX;
8381     }
8382
8383     mb();
8384
8385     return (rc);
8386 }
8387
8388 static inline struct ecore_queue_sp_obj *
8389 bxe_cid_to_q_obj(struct bxe_softc *sc,
8390                  uint32_t         cid)
8391 {
8392     BLOGD(sc, DBG_SP, "retrieving fp from cid %d\n", cid);
8393     return (&sc->sp_objs[CID_TO_FP(cid, sc)].q_obj);
8394 }
8395
8396 static void
8397 bxe_handle_mcast_eqe(struct bxe_softc *sc)
8398 {
8399     struct ecore_mcast_ramrod_params rparam;
8400     int rc;
8401
8402     memset(&rparam, 0, sizeof(rparam));
8403
8404     rparam.mcast_obj = &sc->mcast_obj;
8405
8406     BXE_MCAST_LOCK(sc);
8407
8408     /* clear pending state for the last command */
8409     sc->mcast_obj.raw.clear_pending(&sc->mcast_obj.raw);
8410
8411     /* if there are pending mcast commands - send them */
8412     if (sc->mcast_obj.check_pending(&sc->mcast_obj)) {
8413         rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
8414         if (rc < 0) {
8415             BLOGD(sc, DBG_SP,
8416                 "ERROR: Failed to send pending mcast commands (%d)\n", rc);
8417         }
8418     }
8419
8420     BXE_MCAST_UNLOCK(sc);
8421 }
8422
8423 static void
8424 bxe_handle_classification_eqe(struct bxe_softc      *sc,
8425                               union event_ring_elem *elem)
8426 {
8427     unsigned long ramrod_flags = 0;
8428     int rc = 0;
8429     uint32_t cid = elem->message.data.eth_event.echo & BXE_SWCID_MASK;
8430     struct ecore_vlan_mac_obj *vlan_mac_obj;
8431
8432     /* always push next commands out, don't wait here */
8433     bit_set(&ramrod_flags, RAMROD_CONT);
8434
8435     switch (le32toh(elem->message.data.eth_event.echo) >> BXE_SWCID_SHIFT) {
8436     case ECORE_FILTER_MAC_PENDING:
8437         BLOGD(sc, DBG_SP, "Got SETUP_MAC completions\n");
8438         vlan_mac_obj = &sc->sp_objs[cid].mac_obj;
8439         break;
8440
8441     case ECORE_FILTER_MCAST_PENDING:
8442         BLOGD(sc, DBG_SP, "Got SETUP_MCAST completions\n");
8443         /*
8444          * This is only relevant for 57710 where multicast MACs are
8445          * configured as unicast MACs using the same ramrod.
8446          */
8447         bxe_handle_mcast_eqe(sc);
8448         return;
8449
8450     default:
8451         BLOGE(sc, "Unsupported classification command: %d\n",
8452               elem->message.data.eth_event.echo);
8453         return;
8454     }
8455
8456     rc = vlan_mac_obj->complete(sc, vlan_mac_obj, elem, &ramrod_flags);
8457
8458     if (rc < 0) {
8459         BLOGE(sc, "Failed to schedule new commands (%d)\n", rc);
8460     } else if (rc > 0) {
8461         BLOGD(sc, DBG_SP, "Scheduled next pending commands...\n");
8462     }
8463 }
8464
8465 static void
8466 bxe_handle_rx_mode_eqe(struct bxe_softc      *sc,
8467                        union event_ring_elem *elem)
8468 {
8469     bxe_clear_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state);
8470
8471     /* send rx_mode command again if was requested */
8472     if (bxe_test_and_clear_bit(ECORE_FILTER_RX_MODE_SCHED,
8473                                &sc->sp_state)) {
8474         bxe_set_storm_rx_mode(sc);
8475     }
8476 }
8477
8478 static void
8479 bxe_update_eq_prod(struct bxe_softc *sc,
8480                    uint16_t         prod)
8481 {
8482     storm_memset_eq_prod(sc, prod, SC_FUNC(sc));
8483     wmb(); /* keep prod updates ordered */
8484 }
8485
8486 static void
8487 bxe_eq_int(struct bxe_softc *sc)
8488 {
8489     uint16_t hw_cons, sw_cons, sw_prod;
8490     union event_ring_elem *elem;
8491     uint8_t echo;
8492     uint32_t cid;
8493     uint8_t opcode;
8494     int spqe_cnt = 0;
8495     struct ecore_queue_sp_obj *q_obj;
8496     struct ecore_func_sp_obj *f_obj = &sc->func_obj;
8497     struct ecore_raw_obj *rss_raw = &sc->rss_conf_obj.raw;
8498
8499     hw_cons = le16toh(*sc->eq_cons_sb);
8500
8501     /*
8502      * The hw_cons range is 1-255, 257 - the sw_cons range is 0-254, 256.
8503      * when we get to the next-page we need to adjust so the loop
8504      * condition below will be met. The next element is the size of a
8505      * regular element and hence incrementing by 1
8506      */
8507     if ((hw_cons & EQ_DESC_MAX_PAGE) == EQ_DESC_MAX_PAGE) {
8508         hw_cons++;
8509     }
8510
8511     /*
8512      * This function may never run in parallel with itself for a
8513      * specific sc and no need for a read memory barrier here.
8514      */
8515     sw_cons = sc->eq_cons;
8516     sw_prod = sc->eq_prod;
8517
8518     BLOGD(sc, DBG_SP,"EQ: hw_cons=%u sw_cons=%u eq_spq_left=0x%lx\n",
8519           hw_cons, sw_cons, atomic_load_acq_long(&sc->eq_spq_left));
8520
8521     for (;
8522          sw_cons != hw_cons;
8523          sw_prod = NEXT_EQ_IDX(sw_prod), sw_cons = NEXT_EQ_IDX(sw_cons)) {
8524
8525         elem = &sc->eq[EQ_DESC(sw_cons)];
8526
8527         /* elem CID originates from FW, actually LE */
8528         cid = SW_CID(elem->message.data.cfc_del_event.cid);
8529         opcode = elem->message.opcode;
8530
8531         /* handle eq element */
8532         switch (opcode) {
8533
8534         case EVENT_RING_OPCODE_STAT_QUERY:
8535             BLOGD(sc, DBG_SP, "got statistics completion event %d\n",
8536                   sc->stats_comp++);
8537             /* nothing to do with stats comp */
8538             goto next_spqe;
8539
8540         case EVENT_RING_OPCODE_CFC_DEL:
8541             /* handle according to cid range */
8542             /* we may want to verify here that the sc state is HALTING */
8543             BLOGD(sc, DBG_SP, "got delete ramrod for MULTI[%d]\n", cid);
8544             q_obj = bxe_cid_to_q_obj(sc, cid);
8545             if (q_obj->complete_cmd(sc, q_obj, ECORE_Q_CMD_CFC_DEL)) {
8546                 break;
8547             }
8548             goto next_spqe;
8549
8550         case EVENT_RING_OPCODE_STOP_TRAFFIC:
8551             BLOGD(sc, DBG_SP, "got STOP TRAFFIC\n");
8552             if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_TX_STOP)) {
8553                 break;
8554             }
8555             // XXX bxe_dcbx_set_params(sc, BXE_DCBX_STATE_TX_PAUSED);
8556             goto next_spqe;
8557
8558         case EVENT_RING_OPCODE_START_TRAFFIC:
8559             BLOGD(sc, DBG_SP, "got START TRAFFIC\n");
8560             if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_TX_START)) {
8561                 break;
8562             }
8563             // XXX bxe_dcbx_set_params(sc, BXE_DCBX_STATE_TX_RELEASED);
8564             goto next_spqe;
8565
8566         case EVENT_RING_OPCODE_FUNCTION_UPDATE:
8567             echo = elem->message.data.function_update_event.echo;
8568             if (echo == SWITCH_UPDATE) {
8569                 BLOGD(sc, DBG_SP, "got FUNC_SWITCH_UPDATE ramrod\n");
8570                 if (f_obj->complete_cmd(sc, f_obj,
8571                                         ECORE_F_CMD_SWITCH_UPDATE)) {
8572                     break;
8573                 }
8574             }
8575             else {
8576                 BLOGD(sc, DBG_SP,
8577                       "AFEX: ramrod completed FUNCTION_UPDATE\n");
8578             }
8579             goto next_spqe;
8580
8581         case EVENT_RING_OPCODE_FORWARD_SETUP:
8582             q_obj = &bxe_fwd_sp_obj(sc, q_obj);
8583             if (q_obj->complete_cmd(sc, q_obj,
8584                                     ECORE_Q_CMD_SETUP_TX_ONLY)) {
8585                 break;
8586             }
8587             goto next_spqe;
8588
8589         case EVENT_RING_OPCODE_FUNCTION_START:
8590             BLOGD(sc, DBG_SP, "got FUNC_START ramrod\n");
8591             if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_START)) {
8592                 break;
8593             }
8594             goto next_spqe;
8595
8596         case EVENT_RING_OPCODE_FUNCTION_STOP:
8597             BLOGD(sc, DBG_SP, "got FUNC_STOP ramrod\n");
8598             if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_STOP)) {
8599                 break;
8600             }
8601             goto next_spqe;
8602         }
8603
8604         switch (opcode | sc->state) {
8605         case (EVENT_RING_OPCODE_RSS_UPDATE_RULES | BXE_STATE_OPEN):
8606         case (EVENT_RING_OPCODE_RSS_UPDATE_RULES | BXE_STATE_OPENING_WAITING_PORT):
8607             cid = elem->message.data.eth_event.echo & BXE_SWCID_MASK;
8608             BLOGD(sc, DBG_SP, "got RSS_UPDATE ramrod. CID %d\n", cid);
8609             rss_raw->clear_pending(rss_raw);
8610             break;
8611
8612         case (EVENT_RING_OPCODE_SET_MAC | BXE_STATE_OPEN):
8613         case (EVENT_RING_OPCODE_SET_MAC | BXE_STATE_DIAG):
8614         case (EVENT_RING_OPCODE_SET_MAC | BXE_STATE_CLOSING_WAITING_HALT):
8615         case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BXE_STATE_OPEN):
8616         case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BXE_STATE_DIAG):
8617         case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BXE_STATE_CLOSING_WAITING_HALT):
8618             BLOGD(sc, DBG_SP, "got (un)set mac ramrod\n");
8619             bxe_handle_classification_eqe(sc, elem);
8620             break;
8621
8622         case (EVENT_RING_OPCODE_MULTICAST_RULES | BXE_STATE_OPEN):
8623         case (EVENT_RING_OPCODE_MULTICAST_RULES | BXE_STATE_DIAG):
8624         case (EVENT_RING_OPCODE_MULTICAST_RULES | BXE_STATE_CLOSING_WAITING_HALT):
8625             BLOGD(sc, DBG_SP, "got mcast ramrod\n");
8626             bxe_handle_mcast_eqe(sc);
8627             break;
8628
8629         case (EVENT_RING_OPCODE_FILTERS_RULES | BXE_STATE_OPEN):
8630         case (EVENT_RING_OPCODE_FILTERS_RULES | BXE_STATE_DIAG):
8631         case (EVENT_RING_OPCODE_FILTERS_RULES | BXE_STATE_CLOSING_WAITING_HALT):
8632             BLOGD(sc, DBG_SP, "got rx_mode ramrod\n");
8633             bxe_handle_rx_mode_eqe(sc, elem);
8634             break;
8635
8636         default:
8637             /* unknown event log error and continue */
8638             BLOGE(sc, "Unknown EQ event %d, sc->state 0x%x\n",
8639                   elem->message.opcode, sc->state);
8640         }
8641
8642 next_spqe:
8643         spqe_cnt++;
8644     } /* for */
8645
8646     mb();
8647     atomic_add_acq_long(&sc->eq_spq_left, spqe_cnt);
8648
8649     sc->eq_cons = sw_cons;
8650     sc->eq_prod = sw_prod;
8651
8652     /* make sure that above mem writes were issued towards the memory */
8653     wmb();
8654
8655     /* update producer */
8656     bxe_update_eq_prod(sc, sc->eq_prod);
8657 }
8658
8659 static void
8660 bxe_handle_sp_tq(void *context,
8661                  int  pending)
8662 {
8663     struct bxe_softc *sc = (struct bxe_softc *)context;
8664     uint16_t status;
8665
8666     BLOGD(sc, DBG_SP, "---> SP TASK <---\n");
8667
8668     /* what work needs to be performed? */
8669     status = bxe_update_dsb_idx(sc);
8670
8671     BLOGD(sc, DBG_SP, "dsb status 0x%04x\n", status);
8672
8673     /* HW attentions */
8674     if (status & BXE_DEF_SB_ATT_IDX) {
8675         BLOGD(sc, DBG_SP, "---> ATTN INTR <---\n");
8676         bxe_attn_int(sc);
8677         status &= ~BXE_DEF_SB_ATT_IDX;
8678     }
8679
8680     /* SP events: STAT_QUERY and others */
8681     if (status & BXE_DEF_SB_IDX) {
8682         /* handle EQ completions */
8683         BLOGD(sc, DBG_SP, "---> EQ INTR <---\n");
8684         bxe_eq_int(sc);
8685         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
8686                    le16toh(sc->def_idx), IGU_INT_NOP, 1);
8687         status &= ~BXE_DEF_SB_IDX;
8688     }
8689
8690     /* if status is non zero then something went wrong */
8691     if (__predict_false(status)) {
8692         BLOGE(sc, "Got an unknown SP interrupt! (0x%04x)\n", status);
8693     }
8694
8695     /* ack status block only if something was actually handled */
8696     bxe_ack_sb(sc, sc->igu_dsb_id, ATTENTION_ID,
8697                le16toh(sc->def_att_idx), IGU_INT_ENABLE, 1);
8698
8699     /*
8700      * Must be called after the EQ processing (since eq leads to sriov
8701      * ramrod completion flows).
8702      * This flow may have been scheduled by the arrival of a ramrod
8703      * completion, or by the sriov code rescheduling itself.
8704      */
8705     // XXX bxe_iov_sp_task(sc);
8706
8707 }
8708
8709 static void
8710 bxe_handle_fp_tq(void *context,
8711                  int  pending)
8712 {
8713     struct bxe_fastpath *fp = (struct bxe_fastpath *)context;
8714     struct bxe_softc *sc = fp->sc;
8715     uint8_t more_tx = FALSE;
8716     uint8_t more_rx = FALSE;
8717
8718     BLOGD(sc, DBG_INTR, "---> FP TASK QUEUE (%d) <---\n", fp->index);
8719
8720     /* XXX
8721      * IFF_DRV_RUNNING state can't be checked here since we process
8722      * slowpath events on a client queue during setup. Instead
8723      * we need to add a "process/continue" flag here that the driver
8724      * can use to tell the task here not to do anything.
8725      */
8726 #if 0
8727     if (!(sc->ifnet->if_drv_flags & IFF_DRV_RUNNING)) {
8728         return;
8729     }
8730 #endif
8731
8732     /* update the fastpath index */
8733     bxe_update_fp_sb_idx(fp);
8734
8735     /* XXX add loop here if ever support multiple tx CoS */
8736     /* fp->txdata[cos] */
8737     if (bxe_has_tx_work(fp)) {
8738         BXE_FP_TX_LOCK(fp);
8739         more_tx = bxe_txeof(sc, fp);
8740         BXE_FP_TX_UNLOCK(fp);
8741     }
8742
8743     if (bxe_has_rx_work(fp)) {
8744         more_rx = bxe_rxeof(sc, fp);
8745     }
8746
8747     if (more_rx /*|| more_tx*/) {
8748         /* still more work to do */
8749         taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
8750         return;
8751     }
8752
8753     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
8754                le16toh(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
8755 }
8756
8757 static void
8758 bxe_task_fp(struct bxe_fastpath *fp)
8759 {
8760     struct bxe_softc *sc = fp->sc;
8761     uint8_t more_tx = FALSE;
8762     uint8_t more_rx = FALSE;
8763
8764     BLOGD(sc, DBG_INTR, "---> FP TASK ISR (%d) <---\n", fp->index);
8765
8766     /* update the fastpath index */
8767     bxe_update_fp_sb_idx(fp);
8768
8769     /* XXX add loop here if ever support multiple tx CoS */
8770     /* fp->txdata[cos] */
8771     if (bxe_has_tx_work(fp)) {
8772         BXE_FP_TX_LOCK(fp);
8773         more_tx = bxe_txeof(sc, fp);
8774         BXE_FP_TX_UNLOCK(fp);
8775     }
8776
8777     if (bxe_has_rx_work(fp)) {
8778         more_rx = bxe_rxeof(sc, fp);
8779     }
8780
8781     if (more_rx /*|| more_tx*/) {
8782         /* still more work to do, bail out if this ISR and process later */
8783         taskqueue_enqueue_fast(fp->tq, &fp->tq_task);
8784         return;
8785     }
8786
8787     /*
8788      * Here we write the fastpath index taken before doing any tx or rx work.
8789      * It is very well possible other hw events occurred up to this point and
8790      * they were actually processed accordingly above. Since we're going to
8791      * write an older fastpath index, an interrupt is coming which we might
8792      * not do any work in.
8793      */
8794     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
8795                le16toh(fp->fp_hc_idx), IGU_INT_ENABLE, 1);
8796 }
8797
8798 /*
8799  * Legacy interrupt entry point.
8800  *
8801  * Verifies that the controller generated the interrupt and
8802  * then calls a separate routine to handle the various
8803  * interrupt causes: link, RX, and TX.
8804  */
8805 static void
8806 bxe_intr_legacy(void *xsc)
8807 {
8808     struct bxe_softc *sc = (struct bxe_softc *)xsc;
8809     struct bxe_fastpath *fp;
8810     uint16_t status, mask;
8811     int i;
8812
8813     BLOGD(sc, DBG_INTR, "---> BXE INTx <---\n");
8814
8815     /*
8816      * 0 for ustorm, 1 for cstorm
8817      * the bits returned from ack_int() are 0-15
8818      * bit 0 = attention status block
8819      * bit 1 = fast path status block
8820      * a mask of 0x2 or more = tx/rx event
8821      * a mask of 1 = slow path event
8822      */
8823
8824     status = bxe_ack_int(sc);
8825
8826     /* the interrupt is not for us */
8827     if (__predict_false(status == 0)) {
8828         BLOGD(sc, DBG_INTR, "Not our interrupt!\n");
8829         return;
8830     }
8831
8832     BLOGD(sc, DBG_INTR, "Interrupt status 0x%04x\n", status);
8833
8834     FOR_EACH_ETH_QUEUE(sc, i) {
8835         fp = &sc->fp[i];
8836         mask = (0x2 << (fp->index + CNIC_SUPPORT(sc)));
8837         if (status & mask) {
8838             /* acknowledge and disable further fastpath interrupts */
8839             bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
8840             bxe_task_fp(fp);
8841             status &= ~mask;
8842         }
8843     }
8844
8845     if (__predict_false(status & 0x1)) {
8846         /* acknowledge and disable further slowpath interrupts */
8847         bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
8848
8849         /* schedule slowpath handler */
8850         taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
8851
8852         status &= ~0x1;
8853     }
8854
8855     if (__predict_false(status)) {
8856         BLOGW(sc, "Unexpected fastpath status (0x%08x)!\n", status);
8857     }
8858 }
8859
8860 /* slowpath interrupt entry point */
8861 static void
8862 bxe_intr_sp(void *xsc)
8863 {
8864     struct bxe_softc *sc = (struct bxe_softc *)xsc;
8865
8866     BLOGD(sc, (DBG_INTR | DBG_SP), "---> SP INTR <---\n");
8867
8868     /* acknowledge and disable further slowpath interrupts */
8869     bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
8870
8871     /* schedule slowpath handler */
8872     taskqueue_enqueue_fast(sc->sp_tq, &sc->sp_tq_task);
8873 }
8874
8875 /* fastpath interrupt entry point */
8876 static void
8877 bxe_intr_fp(void *xfp)
8878 {
8879     struct bxe_fastpath *fp = (struct bxe_fastpath *)xfp;
8880     struct bxe_softc *sc = fp->sc;
8881
8882     BLOGD(sc, DBG_INTR, "---> FP INTR %d <---\n", fp->index);
8883
8884     BLOGD(sc, DBG_INTR,
8885           "(cpu=%d) MSI-X fp=%d fw_sb=%d igu_sb=%d\n",
8886           curcpu, fp->index, fp->fw_sb_id, fp->igu_sb_id);
8887
8888     /* acknowledge and disable further fastpath interrupts */
8889     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
8890
8891     bxe_task_fp(fp);
8892 }
8893
8894 /* Release all interrupts allocated by the driver. */
8895 static void
8896 bxe_interrupt_free(struct bxe_softc *sc)
8897 {
8898     int i;
8899
8900     switch (sc->interrupt_mode) {
8901     case INTR_MODE_INTX:
8902         BLOGD(sc, DBG_LOAD, "Releasing legacy INTx vector\n");
8903         if (sc->intr[0].resource != NULL) {
8904             bus_release_resource(sc->dev,
8905                                  SYS_RES_IRQ,
8906                                  sc->intr[0].rid,
8907                                  sc->intr[0].resource);
8908         }
8909         break;
8910     case INTR_MODE_MSI:
8911         for (i = 0; i < sc->intr_count; i++) {
8912             BLOGD(sc, DBG_LOAD, "Releasing MSI vector %d\n", i);
8913             if (sc->intr[i].resource && sc->intr[i].rid) {
8914                 bus_release_resource(sc->dev,
8915                                      SYS_RES_IRQ,
8916                                      sc->intr[i].rid,
8917                                      sc->intr[i].resource);
8918             }
8919         }
8920         pci_release_msi(sc->dev);
8921         break;
8922     case INTR_MODE_MSIX:
8923         for (i = 0; i < sc->intr_count; i++) {
8924             BLOGD(sc, DBG_LOAD, "Releasing MSI-X vector %d\n", i);
8925             if (sc->intr[i].resource && sc->intr[i].rid) {
8926                 bus_release_resource(sc->dev,
8927                                      SYS_RES_IRQ,
8928                                      sc->intr[i].rid,
8929                                      sc->intr[i].resource);
8930             }
8931         }
8932         pci_release_msi(sc->dev);
8933         break;
8934     default:
8935         /* nothing to do as initial allocation failed */
8936         break;
8937     }
8938 }
8939
8940 /*
8941  * This function determines and allocates the appropriate
8942  * interrupt based on system capabilites and user request.
8943  *
8944  * The user may force a particular interrupt mode, specify
8945  * the number of receive queues, specify the method for
8946  * distribuitng received frames to receive queues, or use
8947  * the default settings which will automatically select the
8948  * best supported combination.  In addition, the OS may or
8949  * may not support certain combinations of these settings.
8950  * This routine attempts to reconcile the settings requested
8951  * by the user with the capabilites available from the system
8952  * to select the optimal combination of features.
8953  *
8954  * Returns:
8955  *   0 = Success, !0 = Failure.
8956  */
8957 static int
8958 bxe_interrupt_alloc(struct bxe_softc *sc)
8959 {
8960     int msix_count = 0;
8961     int msi_count = 0;
8962     int num_requested = 0;
8963     int num_allocated = 0;
8964     int rid, i, j;
8965     int rc;
8966
8967     /* get the number of available MSI/MSI-X interrupts from the OS */
8968     if (sc->interrupt_mode > 0) {
8969         if (sc->devinfo.pcie_cap_flags & BXE_MSIX_CAPABLE_FLAG) {
8970             msix_count = pci_msix_count(sc->dev);
8971         }
8972
8973         if (sc->devinfo.pcie_cap_flags & BXE_MSI_CAPABLE_FLAG) {
8974             msi_count = pci_msi_count(sc->dev);
8975         }
8976
8977         BLOGD(sc, DBG_LOAD, "%d MSI and %d MSI-X vectors available\n",
8978               msi_count, msix_count);
8979     }
8980
8981     do { /* try allocating MSI-X interrupt resources (at least 2) */
8982         if (sc->interrupt_mode != INTR_MODE_MSIX) {
8983             break;
8984         }
8985
8986         if (((sc->devinfo.pcie_cap_flags & BXE_MSIX_CAPABLE_FLAG) == 0) ||
8987             (msix_count < 2)) {
8988             sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
8989             break;
8990         }
8991
8992         /* ask for the necessary number of MSI-X vectors */
8993         num_requested = min((sc->num_queues + 1), msix_count);
8994
8995         BLOGD(sc, DBG_LOAD, "Requesting %d MSI-X vectors\n", num_requested);
8996
8997         num_allocated = num_requested;
8998         if ((rc = pci_alloc_msix(sc->dev, &num_allocated)) != 0) {
8999             BLOGE(sc, "MSI-X alloc failed! (%d)\n", rc);
9000             sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
9001             break;
9002         }
9003
9004         if (num_allocated < 2) { /* possible? */
9005             BLOGE(sc, "MSI-X allocation less than 2!\n");
9006             sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
9007             pci_release_msi(sc->dev);
9008             break;
9009         }
9010
9011         BLOGI(sc, "MSI-X vectors Requested %d and Allocated %d\n",
9012               num_requested, num_allocated);
9013
9014         /* best effort so use the number of vectors allocated to us */
9015         sc->intr_count = num_allocated;
9016         sc->num_queues = num_allocated - 1;
9017
9018         rid = 1; /* initial resource identifier */
9019
9020         /* allocate the MSI-X vectors */
9021         for (i = 0; i < num_allocated; i++) {
9022             sc->intr[i].rid = (rid + i);
9023
9024             if ((sc->intr[i].resource =
9025                  bus_alloc_resource_any(sc->dev,
9026                                         SYS_RES_IRQ,
9027                                         &sc->intr[i].rid,
9028                                         RF_ACTIVE)) == NULL) {
9029                 BLOGE(sc, "Failed to map MSI-X[%d] (rid=%d)!\n",
9030                       i, (rid + i));
9031
9032                 for (j = (i - 1); j >= 0; j--) {
9033                     bus_release_resource(sc->dev,
9034                                          SYS_RES_IRQ,
9035                                          sc->intr[j].rid,
9036                                          sc->intr[j].resource);
9037                 }
9038
9039                 sc->intr_count = 0;
9040                 sc->num_queues = 0;
9041                 sc->interrupt_mode = INTR_MODE_MSI; /* try MSI next */
9042                 pci_release_msi(sc->dev);
9043                 break;
9044             }
9045
9046             BLOGD(sc, DBG_LOAD, "Mapped MSI-X[%d] (rid=%d)\n", i, (rid + i));
9047         }
9048     } while (0);
9049
9050     do { /* try allocating MSI vector resources (at least 2) */
9051         if (sc->interrupt_mode != INTR_MODE_MSI) {
9052             break;
9053         }
9054
9055         if (((sc->devinfo.pcie_cap_flags & BXE_MSI_CAPABLE_FLAG) == 0) ||
9056             (msi_count < 1)) {
9057             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
9058             break;
9059         }
9060
9061         /* ask for a single MSI vector */
9062         num_requested = 1;
9063
9064         BLOGD(sc, DBG_LOAD, "Requesting %d MSI vectors\n", num_requested);
9065
9066         num_allocated = num_requested;
9067         if ((rc = pci_alloc_msi(sc->dev, &num_allocated)) != 0) {
9068             BLOGE(sc, "MSI alloc failed (%d)!\n", rc);
9069             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
9070             break;
9071         }
9072
9073         if (num_allocated != 1) { /* possible? */
9074             BLOGE(sc, "MSI allocation is not 1!\n");
9075             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
9076             pci_release_msi(sc->dev);
9077             break;
9078         }
9079
9080         BLOGI(sc, "MSI vectors Requested %d and Allocated %d\n",
9081               num_requested, num_allocated);
9082
9083         /* best effort so use the number of vectors allocated to us */
9084         sc->intr_count = num_allocated;
9085         sc->num_queues = num_allocated;
9086
9087         rid = 1; /* initial resource identifier */
9088
9089         sc->intr[0].rid = rid;
9090
9091         if ((sc->intr[0].resource =
9092              bus_alloc_resource_any(sc->dev,
9093                                     SYS_RES_IRQ,
9094                                     &sc->intr[0].rid,
9095                                     RF_ACTIVE)) == NULL) {
9096             BLOGE(sc, "Failed to map MSI[0] (rid=%d)!\n", rid);
9097             sc->intr_count = 0;
9098             sc->num_queues = 0;
9099             sc->interrupt_mode = INTR_MODE_INTX; /* try INTx next */
9100             pci_release_msi(sc->dev);
9101             break;
9102         }
9103
9104         BLOGD(sc, DBG_LOAD, "Mapped MSI[0] (rid=%d)\n", rid);
9105     } while (0);
9106
9107     do { /* try allocating INTx vector resources */
9108         if (sc->interrupt_mode != INTR_MODE_INTX) {
9109             break;
9110         }
9111
9112         BLOGD(sc, DBG_LOAD, "Requesting legacy INTx interrupt\n");
9113
9114         /* only one vector for INTx */
9115         sc->intr_count = 1;
9116         sc->num_queues = 1;
9117
9118         rid = 0; /* initial resource identifier */
9119
9120         sc->intr[0].rid = rid;
9121
9122         if ((sc->intr[0].resource =
9123              bus_alloc_resource_any(sc->dev,
9124                                     SYS_RES_IRQ,
9125                                     &sc->intr[0].rid,
9126                                     (RF_ACTIVE | RF_SHAREABLE))) == NULL) {
9127             BLOGE(sc, "Failed to map INTx (rid=%d)!\n", rid);
9128             sc->intr_count = 0;
9129             sc->num_queues = 0;
9130             sc->interrupt_mode = -1; /* Failed! */
9131             break;
9132         }
9133
9134         BLOGD(sc, DBG_LOAD, "Mapped INTx (rid=%d)\n", rid);
9135     } while (0);
9136
9137     if (sc->interrupt_mode == -1) {
9138         BLOGE(sc, "Interrupt Allocation: FAILED!!!\n");
9139         rc = 1;
9140     } else {
9141         BLOGD(sc, DBG_LOAD,
9142               "Interrupt Allocation: interrupt_mode=%d, num_queues=%d\n",
9143               sc->interrupt_mode, sc->num_queues);
9144         rc = 0;
9145     }
9146
9147     return (rc);
9148 }
9149
9150 static void
9151 bxe_interrupt_detach(struct bxe_softc *sc)
9152 {
9153     struct bxe_fastpath *fp;
9154     int i;
9155
9156     /* release interrupt resources */
9157     for (i = 0; i < sc->intr_count; i++) {
9158         if (sc->intr[i].resource && sc->intr[i].tag) {
9159             BLOGD(sc, DBG_LOAD, "Disabling interrupt vector %d\n", i);
9160             bus_teardown_intr(sc->dev, sc->intr[i].resource, sc->intr[i].tag);
9161         }
9162     }
9163
9164     for (i = 0; i < sc->num_queues; i++) {
9165         fp = &sc->fp[i];
9166         if (fp->tq) {
9167             taskqueue_drain(fp->tq, &fp->tq_task);
9168             taskqueue_free(fp->tq);
9169             fp->tq = NULL;
9170         }
9171     }
9172
9173
9174     if (sc->sp_tq) {
9175         taskqueue_drain(sc->sp_tq, &sc->sp_tq_task);
9176         taskqueue_free(sc->sp_tq);
9177         sc->sp_tq = NULL;
9178     }
9179 }
9180
9181 /*
9182  * Enables interrupts and attach to the ISR.
9183  *
9184  * When using multiple MSI/MSI-X vectors the first vector
9185  * is used for slowpath operations while all remaining
9186  * vectors are used for fastpath operations.  If only a
9187  * single MSI/MSI-X vector is used (SINGLE_ISR) then the
9188  * ISR must look for both slowpath and fastpath completions.
9189  */
9190 static int
9191 bxe_interrupt_attach(struct bxe_softc *sc)
9192 {
9193     struct bxe_fastpath *fp;
9194     int rc = 0;
9195     int i;
9196
9197     snprintf(sc->sp_tq_name, sizeof(sc->sp_tq_name),
9198              "bxe%d_sp_tq", sc->unit);
9199     TASK_INIT(&sc->sp_tq_task, 0, bxe_handle_sp_tq, sc);
9200     sc->sp_tq = taskqueue_create_fast(sc->sp_tq_name, M_NOWAIT,
9201                                       taskqueue_thread_enqueue,
9202                                       &sc->sp_tq);
9203     taskqueue_start_threads(&sc->sp_tq, 1, PWAIT, /* lower priority */
9204                             "%s", sc->sp_tq_name);
9205
9206
9207     for (i = 0; i < sc->num_queues; i++) {
9208         fp = &sc->fp[i];
9209         snprintf(fp->tq_name, sizeof(fp->tq_name),
9210                  "bxe%d_fp%d_tq", sc->unit, i);
9211         TASK_INIT(&fp->tq_task, 0, bxe_handle_fp_tq, fp);
9212         fp->tq = taskqueue_create_fast(fp->tq_name, M_NOWAIT,
9213                                        taskqueue_thread_enqueue,
9214                                        &fp->tq);
9215         taskqueue_start_threads(&fp->tq, 1, PI_NET, /* higher priority */
9216                                 "%s", fp->tq_name);
9217     }
9218
9219     /* setup interrupt handlers */
9220     if (sc->interrupt_mode == INTR_MODE_MSIX) {
9221         BLOGD(sc, DBG_LOAD, "Enabling slowpath MSI-X[0] vector\n");
9222
9223         /*
9224          * Setup the interrupt handler. Note that we pass the driver instance
9225          * to the interrupt handler for the slowpath.
9226          */
9227         if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
9228                                  (INTR_TYPE_NET | INTR_MPSAFE),
9229                                  NULL, bxe_intr_sp, sc,
9230                                  &sc->intr[0].tag)) != 0) {
9231             BLOGE(sc, "Failed to allocate MSI-X[0] vector (%d)\n", rc);
9232             goto bxe_interrupt_attach_exit;
9233         }
9234
9235         bus_describe_intr(sc->dev, sc->intr[0].resource,
9236                           sc->intr[0].tag, "sp");
9237
9238         /* bus_bind_intr(sc->dev, sc->intr[0].resource, 0); */
9239
9240         /* initialize the fastpath vectors (note the first was used for sp) */
9241         for (i = 0; i < sc->num_queues; i++) {
9242             fp = &sc->fp[i];
9243             BLOGD(sc, DBG_LOAD, "Enabling MSI-X[%d] vector\n", (i + 1));
9244
9245             /*
9246              * Setup the interrupt handler. Note that we pass the
9247              * fastpath context to the interrupt handler in this
9248              * case.
9249              */
9250             if ((rc = bus_setup_intr(sc->dev, sc->intr[i + 1].resource,
9251                                      (INTR_TYPE_NET | INTR_MPSAFE),
9252                                      NULL, bxe_intr_fp, fp,
9253                                      &sc->intr[i + 1].tag)) != 0) {
9254                 BLOGE(sc, "Failed to allocate MSI-X[%d] vector (%d)\n",
9255                       (i + 1), rc);
9256                 goto bxe_interrupt_attach_exit;
9257             }
9258
9259             bus_describe_intr(sc->dev, sc->intr[i + 1].resource,
9260                               sc->intr[i + 1].tag, "fp%02d", i);
9261
9262             /* bind the fastpath instance to a cpu */
9263             if (sc->num_queues > 1) {
9264                 bus_bind_intr(sc->dev, sc->intr[i + 1].resource, i);
9265             }
9266
9267             fp->state = BXE_FP_STATE_IRQ;
9268         }
9269     } else if (sc->interrupt_mode == INTR_MODE_MSI) {
9270         BLOGD(sc, DBG_LOAD, "Enabling MSI[0] vector\n");
9271
9272         /*
9273          * Setup the interrupt handler. Note that we pass the
9274          * driver instance to the interrupt handler which
9275          * will handle both the slowpath and fastpath.
9276          */
9277         if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
9278                                  (INTR_TYPE_NET | INTR_MPSAFE),
9279                                  NULL, bxe_intr_legacy, sc,
9280                                  &sc->intr[0].tag)) != 0) {
9281             BLOGE(sc, "Failed to allocate MSI[0] vector (%d)\n", rc);
9282             goto bxe_interrupt_attach_exit;
9283         }
9284
9285     } else { /* (sc->interrupt_mode == INTR_MODE_INTX) */
9286         BLOGD(sc, DBG_LOAD, "Enabling INTx interrupts\n");
9287
9288         /*
9289          * Setup the interrupt handler. Note that we pass the
9290          * driver instance to the interrupt handler which
9291          * will handle both the slowpath and fastpath.
9292          */
9293         if ((rc = bus_setup_intr(sc->dev, sc->intr[0].resource,
9294                                  (INTR_TYPE_NET | INTR_MPSAFE),
9295                                  NULL, bxe_intr_legacy, sc,
9296                                  &sc->intr[0].tag)) != 0) {
9297             BLOGE(sc, "Failed to allocate INTx interrupt (%d)\n", rc);
9298             goto bxe_interrupt_attach_exit;
9299         }
9300     }
9301
9302 bxe_interrupt_attach_exit:
9303
9304     return (rc);
9305 }
9306
9307 static int  bxe_init_hw_common_chip(struct bxe_softc *sc);
9308 static int  bxe_init_hw_common(struct bxe_softc *sc);
9309 static int  bxe_init_hw_port(struct bxe_softc *sc);
9310 static int  bxe_init_hw_func(struct bxe_softc *sc);
9311 static void bxe_reset_common(struct bxe_softc *sc);
9312 static void bxe_reset_port(struct bxe_softc *sc);
9313 static void bxe_reset_func(struct bxe_softc *sc);
9314 static int  bxe_gunzip_init(struct bxe_softc *sc);
9315 static void bxe_gunzip_end(struct bxe_softc *sc);
9316 static int  bxe_init_firmware(struct bxe_softc *sc);
9317 static void bxe_release_firmware(struct bxe_softc *sc);
9318
9319 static struct
9320 ecore_func_sp_drv_ops bxe_func_sp_drv = {
9321     .init_hw_cmn_chip = bxe_init_hw_common_chip,
9322     .init_hw_cmn      = bxe_init_hw_common,
9323     .init_hw_port     = bxe_init_hw_port,
9324     .init_hw_func     = bxe_init_hw_func,
9325
9326     .reset_hw_cmn     = bxe_reset_common,
9327     .reset_hw_port    = bxe_reset_port,
9328     .reset_hw_func    = bxe_reset_func,
9329
9330     .gunzip_init      = bxe_gunzip_init,
9331     .gunzip_end       = bxe_gunzip_end,
9332
9333     .init_fw          = bxe_init_firmware,
9334     .release_fw       = bxe_release_firmware,
9335 };
9336
9337 static void
9338 bxe_init_func_obj(struct bxe_softc *sc)
9339 {
9340     sc->dmae_ready = 0;
9341
9342     ecore_init_func_obj(sc,
9343                         &sc->func_obj,
9344                         BXE_SP(sc, func_rdata),
9345                         BXE_SP_MAPPING(sc, func_rdata),
9346                         BXE_SP(sc, func_afex_rdata),
9347                         BXE_SP_MAPPING(sc, func_afex_rdata),
9348                         &bxe_func_sp_drv);
9349 }
9350
9351 static int
9352 bxe_init_hw(struct bxe_softc *sc,
9353             uint32_t         load_code)
9354 {
9355     struct ecore_func_state_params func_params = { NULL };
9356     int rc;
9357
9358     /* prepare the parameters for function state transitions */
9359     bit_set(&func_params.ramrod_flags, RAMROD_COMP_WAIT);
9360
9361     func_params.f_obj = &sc->func_obj;
9362     func_params.cmd = ECORE_F_CMD_HW_INIT;
9363
9364     func_params.params.hw_init.load_phase = load_code;
9365
9366     /*
9367      * Via a plethora of function pointers, we will eventually reach
9368      * bxe_init_hw_common(), bxe_init_hw_port(), or bxe_init_hw_func().
9369      */
9370     rc = ecore_func_state_change(sc, &func_params);
9371
9372     return (rc);
9373 }
9374
9375 static void
9376 bxe_fill(struct bxe_softc *sc,
9377          uint32_t         addr,
9378          int              fill,
9379          uint32_t         len)
9380 {
9381     uint32_t i;
9382
9383     if (!(len % 4) && !(addr % 4)) {
9384         for (i = 0; i < len; i += 4) {
9385             REG_WR(sc, (addr + i), fill);
9386         }
9387     } else {
9388         for (i = 0; i < len; i++) {
9389             REG_WR8(sc, (addr + i), fill);
9390         }
9391     }
9392 }
9393
9394 /* writes FP SP data to FW - data_size in dwords */
9395 static void
9396 bxe_wr_fp_sb_data(struct bxe_softc *sc,
9397                   int              fw_sb_id,
9398                   uint32_t         *sb_data_p,
9399                   uint32_t         data_size)
9400 {
9401     int index;
9402
9403     for (index = 0; index < data_size; index++) {
9404         REG_WR(sc,
9405                (BAR_CSTRORM_INTMEM +
9406                 CSTORM_STATUS_BLOCK_DATA_OFFSET(fw_sb_id) +
9407                 (sizeof(uint32_t) * index)),
9408                *(sb_data_p + index));
9409     }
9410 }
9411
9412 static void
9413 bxe_zero_fp_sb(struct bxe_softc *sc,
9414                int              fw_sb_id)
9415 {
9416     struct hc_status_block_data_e2 sb_data_e2;
9417     struct hc_status_block_data_e1x sb_data_e1x;
9418     uint32_t *sb_data_p;
9419     uint32_t data_size = 0;
9420
9421     if (!CHIP_IS_E1x(sc)) {
9422         memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
9423         sb_data_e2.common.state = SB_DISABLED;
9424         sb_data_e2.common.p_func.vf_valid = FALSE;
9425         sb_data_p = (uint32_t *)&sb_data_e2;
9426         data_size = (sizeof(struct hc_status_block_data_e2) /
9427                      sizeof(uint32_t));
9428     } else {
9429         memset(&sb_data_e1x, 0, sizeof(struct hc_status_block_data_e1x));
9430         sb_data_e1x.common.state = SB_DISABLED;
9431         sb_data_e1x.common.p_func.vf_valid = FALSE;
9432         sb_data_p = (uint32_t *)&sb_data_e1x;
9433         data_size = (sizeof(struct hc_status_block_data_e1x) /
9434                      sizeof(uint32_t));
9435     }
9436
9437     bxe_wr_fp_sb_data(sc, fw_sb_id, sb_data_p, data_size);
9438
9439     bxe_fill(sc, (BAR_CSTRORM_INTMEM + CSTORM_STATUS_BLOCK_OFFSET(fw_sb_id)),
9440              0, CSTORM_STATUS_BLOCK_SIZE);
9441     bxe_fill(sc, (BAR_CSTRORM_INTMEM + CSTORM_SYNC_BLOCK_OFFSET(fw_sb_id)),
9442              0, CSTORM_SYNC_BLOCK_SIZE);
9443 }
9444
9445 static void
9446 bxe_wr_sp_sb_data(struct bxe_softc               *sc,
9447                   struct hc_sp_status_block_data *sp_sb_data)
9448 {
9449     int i;
9450
9451     for (i = 0;
9452          i < (sizeof(struct hc_sp_status_block_data) / sizeof(uint32_t));
9453          i++) {
9454         REG_WR(sc,
9455                (BAR_CSTRORM_INTMEM +
9456                 CSTORM_SP_STATUS_BLOCK_DATA_OFFSET(SC_FUNC(sc)) +
9457                 (i * sizeof(uint32_t))),
9458                *((uint32_t *)sp_sb_data + i));
9459     }
9460 }
9461
9462 static void
9463 bxe_zero_sp_sb(struct bxe_softc *sc)
9464 {
9465     struct hc_sp_status_block_data sp_sb_data;
9466
9467     memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
9468
9469     sp_sb_data.state           = SB_DISABLED;
9470     sp_sb_data.p_func.vf_valid = FALSE;
9471
9472     bxe_wr_sp_sb_data(sc, &sp_sb_data);
9473
9474     bxe_fill(sc,
9475              (BAR_CSTRORM_INTMEM +
9476               CSTORM_SP_STATUS_BLOCK_OFFSET(SC_FUNC(sc))),
9477               0, CSTORM_SP_STATUS_BLOCK_SIZE);
9478     bxe_fill(sc,
9479              (BAR_CSTRORM_INTMEM +
9480               CSTORM_SP_SYNC_BLOCK_OFFSET(SC_FUNC(sc))),
9481               0, CSTORM_SP_SYNC_BLOCK_SIZE);
9482 }
9483
9484 static void
9485 bxe_setup_ndsb_state_machine(struct hc_status_block_sm *hc_sm,
9486                              int                       igu_sb_id,
9487                              int                       igu_seg_id)
9488 {
9489     hc_sm->igu_sb_id      = igu_sb_id;
9490     hc_sm->igu_seg_id     = igu_seg_id;
9491     hc_sm->timer_value    = 0xFF;
9492     hc_sm->time_to_expire = 0xFFFFFFFF;
9493 }
9494
9495 static void
9496 bxe_map_sb_state_machines(struct hc_index_data *index_data)
9497 {
9498     /* zero out state machine indices */
9499
9500     /* rx indices */
9501     index_data[HC_INDEX_ETH_RX_CQ_CONS].flags &= ~HC_INDEX_DATA_SM_ID;
9502
9503     /* tx indices */
9504     index_data[HC_INDEX_OOO_TX_CQ_CONS].flags      &= ~HC_INDEX_DATA_SM_ID;
9505     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS0].flags &= ~HC_INDEX_DATA_SM_ID;
9506     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS1].flags &= ~HC_INDEX_DATA_SM_ID;
9507     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS2].flags &= ~HC_INDEX_DATA_SM_ID;
9508
9509     /* map indices */
9510
9511     /* rx indices */
9512     index_data[HC_INDEX_ETH_RX_CQ_CONS].flags |=
9513         (SM_RX_ID << HC_INDEX_DATA_SM_ID_SHIFT);
9514
9515     /* tx indices */
9516     index_data[HC_INDEX_OOO_TX_CQ_CONS].flags |=
9517         (SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT);
9518     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS0].flags |=
9519         (SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT);
9520     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS1].flags |=
9521         (SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT);
9522     index_data[HC_INDEX_ETH_TX_CQ_CONS_COS2].flags |=
9523         (SM_TX_ID << HC_INDEX_DATA_SM_ID_SHIFT);
9524 }
9525
9526 static void
9527 bxe_init_sb(struct bxe_softc *sc,
9528             bus_addr_t       busaddr,
9529             int              vfid,
9530             uint8_t          vf_valid,
9531             int              fw_sb_id,
9532             int              igu_sb_id)
9533 {
9534     struct hc_status_block_data_e2  sb_data_e2;
9535     struct hc_status_block_data_e1x sb_data_e1x;
9536     struct hc_status_block_sm       *hc_sm_p;
9537     uint32_t *sb_data_p;
9538     int igu_seg_id;
9539     int data_size;
9540
9541     if (CHIP_INT_MODE_IS_BC(sc)) {
9542         igu_seg_id = HC_SEG_ACCESS_NORM;
9543     } else {
9544         igu_seg_id = IGU_SEG_ACCESS_NORM;
9545     }
9546
9547     bxe_zero_fp_sb(sc, fw_sb_id);
9548
9549     if (!CHIP_IS_E1x(sc)) {
9550         memset(&sb_data_e2, 0, sizeof(struct hc_status_block_data_e2));
9551         sb_data_e2.common.state = SB_ENABLED;
9552         sb_data_e2.common.p_func.pf_id = SC_FUNC(sc);
9553         sb_data_e2.common.p_func.vf_id = vfid;
9554         sb_data_e2.common.p_func.vf_valid = vf_valid;
9555         sb_data_e2.common.p_func.vnic_id = SC_VN(sc);
9556         sb_data_e2.common.same_igu_sb_1b = TRUE;
9557         sb_data_e2.common.host_sb_addr.hi = U64_HI(busaddr);
9558         sb_data_e2.common.host_sb_addr.lo = U64_LO(busaddr);
9559         hc_sm_p = sb_data_e2.common.state_machine;
9560         sb_data_p = (uint32_t *)&sb_data_e2;
9561         data_size = (sizeof(struct hc_status_block_data_e2) /
9562                      sizeof(uint32_t));
9563         bxe_map_sb_state_machines(sb_data_e2.index_data);
9564     } else {
9565         memset(&sb_data_e1x, 0, sizeof(struct hc_status_block_data_e1x));
9566         sb_data_e1x.common.state = SB_ENABLED;
9567         sb_data_e1x.common.p_func.pf_id = SC_FUNC(sc);
9568         sb_data_e1x.common.p_func.vf_id = 0xff;
9569         sb_data_e1x.common.p_func.vf_valid = FALSE;
9570         sb_data_e1x.common.p_func.vnic_id = SC_VN(sc);
9571         sb_data_e1x.common.same_igu_sb_1b = TRUE;
9572         sb_data_e1x.common.host_sb_addr.hi = U64_HI(busaddr);
9573         sb_data_e1x.common.host_sb_addr.lo = U64_LO(busaddr);
9574         hc_sm_p = sb_data_e1x.common.state_machine;
9575         sb_data_p = (uint32_t *)&sb_data_e1x;
9576         data_size = (sizeof(struct hc_status_block_data_e1x) /
9577                      sizeof(uint32_t));
9578         bxe_map_sb_state_machines(sb_data_e1x.index_data);
9579     }
9580
9581     bxe_setup_ndsb_state_machine(&hc_sm_p[SM_RX_ID], igu_sb_id, igu_seg_id);
9582     bxe_setup_ndsb_state_machine(&hc_sm_p[SM_TX_ID], igu_sb_id, igu_seg_id);
9583
9584     BLOGD(sc, DBG_LOAD, "Init FW SB %d\n", fw_sb_id);
9585
9586     /* write indices to HW - PCI guarantees endianity of regpairs */
9587     bxe_wr_fp_sb_data(sc, fw_sb_id, sb_data_p, data_size);
9588 }
9589
9590 static inline uint8_t
9591 bxe_fp_qzone_id(struct bxe_fastpath *fp)
9592 {
9593     if (CHIP_IS_E1x(fp->sc)) {
9594         return (fp->cl_id + SC_PORT(fp->sc) * ETH_MAX_RX_CLIENTS_E1H);
9595     } else {
9596         return (fp->cl_id);
9597     }
9598 }
9599
9600 static inline uint32_t
9601 bxe_rx_ustorm_prods_offset(struct bxe_softc    *sc,
9602                            struct bxe_fastpath *fp)
9603 {
9604     uint32_t offset = BAR_USTRORM_INTMEM;
9605
9606     if (!CHIP_IS_E1x(sc)) {
9607         offset += USTORM_RX_PRODS_E2_OFFSET(fp->cl_qzone_id);
9608     } else {
9609         offset += USTORM_RX_PRODS_E1X_OFFSET(SC_PORT(sc), fp->cl_id);
9610     }
9611
9612     return (offset);
9613 }
9614
9615 static void
9616 bxe_init_eth_fp(struct bxe_softc *sc,
9617                 int              idx)
9618 {
9619     struct bxe_fastpath *fp = &sc->fp[idx];
9620     uint32_t cids[ECORE_MULTI_TX_COS] = { 0 };
9621     unsigned long q_type = 0;
9622     int cos;
9623
9624     fp->sc    = sc;
9625     fp->index = idx;
9626
9627     fp->igu_sb_id = (sc->igu_base_sb + idx + CNIC_SUPPORT(sc));
9628     fp->fw_sb_id = (sc->base_fw_ndsb + idx + CNIC_SUPPORT(sc));
9629
9630     fp->cl_id = (CHIP_IS_E1x(sc)) ?
9631                     (SC_L_ID(sc) + idx) :
9632                     /* want client ID same as IGU SB ID for non-E1 */
9633                     fp->igu_sb_id;
9634     fp->cl_qzone_id = bxe_fp_qzone_id(fp);
9635
9636     /* setup sb indices */
9637     if (!CHIP_IS_E1x(sc)) {
9638         fp->sb_index_values  = fp->status_block.e2_sb->sb.index_values;
9639         fp->sb_running_index = fp->status_block.e2_sb->sb.running_index;
9640     } else {
9641         fp->sb_index_values  = fp->status_block.e1x_sb->sb.index_values;
9642         fp->sb_running_index = fp->status_block.e1x_sb->sb.running_index;
9643     }
9644
9645     /* init shortcut */
9646     fp->ustorm_rx_prods_offset = bxe_rx_ustorm_prods_offset(sc, fp);
9647
9648     fp->rx_cq_cons_sb = &fp->sb_index_values[HC_INDEX_ETH_RX_CQ_CONS];
9649
9650     /*
9651      * XXX If multiple CoS is ever supported then each fastpath structure
9652      * will need to maintain tx producer/consumer/dma/etc values *per* CoS.
9653      */
9654     for (cos = 0; cos < sc->max_cos; cos++) {
9655         cids[cos] = idx;
9656     }
9657     fp->tx_cons_sb = &fp->sb_index_values[HC_INDEX_ETH_TX_CQ_CONS_COS0];
9658
9659     /* nothing more for a VF to do */
9660     if (IS_VF(sc)) {
9661         return;
9662     }
9663
9664     bxe_init_sb(sc, fp->sb_dma.paddr, BXE_VF_ID_INVALID, FALSE,
9665                 fp->fw_sb_id, fp->igu_sb_id);
9666
9667     bxe_update_fp_sb_idx(fp);
9668
9669     /* Configure Queue State object */
9670     bit_set(&q_type, ECORE_Q_TYPE_HAS_RX);
9671     bit_set(&q_type, ECORE_Q_TYPE_HAS_TX);
9672
9673     ecore_init_queue_obj(sc,
9674                          &sc->sp_objs[idx].q_obj,
9675                          fp->cl_id,
9676                          cids,
9677                          sc->max_cos,
9678                          SC_FUNC(sc),
9679                          BXE_SP(sc, q_rdata),
9680                          BXE_SP_MAPPING(sc, q_rdata),
9681                          q_type);
9682
9683     /* configure classification DBs */
9684     ecore_init_mac_obj(sc,
9685                        &sc->sp_objs[idx].mac_obj,
9686                        fp->cl_id,
9687                        idx,
9688                        SC_FUNC(sc),
9689                        BXE_SP(sc, mac_rdata),
9690                        BXE_SP_MAPPING(sc, mac_rdata),
9691                        ECORE_FILTER_MAC_PENDING,
9692                        &sc->sp_state,
9693                        ECORE_OBJ_TYPE_RX_TX,
9694                        &sc->macs_pool);
9695
9696     BLOGD(sc, DBG_LOAD, "fp[%d]: sb=%p cl_id=%d fw_sb=%d igu_sb=%d\n",
9697           idx, fp->status_block.e2_sb, fp->cl_id, fp->fw_sb_id, fp->igu_sb_id);
9698 }
9699
9700 static inline void
9701 bxe_update_rx_prod(struct bxe_softc    *sc,
9702                    struct bxe_fastpath *fp,
9703                    uint16_t            rx_bd_prod,
9704                    uint16_t            rx_cq_prod,
9705                    uint16_t            rx_sge_prod)
9706 {
9707     struct ustorm_eth_rx_producers rx_prods = { 0 };
9708     uint32_t i;
9709
9710     /* update producers */
9711     rx_prods.bd_prod  = rx_bd_prod;
9712     rx_prods.cqe_prod = rx_cq_prod;
9713     rx_prods.sge_prod = rx_sge_prod;
9714
9715     /*
9716      * Make sure that the BD and SGE data is updated before updating the
9717      * producers since FW might read the BD/SGE right after the producer
9718      * is updated.
9719      * This is only applicable for weak-ordered memory model archs such
9720      * as IA-64. The following barrier is also mandatory since FW will
9721      * assumes BDs must have buffers.
9722      */
9723     wmb();
9724
9725     for (i = 0; i < (sizeof(rx_prods) / 4); i++) {
9726         REG_WR(sc,
9727                (fp->ustorm_rx_prods_offset + (i * 4)),
9728                ((uint32_t *)&rx_prods)[i]);
9729     }
9730
9731     wmb(); /* keep prod updates ordered */
9732
9733     BLOGD(sc, DBG_RX,
9734           "RX fp[%d]: wrote prods bd_prod=%u cqe_prod=%u sge_prod=%u\n",
9735           fp->index, rx_bd_prod, rx_cq_prod, rx_sge_prod);
9736 }
9737
9738 static void
9739 bxe_init_rx_rings(struct bxe_softc *sc)
9740 {
9741     struct bxe_fastpath *fp;
9742     int i;
9743
9744     for (i = 0; i < sc->num_queues; i++) {
9745         fp = &sc->fp[i];
9746
9747         fp->rx_bd_cons = 0;
9748
9749         /*
9750          * Activate the BD ring...
9751          * Warning, this will generate an interrupt (to the TSTORM)
9752          * so this can only be done after the chip is initialized
9753          */
9754         bxe_update_rx_prod(sc, fp,
9755                            fp->rx_bd_prod,
9756                            fp->rx_cq_prod,
9757                            fp->rx_sge_prod);
9758
9759         if (i != 0) {
9760             continue;
9761         }
9762
9763         if (CHIP_IS_E1(sc)) {
9764             REG_WR(sc,
9765                    (BAR_USTRORM_INTMEM +
9766                     USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(SC_FUNC(sc))),
9767                    U64_LO(fp->rcq_dma.paddr));
9768             REG_WR(sc,
9769                    (BAR_USTRORM_INTMEM +
9770                     USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(SC_FUNC(sc)) + 4),
9771                    U64_HI(fp->rcq_dma.paddr));
9772         }
9773     }
9774 }
9775
9776 static void
9777 bxe_init_tx_ring_one(struct bxe_fastpath *fp)
9778 {
9779     SET_FLAG(fp->tx_db.data.header.data, DOORBELL_HDR_T_DB_TYPE, 1);
9780     fp->tx_db.data.zero_fill1 = 0;
9781     fp->tx_db.data.prod = 0;
9782
9783     fp->tx_pkt_prod = 0;
9784     fp->tx_pkt_cons = 0;
9785     fp->tx_bd_prod = 0;
9786     fp->tx_bd_cons = 0;
9787     fp->eth_q_stats.tx_pkts = 0;
9788 }
9789
9790 static inline void
9791 bxe_init_tx_rings(struct bxe_softc *sc)
9792 {
9793     int i;
9794
9795     for (i = 0; i < sc->num_queues; i++) {
9796         bxe_init_tx_ring_one(&sc->fp[i]);
9797     }
9798 }
9799
9800 static void
9801 bxe_init_def_sb(struct bxe_softc *sc)
9802 {
9803     struct host_sp_status_block *def_sb = sc->def_sb;
9804     bus_addr_t mapping = sc->def_sb_dma.paddr;
9805     int igu_sp_sb_index;
9806     int igu_seg_id;
9807     int port = SC_PORT(sc);
9808     int func = SC_FUNC(sc);
9809     int reg_offset, reg_offset_en5;
9810     uint64_t section;
9811     int index, sindex;
9812     struct hc_sp_status_block_data sp_sb_data;
9813
9814     memset(&sp_sb_data, 0, sizeof(struct hc_sp_status_block_data));
9815
9816     if (CHIP_INT_MODE_IS_BC(sc)) {
9817         igu_sp_sb_index = DEF_SB_IGU_ID;
9818         igu_seg_id = HC_SEG_ACCESS_DEF;
9819     } else {
9820         igu_sp_sb_index = sc->igu_dsb_id;
9821         igu_seg_id = IGU_SEG_ACCESS_DEF;
9822     }
9823
9824     /* attentions */
9825     section = ((uint64_t)mapping +
9826                offsetof(struct host_sp_status_block, atten_status_block));
9827     def_sb->atten_status_block.status_block_id = igu_sp_sb_index;
9828     sc->attn_state = 0;
9829
9830     reg_offset = (port) ?
9831                      MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
9832                      MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0;
9833     reg_offset_en5 = (port) ?
9834                          MISC_REG_AEU_ENABLE5_FUNC_1_OUT_0 :
9835                          MISC_REG_AEU_ENABLE5_FUNC_0_OUT_0;
9836
9837     for (index = 0; index < MAX_DYNAMIC_ATTN_GRPS; index++) {
9838         /* take care of sig[0]..sig[4] */
9839         for (sindex = 0; sindex < 4; sindex++) {
9840             sc->attn_group[index].sig[sindex] =
9841                 REG_RD(sc, (reg_offset + (sindex * 0x4) + (0x10 * index)));
9842         }
9843
9844         if (!CHIP_IS_E1x(sc)) {
9845             /*
9846              * enable5 is separate from the rest of the registers,
9847              * and the address skip is 4 and not 16 between the
9848              * different groups
9849              */
9850             sc->attn_group[index].sig[4] =
9851                 REG_RD(sc, (reg_offset_en5 + (0x4 * index)));
9852         } else {
9853             sc->attn_group[index].sig[4] = 0;
9854         }
9855     }
9856
9857     if (sc->devinfo.int_block == INT_BLOCK_HC) {
9858         reg_offset = (port) ?
9859                          HC_REG_ATTN_MSG1_ADDR_L :
9860                          HC_REG_ATTN_MSG0_ADDR_L;
9861         REG_WR(sc, reg_offset, U64_LO(section));
9862         REG_WR(sc, (reg_offset + 4), U64_HI(section));
9863     } else if (!CHIP_IS_E1x(sc)) {
9864         REG_WR(sc, IGU_REG_ATTN_MSG_ADDR_L, U64_LO(section));
9865         REG_WR(sc, IGU_REG_ATTN_MSG_ADDR_H, U64_HI(section));
9866     }
9867
9868     section = ((uint64_t)mapping +
9869                offsetof(struct host_sp_status_block, sp_sb));
9870
9871     bxe_zero_sp_sb(sc);
9872
9873     /* PCI guarantees endianity of regpair */
9874     sp_sb_data.state           = SB_ENABLED;
9875     sp_sb_data.host_sb_addr.lo = U64_LO(section);
9876     sp_sb_data.host_sb_addr.hi = U64_HI(section);
9877     sp_sb_data.igu_sb_id       = igu_sp_sb_index;
9878     sp_sb_data.igu_seg_id      = igu_seg_id;
9879     sp_sb_data.p_func.pf_id    = func;
9880     sp_sb_data.p_func.vnic_id  = SC_VN(sc);
9881     sp_sb_data.p_func.vf_id    = 0xff;
9882
9883     bxe_wr_sp_sb_data(sc, &sp_sb_data);
9884
9885     bxe_ack_sb(sc, sc->igu_dsb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
9886 }
9887
9888 static void
9889 bxe_init_sp_ring(struct bxe_softc *sc)
9890 {
9891     atomic_store_rel_long(&sc->cq_spq_left, MAX_SPQ_PENDING);
9892     sc->spq_prod_idx = 0;
9893     sc->dsb_sp_prod = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_ETH_DEF_CONS];
9894     sc->spq_prod_bd = sc->spq;
9895     sc->spq_last_bd = (sc->spq_prod_bd + MAX_SP_DESC_CNT);
9896 }
9897
9898 static void
9899 bxe_init_eq_ring(struct bxe_softc *sc)
9900 {
9901     union event_ring_elem *elem;
9902     int i;
9903
9904     for (i = 1; i <= NUM_EQ_PAGES; i++) {
9905         elem = &sc->eq[EQ_DESC_CNT_PAGE * i - 1];
9906
9907         elem->next_page.addr.hi = htole32(U64_HI(sc->eq_dma.paddr +
9908                                                  BCM_PAGE_SIZE *
9909                                                  (i % NUM_EQ_PAGES)));
9910         elem->next_page.addr.lo = htole32(U64_LO(sc->eq_dma.paddr +
9911                                                  BCM_PAGE_SIZE *
9912                                                  (i % NUM_EQ_PAGES)));
9913     }
9914
9915     sc->eq_cons    = 0;
9916     sc->eq_prod    = NUM_EQ_DESC;
9917     sc->eq_cons_sb = &sc->def_sb->sp_sb.index_values[HC_SP_INDEX_EQ_CONS];
9918
9919     atomic_store_rel_long(&sc->eq_spq_left,
9920                           (min((MAX_SP_DESC_CNT - MAX_SPQ_PENDING),
9921                                NUM_EQ_DESC) - 1));
9922 }
9923
9924 static void
9925 bxe_init_internal_common(struct bxe_softc *sc)
9926 {
9927     int i;
9928
9929     if (IS_MF_SI(sc)) {
9930         /*
9931          * In switch independent mode, the TSTORM needs to accept
9932          * packets that failed classification, since approximate match
9933          * mac addresses aren't written to NIG LLH.
9934          */
9935         REG_WR8(sc,
9936                 (BAR_TSTRORM_INTMEM + TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET),
9937                 2);
9938     } else if (!CHIP_IS_E1(sc)) { /* 57710 doesn't support MF */
9939         REG_WR8(sc,
9940                 (BAR_TSTRORM_INTMEM + TSTORM_ACCEPT_CLASSIFY_FAILED_OFFSET),
9941                 0);
9942     }
9943
9944     /*
9945      * Zero this manually as its initialization is currently missing
9946      * in the initTool.
9947      */
9948     for (i = 0; i < (USTORM_AGG_DATA_SIZE >> 2); i++) {
9949         REG_WR(sc,
9950                (BAR_USTRORM_INTMEM + USTORM_AGG_DATA_OFFSET + (i * 4)),
9951                0);
9952     }
9953
9954     if (!CHIP_IS_E1x(sc)) {
9955         REG_WR8(sc, (BAR_CSTRORM_INTMEM + CSTORM_IGU_MODE_OFFSET),
9956                 CHIP_INT_MODE_IS_BC(sc) ? HC_IGU_BC_MODE : HC_IGU_NBC_MODE);
9957     }
9958 }
9959
9960 static void
9961 bxe_init_internal(struct bxe_softc *sc,
9962                   uint32_t         load_code)
9963 {
9964     switch (load_code) {
9965     case FW_MSG_CODE_DRV_LOAD_COMMON:
9966     case FW_MSG_CODE_DRV_LOAD_COMMON_CHIP:
9967         bxe_init_internal_common(sc);
9968         /* no break */
9969
9970     case FW_MSG_CODE_DRV_LOAD_PORT:
9971         /* nothing to do */
9972         /* no break */
9973
9974     case FW_MSG_CODE_DRV_LOAD_FUNCTION:
9975         /* internal memory per function is initialized inside bxe_pf_init */
9976         break;
9977
9978     default:
9979         BLOGE(sc, "Unknown load_code (0x%x) from MCP\n", load_code);
9980         break;
9981     }
9982 }
9983
9984 static void
9985 storm_memset_func_cfg(struct bxe_softc                         *sc,
9986                       struct tstorm_eth_function_common_config *tcfg,
9987                       uint16_t                                  abs_fid)
9988 {
9989     uint32_t addr;
9990     size_t size;
9991
9992     addr = (BAR_TSTRORM_INTMEM +
9993             TSTORM_FUNCTION_COMMON_CONFIG_OFFSET(abs_fid));
9994     size = sizeof(struct tstorm_eth_function_common_config);
9995     ecore_storm_memset_struct(sc, addr, size, (uint32_t *)tcfg);
9996 }
9997
9998 static void
9999 bxe_func_init(struct bxe_softc            *sc,
10000               struct bxe_func_init_params *p)
10001 {
10002     struct tstorm_eth_function_common_config tcfg = { 0 };
10003
10004     if (CHIP_IS_E1x(sc)) {
10005         storm_memset_func_cfg(sc, &tcfg, p->func_id);
10006     }
10007
10008     /* Enable the function in the FW */
10009     storm_memset_vf_to_pf(sc, p->func_id, p->pf_id);
10010     storm_memset_func_en(sc, p->func_id, 1);
10011
10012     /* spq */
10013     if (p->func_flgs & FUNC_FLG_SPQ) {
10014         storm_memset_spq_addr(sc, p->spq_map, p->func_id);
10015         REG_WR(sc,
10016                (XSEM_REG_FAST_MEMORY + XSTORM_SPQ_PROD_OFFSET(p->func_id)),
10017                p->spq_prod);
10018     }
10019 }
10020
10021 /*
10022  * Calculates the sum of vn_min_rates.
10023  * It's needed for further normalizing of the min_rates.
10024  * Returns:
10025  *   sum of vn_min_rates.
10026  *     or
10027  *   0 - if all the min_rates are 0.
10028  * In the later case fainess algorithm should be deactivated.
10029  * If all min rates are not zero then those that are zeroes will be set to 1.
10030  */
10031 static void
10032 bxe_calc_vn_min(struct bxe_softc       *sc,
10033                 struct cmng_init_input *input)
10034 {
10035     uint32_t vn_cfg;
10036     uint32_t vn_min_rate;
10037     int all_zero = 1;
10038     int vn;
10039
10040     for (vn = VN_0; vn < SC_MAX_VN_NUM(sc); vn++) {
10041         vn_cfg = sc->devinfo.mf_info.mf_config[vn];
10042         vn_min_rate = (((vn_cfg & FUNC_MF_CFG_MIN_BW_MASK) >>
10043                         FUNC_MF_CFG_MIN_BW_SHIFT) * 100);
10044
10045         if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
10046             /* skip hidden VNs */
10047             vn_min_rate = 0;
10048         } else if (!vn_min_rate) {
10049             /* If min rate is zero - set it to 100 */
10050             vn_min_rate = DEF_MIN_RATE;
10051         } else {
10052             all_zero = 0;
10053         }
10054
10055         input->vnic_min_rate[vn] = vn_min_rate;
10056     }
10057
10058     /* if ETS or all min rates are zeros - disable fairness */
10059     if (BXE_IS_ETS_ENABLED(sc)) {
10060         input->flags.cmng_enables &= ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
10061         BLOGD(sc, DBG_LOAD, "Fairness disabled (ETS)\n");
10062     } else if (all_zero) {
10063         input->flags.cmng_enables &= ~CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
10064         BLOGD(sc, DBG_LOAD,
10065               "Fariness disabled (all MIN values are zeroes)\n");
10066     } else {
10067         input->flags.cmng_enables |= CMNG_FLAGS_PER_PORT_FAIRNESS_VN;
10068     }
10069 }
10070
10071 static inline uint16_t
10072 bxe_extract_max_cfg(struct bxe_softc *sc,
10073                     uint32_t         mf_cfg)
10074 {
10075     uint16_t max_cfg = ((mf_cfg & FUNC_MF_CFG_MAX_BW_MASK) >>
10076                         FUNC_MF_CFG_MAX_BW_SHIFT);
10077
10078     if (!max_cfg) {
10079         BLOGD(sc, DBG_LOAD, "Max BW configured to 0 - using 100 instead\n");
10080         max_cfg = 100;
10081     }
10082
10083     return (max_cfg);
10084 }
10085
10086 static void
10087 bxe_calc_vn_max(struct bxe_softc       *sc,
10088                 int                    vn,
10089                 struct cmng_init_input *input)
10090 {
10091     uint16_t vn_max_rate;
10092     uint32_t vn_cfg = sc->devinfo.mf_info.mf_config[vn];
10093     uint32_t max_cfg;
10094
10095     if (vn_cfg & FUNC_MF_CFG_FUNC_HIDE) {
10096         vn_max_rate = 0;
10097     } else {
10098         max_cfg = bxe_extract_max_cfg(sc, vn_cfg);
10099
10100         if (IS_MF_SI(sc)) {
10101             /* max_cfg in percents of linkspeed */
10102             vn_max_rate = ((sc->link_vars.line_speed * max_cfg) / 100);
10103         } else { /* SD modes */
10104             /* max_cfg is absolute in 100Mb units */
10105             vn_max_rate = (max_cfg * 100);
10106         }
10107     }
10108
10109     BLOGD(sc, DBG_LOAD, "vn %d: vn_max_rate %d\n", vn, vn_max_rate);
10110
10111     input->vnic_max_rate[vn] = vn_max_rate;
10112 }
10113
10114 static void
10115 bxe_cmng_fns_init(struct bxe_softc *sc,
10116                   uint8_t          read_cfg,
10117                   uint8_t          cmng_type)
10118 {
10119     struct cmng_init_input input;
10120     int vn;
10121
10122     memset(&input, 0, sizeof(struct cmng_init_input));
10123
10124     input.port_rate = sc->link_vars.line_speed;
10125
10126     if (cmng_type == CMNG_FNS_MINMAX) {
10127         /* read mf conf from shmem */
10128         if (read_cfg) {
10129             bxe_read_mf_cfg(sc);
10130         }
10131
10132         /* get VN min rate and enable fairness if not 0 */
10133         bxe_calc_vn_min(sc, &input);
10134
10135         /* get VN max rate */
10136         if (sc->port.pmf) {
10137             for (vn = VN_0; vn < SC_MAX_VN_NUM(sc); vn++) {
10138                 bxe_calc_vn_max(sc, vn, &input);
10139             }
10140         }
10141
10142         /* always enable rate shaping and fairness */
10143         input.flags.cmng_enables |= CMNG_FLAGS_PER_PORT_RATE_SHAPING_VN;
10144
10145         ecore_init_cmng(&input, &sc->cmng);
10146         return;
10147     }
10148
10149     /* rate shaping and fairness are disabled */
10150     BLOGD(sc, DBG_LOAD, "rate shaping and fairness have been disabled\n");
10151 }
10152
10153 static int
10154 bxe_get_cmng_fns_mode(struct bxe_softc *sc)
10155 {
10156     if (CHIP_REV_IS_SLOW(sc)) {
10157         return (CMNG_FNS_NONE);
10158     }
10159
10160     if (IS_MF(sc)) {
10161         return (CMNG_FNS_MINMAX);
10162     }
10163
10164     return (CMNG_FNS_NONE);
10165 }
10166
10167 static void
10168 storm_memset_cmng(struct bxe_softc *sc,
10169                   struct cmng_init *cmng,
10170                   uint8_t          port)
10171 {
10172     int vn;
10173     int func;
10174     uint32_t addr;
10175     size_t size;
10176
10177     addr = (BAR_XSTRORM_INTMEM +
10178             XSTORM_CMNG_PER_PORT_VARS_OFFSET(port));
10179     size = sizeof(struct cmng_struct_per_port);
10180     ecore_storm_memset_struct(sc, addr, size, (uint32_t *)&cmng->port);
10181
10182     for (vn = VN_0; vn < SC_MAX_VN_NUM(sc); vn++) {
10183         func = func_by_vn(sc, vn);
10184
10185         addr = (BAR_XSTRORM_INTMEM +
10186                 XSTORM_RATE_SHAPING_PER_VN_VARS_OFFSET(func));
10187         size = sizeof(struct rate_shaping_vars_per_vn);
10188         ecore_storm_memset_struct(sc, addr, size,
10189                                   (uint32_t *)&cmng->vnic.vnic_max_rate[vn]);
10190
10191         addr = (BAR_XSTRORM_INTMEM +
10192                 XSTORM_FAIRNESS_PER_VN_VARS_OFFSET(func));
10193         size = sizeof(struct fairness_vars_per_vn);
10194         ecore_storm_memset_struct(sc, addr, size,
10195                                   (uint32_t *)&cmng->vnic.vnic_min_rate[vn]);
10196     }
10197 }
10198
10199 static void
10200 bxe_pf_init(struct bxe_softc *sc)
10201 {
10202     struct bxe_func_init_params func_init = { 0 };
10203     struct event_ring_data eq_data = { { 0 } };
10204     uint16_t flags;
10205
10206     if (!CHIP_IS_E1x(sc)) {
10207         /* reset IGU PF statistics: MSIX + ATTN */
10208         /* PF */
10209         REG_WR(sc,
10210                (IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
10211                 (BXE_IGU_STAS_MSG_VF_CNT * 4) +
10212                 ((CHIP_IS_MODE_4_PORT(sc) ? SC_FUNC(sc) : SC_VN(sc)) * 4)),
10213                0);
10214         /* ATTN */
10215         REG_WR(sc,
10216                (IGU_REG_STATISTIC_NUM_MESSAGE_SENT +
10217                 (BXE_IGU_STAS_MSG_VF_CNT * 4) +
10218                 (BXE_IGU_STAS_MSG_PF_CNT * 4) +
10219                 ((CHIP_IS_MODE_4_PORT(sc) ? SC_FUNC(sc) : SC_VN(sc)) * 4)),
10220                0);
10221     }
10222
10223     /* function setup flags */
10224     flags = (FUNC_FLG_STATS | FUNC_FLG_LEADING | FUNC_FLG_SPQ);
10225
10226     /*
10227      * This flag is relevant for E1x only.
10228      * E2 doesn't have a TPA configuration in a function level.
10229      */
10230     flags |= (sc->ifnet->if_capenable & IFCAP_LRO) ? FUNC_FLG_TPA : 0;
10231
10232     func_init.func_flgs = flags;
10233     func_init.pf_id     = SC_FUNC(sc);
10234     func_init.func_id   = SC_FUNC(sc);
10235     func_init.spq_map   = sc->spq_dma.paddr;
10236     func_init.spq_prod  = sc->spq_prod_idx;
10237
10238     bxe_func_init(sc, &func_init);
10239
10240     memset(&sc->cmng, 0, sizeof(struct cmng_struct_per_port));
10241
10242     /*
10243      * Congestion management values depend on the link rate.
10244      * There is no active link so initial link rate is set to 10Gbps.
10245      * When the link comes up the congestion management values are
10246      * re-calculated according to the actual link rate.
10247      */
10248     sc->link_vars.line_speed = SPEED_10000;
10249     bxe_cmng_fns_init(sc, TRUE, bxe_get_cmng_fns_mode(sc));
10250
10251     /* Only the PMF sets the HW */
10252     if (sc->port.pmf) {
10253         storm_memset_cmng(sc, &sc->cmng, SC_PORT(sc));
10254     }
10255
10256     /* init Event Queue - PCI bus guarantees correct endainity */
10257     eq_data.base_addr.hi = U64_HI(sc->eq_dma.paddr);
10258     eq_data.base_addr.lo = U64_LO(sc->eq_dma.paddr);
10259     eq_data.producer     = sc->eq_prod;
10260     eq_data.index_id     = HC_SP_INDEX_EQ_CONS;
10261     eq_data.sb_id        = DEF_SB_ID;
10262     storm_memset_eq_data(sc, &eq_data, SC_FUNC(sc));
10263 }
10264
10265 static void
10266 bxe_hc_int_enable(struct bxe_softc *sc)
10267 {
10268     int port = SC_PORT(sc);
10269     uint32_t addr = (port) ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
10270     uint32_t val = REG_RD(sc, addr);
10271     uint8_t msix = (sc->interrupt_mode == INTR_MODE_MSIX) ? TRUE : FALSE;
10272     uint8_t single_msix = ((sc->interrupt_mode == INTR_MODE_MSIX) &&
10273                            (sc->intr_count == 1)) ? TRUE : FALSE;
10274     uint8_t msi = (sc->interrupt_mode == INTR_MODE_MSI) ? TRUE : FALSE;
10275
10276     if (msix) {
10277         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
10278                  HC_CONFIG_0_REG_INT_LINE_EN_0);
10279         val |= (HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
10280                 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
10281         if (single_msix) {
10282             val |= HC_CONFIG_0_REG_SINGLE_ISR_EN_0;
10283         }
10284     } else if (msi) {
10285         val &= ~HC_CONFIG_0_REG_INT_LINE_EN_0;
10286         val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
10287                 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
10288                 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
10289     } else {
10290         val |= (HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
10291                 HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
10292                 HC_CONFIG_0_REG_INT_LINE_EN_0 |
10293                 HC_CONFIG_0_REG_ATTN_BIT_EN_0);
10294
10295         if (!CHIP_IS_E1(sc)) {
10296             BLOGD(sc, DBG_INTR, "write %x to HC %d (addr 0x%x)\n",
10297                   val, port, addr);
10298
10299             REG_WR(sc, addr, val);
10300
10301             val &= ~HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0;
10302         }
10303     }
10304
10305     if (CHIP_IS_E1(sc)) {
10306         REG_WR(sc, (HC_REG_INT_MASK + port*4), 0x1FFFF);
10307     }
10308
10309     BLOGD(sc, DBG_INTR, "write %x to HC %d (addr 0x%x) mode %s\n",
10310           val, port, addr, ((msix) ? "MSI-X" : ((msi) ? "MSI" : "INTx")));
10311
10312     REG_WR(sc, addr, val);
10313
10314     /* ensure that HC_CONFIG is written before leading/trailing edge config */
10315     mb();
10316
10317     if (!CHIP_IS_E1(sc)) {
10318         /* init leading/trailing edge */
10319         if (IS_MF(sc)) {
10320             val = (0xee0f | (1 << (SC_VN(sc) + 4)));
10321             if (sc->port.pmf) {
10322                 /* enable nig and gpio3 attention */
10323                 val |= 0x1100;
10324             }
10325         } else {
10326             val = 0xffff;
10327         }
10328
10329         REG_WR(sc, (HC_REG_TRAILING_EDGE_0 + port*8), val);
10330         REG_WR(sc, (HC_REG_LEADING_EDGE_0 + port*8), val);
10331     }
10332
10333     /* make sure that interrupts are indeed enabled from here on */
10334     mb();
10335 }
10336
10337 static void
10338 bxe_igu_int_enable(struct bxe_softc *sc)
10339 {
10340     uint32_t val;
10341     uint8_t msix = (sc->interrupt_mode == INTR_MODE_MSIX) ? TRUE : FALSE;
10342     uint8_t single_msix = ((sc->interrupt_mode == INTR_MODE_MSIX) &&
10343                            (sc->intr_count == 1)) ? TRUE : FALSE;
10344     uint8_t msi = (sc->interrupt_mode == INTR_MODE_MSI) ? TRUE : FALSE;
10345
10346     val = REG_RD(sc, IGU_REG_PF_CONFIGURATION);
10347
10348     if (msix) {
10349         val &= ~(IGU_PF_CONF_INT_LINE_EN |
10350                  IGU_PF_CONF_SINGLE_ISR_EN);
10351         val |= (IGU_PF_CONF_MSI_MSIX_EN |
10352                 IGU_PF_CONF_ATTN_BIT_EN);
10353         if (single_msix) {
10354             val |= IGU_PF_CONF_SINGLE_ISR_EN;
10355         }
10356     } else if (msi) {
10357         val &= ~IGU_PF_CONF_INT_LINE_EN;
10358         val |= (IGU_PF_CONF_MSI_MSIX_EN |
10359                 IGU_PF_CONF_ATTN_BIT_EN |
10360                 IGU_PF_CONF_SINGLE_ISR_EN);
10361     } else {
10362         val &= ~IGU_PF_CONF_MSI_MSIX_EN;
10363         val |= (IGU_PF_CONF_INT_LINE_EN |
10364                 IGU_PF_CONF_ATTN_BIT_EN |
10365                 IGU_PF_CONF_SINGLE_ISR_EN);
10366     }
10367
10368     /* clean previous status - need to configure igu prior to ack*/
10369     if ((!msix) || single_msix) {
10370         REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
10371         bxe_ack_int(sc);
10372     }
10373
10374     val |= IGU_PF_CONF_FUNC_EN;
10375
10376     BLOGD(sc, DBG_INTR, "write 0x%x to IGU mode %s\n",
10377           val, ((msix) ? "MSI-X" : ((msi) ? "MSI" : "INTx")));
10378
10379     REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
10380
10381     mb();
10382
10383     /* init leading/trailing edge */
10384     if (IS_MF(sc)) {
10385         val = (0xee0f | (1 << (SC_VN(sc) + 4)));
10386         if (sc->port.pmf) {
10387             /* enable nig and gpio3 attention */
10388             val |= 0x1100;
10389         }
10390     } else {
10391         val = 0xffff;
10392     }
10393
10394     REG_WR(sc, IGU_REG_TRAILING_EDGE_LATCH, val);
10395     REG_WR(sc, IGU_REG_LEADING_EDGE_LATCH, val);
10396
10397     /* make sure that interrupts are indeed enabled from here on */
10398     mb();
10399 }
10400
10401 static void
10402 bxe_int_enable(struct bxe_softc *sc)
10403 {
10404     if (sc->devinfo.int_block == INT_BLOCK_HC) {
10405         bxe_hc_int_enable(sc);
10406     } else {
10407         bxe_igu_int_enable(sc);
10408     }
10409 }
10410
10411 static void
10412 bxe_hc_int_disable(struct bxe_softc *sc)
10413 {
10414     int port = SC_PORT(sc);
10415     uint32_t addr = (port) ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0;
10416     uint32_t val = REG_RD(sc, addr);
10417
10418     /*
10419      * In E1 we must use only PCI configuration space to disable MSI/MSIX
10420      * capablility. It's forbidden to disable IGU_PF_CONF_MSI_MSIX_EN in HC
10421      * block
10422      */
10423     if (CHIP_IS_E1(sc)) {
10424         /*
10425          * Since IGU_PF_CONF_MSI_MSIX_EN still always on use mask register
10426          * to prevent from HC sending interrupts after we exit the function
10427          */
10428         REG_WR(sc, (HC_REG_INT_MASK + port*4), 0);
10429
10430         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
10431                  HC_CONFIG_0_REG_INT_LINE_EN_0 |
10432                  HC_CONFIG_0_REG_ATTN_BIT_EN_0);
10433     } else {
10434         val &= ~(HC_CONFIG_0_REG_SINGLE_ISR_EN_0 |
10435                  HC_CONFIG_0_REG_MSI_MSIX_INT_EN_0 |
10436                  HC_CONFIG_0_REG_INT_LINE_EN_0 |
10437                  HC_CONFIG_0_REG_ATTN_BIT_EN_0);
10438     }
10439
10440     BLOGD(sc, DBG_INTR, "write %x to HC %d (addr 0x%x)\n", val, port, addr);
10441
10442     /* flush all outstanding writes */
10443     mb();
10444
10445     REG_WR(sc, addr, val);
10446     if (REG_RD(sc, addr) != val) {
10447         BLOGE(sc, "proper val not read from HC IGU!\n");
10448     }
10449 }
10450
10451 static void
10452 bxe_igu_int_disable(struct bxe_softc *sc)
10453 {
10454     uint32_t val = REG_RD(sc, IGU_REG_PF_CONFIGURATION);
10455
10456     val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
10457              IGU_PF_CONF_INT_LINE_EN |
10458              IGU_PF_CONF_ATTN_BIT_EN);
10459
10460     BLOGD(sc, DBG_INTR, "write %x to IGU\n", val);
10461
10462     /* flush all outstanding writes */
10463     mb();
10464
10465     REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
10466     if (REG_RD(sc, IGU_REG_PF_CONFIGURATION) != val) {
10467         BLOGE(sc, "proper val not read from IGU!\n");
10468     }
10469 }
10470
10471 static void
10472 bxe_int_disable(struct bxe_softc *sc)
10473 {
10474     if (sc->devinfo.int_block == INT_BLOCK_HC) {
10475         bxe_hc_int_disable(sc);
10476     } else {
10477         bxe_igu_int_disable(sc);
10478     }
10479 }
10480
10481 static void
10482 bxe_nic_init(struct bxe_softc *sc,
10483              int              load_code)
10484 {
10485     int i;
10486
10487     for (i = 0; i < sc->num_queues; i++) {
10488         bxe_init_eth_fp(sc, i);
10489     }
10490
10491     rmb(); /* ensure status block indices were read */
10492
10493     bxe_init_rx_rings(sc);
10494     bxe_init_tx_rings(sc);
10495
10496     if (IS_VF(sc)) {
10497         return;
10498     }
10499
10500     /* initialize MOD_ABS interrupts */
10501     elink_init_mod_abs_int(sc, &sc->link_vars,
10502                            sc->devinfo.chip_id,
10503                            sc->devinfo.shmem_base,
10504                            sc->devinfo.shmem2_base,
10505                            SC_PORT(sc));
10506
10507     bxe_init_def_sb(sc);
10508     bxe_update_dsb_idx(sc);
10509     bxe_init_sp_ring(sc);
10510     bxe_init_eq_ring(sc);
10511     bxe_init_internal(sc, load_code);
10512     bxe_pf_init(sc);
10513     bxe_stats_init(sc);
10514
10515     /* flush all before enabling interrupts */
10516     mb();
10517
10518     bxe_int_enable(sc);
10519
10520     /* check for SPIO5 */
10521     bxe_attn_int_deasserted0(sc,
10522                              REG_RD(sc,
10523                                     (MISC_REG_AEU_AFTER_INVERT_1_FUNC_0 +
10524                                      SC_PORT(sc)*4)) &
10525                              AEU_INPUTS_ATTN_BITS_SPIO5);
10526 }
10527
10528 static inline void
10529 bxe_init_objs(struct bxe_softc *sc)
10530 {
10531     /* mcast rules must be added to tx if tx switching is enabled */
10532     ecore_obj_type o_type =
10533         (sc->flags & BXE_TX_SWITCHING) ? ECORE_OBJ_TYPE_RX_TX :
10534                                          ECORE_OBJ_TYPE_RX;
10535
10536     /* RX_MODE controlling object */
10537     ecore_init_rx_mode_obj(sc, &sc->rx_mode_obj);
10538
10539     /* multicast configuration controlling object */
10540     ecore_init_mcast_obj(sc,
10541                          &sc->mcast_obj,
10542                          sc->fp[0].cl_id,
10543                          sc->fp[0].index,
10544                          SC_FUNC(sc),
10545                          SC_FUNC(sc),
10546                          BXE_SP(sc, mcast_rdata),
10547                          BXE_SP_MAPPING(sc, mcast_rdata),
10548                          ECORE_FILTER_MCAST_PENDING,
10549                          &sc->sp_state,
10550                          o_type);
10551
10552     /* Setup CAM credit pools */
10553     ecore_init_mac_credit_pool(sc,
10554                                &sc->macs_pool,
10555                                SC_FUNC(sc),
10556                                CHIP_IS_E1x(sc) ? VNICS_PER_PORT(sc) :
10557                                                  VNICS_PER_PATH(sc));
10558
10559     ecore_init_vlan_credit_pool(sc,
10560                                 &sc->vlans_pool,
10561                                 SC_ABS_FUNC(sc) >> 1,
10562                                 CHIP_IS_E1x(sc) ? VNICS_PER_PORT(sc) :
10563                                                   VNICS_PER_PATH(sc));
10564
10565     /* RSS configuration object */
10566     ecore_init_rss_config_obj(sc,
10567                               &sc->rss_conf_obj,
10568                               sc->fp[0].cl_id,
10569                               sc->fp[0].index,
10570                               SC_FUNC(sc),
10571                               SC_FUNC(sc),
10572                               BXE_SP(sc, rss_rdata),
10573                               BXE_SP_MAPPING(sc, rss_rdata),
10574                               ECORE_FILTER_RSS_CONF_PENDING,
10575                               &sc->sp_state, ECORE_OBJ_TYPE_RX);
10576 }
10577
10578 /*
10579  * Initialize the function. This must be called before sending CLIENT_SETUP
10580  * for the first client.
10581  */
10582 static inline int
10583 bxe_func_start(struct bxe_softc *sc)
10584 {
10585     struct ecore_func_state_params func_params = { NULL };
10586     struct ecore_func_start_params *start_params = &func_params.params.start;
10587
10588     /* Prepare parameters for function state transitions */
10589     bit_set(&func_params.ramrod_flags, RAMROD_COMP_WAIT);
10590
10591     func_params.f_obj = &sc->func_obj;
10592     func_params.cmd = ECORE_F_CMD_START;
10593
10594     /* Function parameters */
10595     start_params->mf_mode     = sc->devinfo.mf_info.mf_mode;
10596     start_params->sd_vlan_tag = OVLAN(sc);
10597
10598     if (CHIP_IS_E2(sc) || CHIP_IS_E3(sc)) {
10599         start_params->network_cos_mode = STATIC_COS;
10600     } else { /* CHIP_IS_E1X */
10601         start_params->network_cos_mode = FW_WRR;
10602     }
10603
10604     //start_params->gre_tunnel_mode = 0;
10605     //start_params->gre_tunnel_rss  = 0;
10606
10607     return (ecore_func_state_change(sc, &func_params));
10608 }
10609
10610 static int
10611 bxe_set_power_state(struct bxe_softc *sc,
10612                     uint8_t          state)
10613 {
10614     uint16_t pmcsr;
10615
10616     /* If there is no power capability, silently succeed */
10617     if (!(sc->devinfo.pcie_cap_flags & BXE_PM_CAPABLE_FLAG)) {
10618         BLOGW(sc, "No power capability\n");
10619         return (0);
10620     }
10621
10622     pmcsr = pci_read_config(sc->dev,
10623                             (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
10624                             2);
10625
10626     switch (state) {
10627     case PCI_PM_D0:
10628         pci_write_config(sc->dev,
10629                          (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
10630                          ((pmcsr & ~PCIM_PSTAT_DMASK) | PCIM_PSTAT_PME), 2);
10631
10632         if (pmcsr & PCIM_PSTAT_DMASK) {
10633             /* delay required during transition out of D3hot */
10634             DELAY(20000);
10635         }
10636
10637         break;
10638
10639     case PCI_PM_D3hot:
10640         /* XXX if there are other clients above don't shut down the power */
10641
10642         /* don't shut down the power for emulation and FPGA */
10643         if (CHIP_REV_IS_SLOW(sc)) {
10644             return (0);
10645         }
10646
10647         pmcsr &= ~PCIM_PSTAT_DMASK;
10648         pmcsr |= PCIM_PSTAT_D3;
10649
10650         if (sc->wol) {
10651             pmcsr |= PCIM_PSTAT_PMEENABLE;
10652         }
10653
10654         pci_write_config(sc->dev,
10655                          (sc->devinfo.pcie_pm_cap_reg + PCIR_POWER_STATUS),
10656                          pmcsr, 4);
10657
10658         /*
10659          * No more memory access after this point until device is brought back
10660          * to D0 state.
10661          */
10662         break;
10663
10664     default:
10665         BLOGE(sc, "Can't support PCI power state = 0x%x pmcsr 0x%x\n",
10666             state, pmcsr);
10667         return (-1);
10668     }
10669
10670     return (0);
10671 }
10672
10673
10674 /* return true if succeeded to acquire the lock */
10675 static uint8_t
10676 bxe_trylock_hw_lock(struct bxe_softc *sc,
10677                     uint32_t         resource)
10678 {
10679     uint32_t lock_status;
10680     uint32_t resource_bit = (1 << resource);
10681     int func = SC_FUNC(sc);
10682     uint32_t hw_lock_control_reg;
10683
10684     BLOGD(sc, DBG_LOAD, "Trying to take a resource lock 0x%x\n", resource);
10685
10686     /* Validating that the resource is within range */
10687     if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
10688         BLOGD(sc, DBG_LOAD,
10689               "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)\n",
10690               resource, HW_LOCK_MAX_RESOURCE_VALUE);
10691         return (FALSE);
10692     }
10693
10694     if (func <= 5) {
10695         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_1 + func*8);
10696     } else {
10697         hw_lock_control_reg = (MISC_REG_DRIVER_CONTROL_7 + (func - 6)*8);
10698     }
10699
10700     /* try to acquire the lock */
10701     REG_WR(sc, hw_lock_control_reg + 4, resource_bit);
10702     lock_status = REG_RD(sc, hw_lock_control_reg);
10703     if (lock_status & resource_bit) {
10704         return (TRUE);
10705     }
10706
10707     BLOGE(sc, "Failed to get a resource lock 0x%x func %d "
10708         "lock_status 0x%x resource_bit 0x%x\n", resource, func,
10709         lock_status, resource_bit);
10710
10711     return (FALSE);
10712 }
10713
10714 /*
10715  * Get the recovery leader resource id according to the engine this function
10716  * belongs to. Currently only only 2 engines is supported.
10717  */
10718 static int
10719 bxe_get_leader_lock_resource(struct bxe_softc *sc)
10720 {
10721     if (SC_PATH(sc)) {
10722         return (HW_LOCK_RESOURCE_RECOVERY_LEADER_1);
10723     } else {
10724         return (HW_LOCK_RESOURCE_RECOVERY_LEADER_0);
10725     }
10726 }
10727
10728 /* try to acquire a leader lock for current engine */
10729 static uint8_t
10730 bxe_trylock_leader_lock(struct bxe_softc *sc)
10731 {
10732     return (bxe_trylock_hw_lock(sc, bxe_get_leader_lock_resource(sc)));
10733 }
10734
10735 static int
10736 bxe_release_leader_lock(struct bxe_softc *sc)
10737 {
10738     return (bxe_release_hw_lock(sc, bxe_get_leader_lock_resource(sc)));
10739 }
10740
10741 /* close gates #2, #3 and #4 */
10742 static void
10743 bxe_set_234_gates(struct bxe_softc *sc,
10744                   uint8_t          close)
10745 {
10746     uint32_t val;
10747
10748     /* gates #2 and #4a are closed/opened for "not E1" only */
10749     if (!CHIP_IS_E1(sc)) {
10750         /* #4 */
10751         REG_WR(sc, PXP_REG_HST_DISCARD_DOORBELLS, !!close);
10752         /* #2 */
10753         REG_WR(sc, PXP_REG_HST_DISCARD_INTERNAL_WRITES, !!close);
10754     }
10755
10756     /* #3 */
10757     if (CHIP_IS_E1x(sc)) {
10758         /* prevent interrupts from HC on both ports */
10759         val = REG_RD(sc, HC_REG_CONFIG_1);
10760         REG_WR(sc, HC_REG_CONFIG_1,
10761                (!close) ? (val | HC_CONFIG_1_REG_BLOCK_DISABLE_1) :
10762                (val & ~(uint32_t)HC_CONFIG_1_REG_BLOCK_DISABLE_1));
10763
10764         val = REG_RD(sc, HC_REG_CONFIG_0);
10765         REG_WR(sc, HC_REG_CONFIG_0,
10766                (!close) ? (val | HC_CONFIG_0_REG_BLOCK_DISABLE_0) :
10767                (val & ~(uint32_t)HC_CONFIG_0_REG_BLOCK_DISABLE_0));
10768     } else {
10769         /* Prevent incomming interrupts in IGU */
10770         val = REG_RD(sc, IGU_REG_BLOCK_CONFIGURATION);
10771
10772         REG_WR(sc, IGU_REG_BLOCK_CONFIGURATION,
10773                (!close) ?
10774                (val | IGU_BLOCK_CONFIGURATION_REG_BLOCK_ENABLE) :
10775                (val & ~(uint32_t)IGU_BLOCK_CONFIGURATION_REG_BLOCK_ENABLE));
10776     }
10777
10778     BLOGD(sc, DBG_LOAD, "%s gates #2, #3 and #4\n",
10779           close ? "closing" : "opening");
10780
10781     wmb();
10782 }
10783
10784 /* poll for pending writes bit, it should get cleared in no more than 1s */
10785 static int
10786 bxe_er_poll_igu_vq(struct bxe_softc *sc)
10787 {
10788     uint32_t cnt = 1000;
10789     uint32_t pend_bits = 0;
10790
10791     do {
10792         pend_bits = REG_RD(sc, IGU_REG_PENDING_BITS_STATUS);
10793
10794         if (pend_bits == 0) {
10795             break;
10796         }
10797
10798         DELAY(1000);
10799     } while (--cnt > 0);
10800
10801     if (cnt == 0) {
10802         BLOGE(sc, "Still pending IGU requests bits=0x%08x!\n", pend_bits);
10803         return (-1);
10804     }
10805
10806     return (0);
10807 }
10808
10809 #define SHARED_MF_CLP_MAGIC  0x80000000 /* 'magic' bit */
10810
10811 static void
10812 bxe_clp_reset_prep(struct bxe_softc *sc,
10813                    uint32_t         *magic_val)
10814 {
10815     /* Do some magic... */
10816     uint32_t val = MFCFG_RD(sc, shared_mf_config.clp_mb);
10817     *magic_val = val & SHARED_MF_CLP_MAGIC;
10818     MFCFG_WR(sc, shared_mf_config.clp_mb, val | SHARED_MF_CLP_MAGIC);
10819 }
10820
10821 /* restore the value of the 'magic' bit */
10822 static void
10823 bxe_clp_reset_done(struct bxe_softc *sc,
10824                    uint32_t         magic_val)
10825 {
10826     /* Restore the 'magic' bit value... */
10827     uint32_t val = MFCFG_RD(sc, shared_mf_config.clp_mb);
10828     MFCFG_WR(sc, shared_mf_config.clp_mb,
10829               (val & (~SHARED_MF_CLP_MAGIC)) | magic_val);
10830 }
10831
10832 /* prepare for MCP reset, takes care of CLP configurations */
10833 static void
10834 bxe_reset_mcp_prep(struct bxe_softc *sc,
10835                    uint32_t         *magic_val)
10836 {
10837     uint32_t shmem;
10838     uint32_t validity_offset;
10839
10840     /* set `magic' bit in order to save MF config */
10841     if (!CHIP_IS_E1(sc)) {
10842         bxe_clp_reset_prep(sc, magic_val);
10843     }
10844
10845     /* get shmem offset */
10846     shmem = REG_RD(sc, MISC_REG_SHARED_MEM_ADDR);
10847     validity_offset =
10848         offsetof(struct shmem_region, validity_map[SC_PORT(sc)]);
10849
10850     /* Clear validity map flags */
10851     if (shmem > 0) {
10852         REG_WR(sc, shmem + validity_offset, 0);
10853     }
10854 }
10855
10856 #define MCP_TIMEOUT      5000   /* 5 seconds (in ms) */
10857 #define MCP_ONE_TIMEOUT  100    /* 100 ms */
10858
10859 static void
10860 bxe_mcp_wait_one(struct bxe_softc *sc)
10861 {
10862     /* special handling for emulation and FPGA (10 times longer) */
10863     if (CHIP_REV_IS_SLOW(sc)) {
10864         DELAY((MCP_ONE_TIMEOUT*10) * 1000);
10865     } else {
10866         DELAY((MCP_ONE_TIMEOUT) * 1000);
10867     }
10868 }
10869
10870 /* initialize shmem_base and waits for validity signature to appear */
10871 static int
10872 bxe_init_shmem(struct bxe_softc *sc)
10873 {
10874     int cnt = 0;
10875     uint32_t val = 0;
10876
10877     do {
10878         sc->devinfo.shmem_base     =
10879         sc->link_params.shmem_base =
10880             REG_RD(sc, MISC_REG_SHARED_MEM_ADDR);
10881
10882         if (sc->devinfo.shmem_base) {
10883             val = SHMEM_RD(sc, validity_map[SC_PORT(sc)]);
10884             if (val & SHR_MEM_VALIDITY_MB)
10885                 return (0);
10886         }
10887
10888         bxe_mcp_wait_one(sc);
10889
10890     } while (cnt++ < (MCP_TIMEOUT / MCP_ONE_TIMEOUT));
10891
10892     BLOGE(sc, "BAD MCP validity signature\n");
10893
10894     return (-1);
10895 }
10896
10897 static int
10898 bxe_reset_mcp_comp(struct bxe_softc *sc,
10899                    uint32_t         magic_val)
10900 {
10901     int rc = bxe_init_shmem(sc);
10902
10903     /* Restore the `magic' bit value */
10904     if (!CHIP_IS_E1(sc)) {
10905         bxe_clp_reset_done(sc, magic_val);
10906     }
10907
10908     return (rc);
10909 }
10910
10911 static void
10912 bxe_pxp_prep(struct bxe_softc *sc)
10913 {
10914     if (!CHIP_IS_E1(sc)) {
10915         REG_WR(sc, PXP2_REG_RD_START_INIT, 0);
10916         REG_WR(sc, PXP2_REG_RQ_RBC_DONE, 0);
10917         wmb();
10918     }
10919 }
10920
10921 /*
10922  * Reset the whole chip except for:
10923  *      - PCIE core
10924  *      - PCI Glue, PSWHST, PXP/PXP2 RF (all controlled by one reset bit)
10925  *      - IGU
10926  *      - MISC (including AEU)
10927  *      - GRC
10928  *      - RBCN, RBCP
10929  */
10930 static void
10931 bxe_process_kill_chip_reset(struct bxe_softc *sc,
10932                             uint8_t          global)
10933 {
10934     uint32_t not_reset_mask1, reset_mask1, not_reset_mask2, reset_mask2;
10935     uint32_t global_bits2, stay_reset2;
10936
10937     /*
10938      * Bits that have to be set in reset_mask2 if we want to reset 'global'
10939      * (per chip) blocks.
10940      */
10941     global_bits2 =
10942         MISC_REGISTERS_RESET_REG_2_RST_MCP_N_RESET_CMN_CPU |
10943         MISC_REGISTERS_RESET_REG_2_RST_MCP_N_RESET_CMN_CORE;
10944
10945     /*
10946      * Don't reset the following blocks.
10947      * Important: per port blocks (such as EMAC, BMAC, UMAC) can't be
10948      *            reset, as in 4 port device they might still be owned
10949      *            by the MCP (there is only one leader per path).
10950      */
10951     not_reset_mask1 =
10952         MISC_REGISTERS_RESET_REG_1_RST_HC |
10953         MISC_REGISTERS_RESET_REG_1_RST_PXPV |
10954         MISC_REGISTERS_RESET_REG_1_RST_PXP;
10955
10956     not_reset_mask2 =
10957         MISC_REGISTERS_RESET_REG_2_RST_PCI_MDIO |
10958         MISC_REGISTERS_RESET_REG_2_RST_EMAC0_HARD_CORE |
10959         MISC_REGISTERS_RESET_REG_2_RST_EMAC1_HARD_CORE |
10960         MISC_REGISTERS_RESET_REG_2_RST_MISC_CORE |
10961         MISC_REGISTERS_RESET_REG_2_RST_RBCN |
10962         MISC_REGISTERS_RESET_REG_2_RST_GRC  |
10963         MISC_REGISTERS_RESET_REG_2_RST_MCP_N_RESET_REG_HARD_CORE |
10964         MISC_REGISTERS_RESET_REG_2_RST_MCP_N_HARD_CORE_RST_B |
10965         MISC_REGISTERS_RESET_REG_2_RST_ATC |
10966         MISC_REGISTERS_RESET_REG_2_PGLC |
10967         MISC_REGISTERS_RESET_REG_2_RST_BMAC0 |
10968         MISC_REGISTERS_RESET_REG_2_RST_BMAC1 |
10969         MISC_REGISTERS_RESET_REG_2_RST_EMAC0 |
10970         MISC_REGISTERS_RESET_REG_2_RST_EMAC1 |
10971         MISC_REGISTERS_RESET_REG_2_UMAC0 |
10972         MISC_REGISTERS_RESET_REG_2_UMAC1;
10973
10974     /*
10975      * Keep the following blocks in reset:
10976      *  - all xxMACs are handled by the elink code.
10977      */
10978     stay_reset2 =
10979         MISC_REGISTERS_RESET_REG_2_XMAC |
10980         MISC_REGISTERS_RESET_REG_2_XMAC_SOFT;
10981
10982     /* Full reset masks according to the chip */
10983     reset_mask1 = 0xffffffff;
10984
10985     if (CHIP_IS_E1(sc))
10986         reset_mask2 = 0xffff;
10987     else if (CHIP_IS_E1H(sc))
10988         reset_mask2 = 0x1ffff;
10989     else if (CHIP_IS_E2(sc))
10990         reset_mask2 = 0xfffff;
10991     else /* CHIP_IS_E3 */
10992         reset_mask2 = 0x3ffffff;
10993
10994     /* Don't reset global blocks unless we need to */
10995     if (!global)
10996         reset_mask2 &= ~global_bits2;
10997
10998     /*
10999      * In case of attention in the QM, we need to reset PXP
11000      * (MISC_REGISTERS_RESET_REG_2_RST_PXP_RQ_RD_WR) before QM
11001      * because otherwise QM reset would release 'close the gates' shortly
11002      * before resetting the PXP, then the PSWRQ would send a write
11003      * request to PGLUE. Then when PXP is reset, PGLUE would try to
11004      * read the payload data from PSWWR, but PSWWR would not
11005      * respond. The write queue in PGLUE would stuck, dmae commands
11006      * would not return. Therefore it's important to reset the second
11007      * reset register (containing the
11008      * MISC_REGISTERS_RESET_REG_2_RST_PXP_RQ_RD_WR bit) before the
11009      * first one (containing the MISC_REGISTERS_RESET_REG_1_RST_QM
11010      * bit).
11011      */
11012     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
11013            reset_mask2 & (~not_reset_mask2));
11014
11015     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
11016            reset_mask1 & (~not_reset_mask1));
11017
11018     mb();
11019     wmb();
11020
11021     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
11022            reset_mask2 & (~stay_reset2));
11023
11024     mb();
11025     wmb();
11026
11027     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, reset_mask1);
11028     wmb();
11029 }
11030
11031 static int
11032 bxe_process_kill(struct bxe_softc *sc,
11033                  uint8_t          global)
11034 {
11035     int cnt = 1000;
11036     uint32_t val = 0;
11037     uint32_t sr_cnt, blk_cnt, port_is_idle_0, port_is_idle_1, pgl_exp_rom2;
11038     uint32_t tags_63_32 = 0;
11039
11040     /* Empty the Tetris buffer, wait for 1s */
11041     do {
11042         sr_cnt  = REG_RD(sc, PXP2_REG_RD_SR_CNT);
11043         blk_cnt = REG_RD(sc, PXP2_REG_RD_BLK_CNT);
11044         port_is_idle_0 = REG_RD(sc, PXP2_REG_RD_PORT_IS_IDLE_0);
11045         port_is_idle_1 = REG_RD(sc, PXP2_REG_RD_PORT_IS_IDLE_1);
11046         pgl_exp_rom2 = REG_RD(sc, PXP2_REG_PGL_EXP_ROM2);
11047         if (CHIP_IS_E3(sc)) {
11048             tags_63_32 = REG_RD(sc, PGLUE_B_REG_TAGS_63_32);
11049         }
11050
11051         if ((sr_cnt == 0x7e) && (blk_cnt == 0xa0) &&
11052             ((port_is_idle_0 & 0x1) == 0x1) &&
11053             ((port_is_idle_1 & 0x1) == 0x1) &&
11054             (pgl_exp_rom2 == 0xffffffff) &&
11055             (!CHIP_IS_E3(sc) || (tags_63_32 == 0xffffffff)))
11056             break;
11057         DELAY(1000);
11058     } while (cnt-- > 0);
11059
11060     if (cnt <= 0) {
11061         BLOGE(sc, "ERROR: Tetris buffer didn't get empty or there "
11062                   "are still outstanding read requests after 1s! "
11063                   "sr_cnt=0x%08x, blk_cnt=0x%08x, port_is_idle_0=0x%08x, "
11064                   "port_is_idle_1=0x%08x, pgl_exp_rom2=0x%08x\n",
11065               sr_cnt, blk_cnt, port_is_idle_0,
11066               port_is_idle_1, pgl_exp_rom2);
11067         return (-1);
11068     }
11069
11070     mb();
11071
11072     /* Close gates #2, #3 and #4 */
11073     bxe_set_234_gates(sc, TRUE);
11074
11075     /* Poll for IGU VQs for 57712 and newer chips */
11076     if (!CHIP_IS_E1x(sc) && bxe_er_poll_igu_vq(sc)) {
11077         return (-1);
11078     }
11079
11080     /* XXX indicate that "process kill" is in progress to MCP */
11081
11082     /* clear "unprepared" bit */
11083     REG_WR(sc, MISC_REG_UNPREPARED, 0);
11084     mb();
11085
11086     /* Make sure all is written to the chip before the reset */
11087     wmb();
11088
11089     /*
11090      * Wait for 1ms to empty GLUE and PCI-E core queues,
11091      * PSWHST, GRC and PSWRD Tetris buffer.
11092      */
11093     DELAY(1000);
11094
11095     /* Prepare to chip reset: */
11096     /* MCP */
11097     if (global) {
11098         bxe_reset_mcp_prep(sc, &val);
11099     }
11100
11101     /* PXP */
11102     bxe_pxp_prep(sc);
11103     mb();
11104
11105     /* reset the chip */
11106     bxe_process_kill_chip_reset(sc, global);
11107     mb();
11108
11109     /* clear errors in PGB */
11110     if (!CHIP_IS_E1(sc))
11111         REG_WR(sc, PGLUE_B_REG_LATCHED_ERRORS_CLR, 0x7f);
11112
11113     /* Recover after reset: */
11114     /* MCP */
11115     if (global && bxe_reset_mcp_comp(sc, val)) {
11116         return (-1);
11117     }
11118
11119     /* XXX add resetting the NO_MCP mode DB here */
11120
11121     /* Open the gates #2, #3 and #4 */
11122     bxe_set_234_gates(sc, FALSE);
11123
11124     /* XXX
11125      * IGU/AEU preparation bring back the AEU/IGU to a reset state
11126      * re-enable attentions
11127      */
11128
11129     return (0);
11130 }
11131
11132 static int
11133 bxe_leader_reset(struct bxe_softc *sc)
11134 {
11135     int rc = 0;
11136     uint8_t global = bxe_reset_is_global(sc);
11137     uint32_t load_code;
11138
11139     /*
11140      * If not going to reset MCP, load "fake" driver to reset HW while
11141      * driver is owner of the HW.
11142      */
11143     if (!global && !BXE_NOMCP(sc)) {
11144         load_code = bxe_fw_command(sc, DRV_MSG_CODE_LOAD_REQ,
11145                                    DRV_MSG_CODE_LOAD_REQ_WITH_LFA);
11146         if (!load_code) {
11147             BLOGE(sc, "MCP response failure, aborting\n");
11148             rc = -1;
11149             goto exit_leader_reset;
11150         }
11151
11152         if ((load_code != FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) &&
11153             (load_code != FW_MSG_CODE_DRV_LOAD_COMMON)) {
11154             BLOGE(sc, "MCP unexpected response, aborting\n");
11155             rc = -1;
11156             goto exit_leader_reset2;
11157         }
11158
11159         load_code = bxe_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
11160         if (!load_code) {
11161             BLOGE(sc, "MCP response failure, aborting\n");
11162             rc = -1;
11163             goto exit_leader_reset2;
11164         }
11165     }
11166
11167     /* try to recover after the failure */
11168     if (bxe_process_kill(sc, global)) {
11169         BLOGE(sc, "Something bad occurred on engine %d!\n", SC_PATH(sc));
11170         rc = -1;
11171         goto exit_leader_reset2;
11172     }
11173
11174     /*
11175      * Clear the RESET_IN_PROGRESS and RESET_GLOBAL bits and update the driver
11176      * state.
11177      */
11178     bxe_set_reset_done(sc);
11179     if (global) {
11180         bxe_clear_reset_global(sc);
11181     }
11182
11183 exit_leader_reset2:
11184
11185     /* unload "fake driver" if it was loaded */
11186     if (!global && !BXE_NOMCP(sc)) {
11187         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP, 0);
11188         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE, 0);
11189     }
11190
11191 exit_leader_reset:
11192
11193     sc->is_leader = 0;
11194     bxe_release_leader_lock(sc);
11195
11196     mb();
11197     return (rc);
11198 }
11199
11200 /*
11201  * prepare INIT transition, parameters configured:
11202  *   - HC configuration
11203  *   - Queue's CDU context
11204  */
11205 static void
11206 bxe_pf_q_prep_init(struct bxe_softc               *sc,
11207                    struct bxe_fastpath            *fp,
11208                    struct ecore_queue_init_params *init_params)
11209 {
11210     uint8_t cos;
11211     int cxt_index, cxt_offset;
11212
11213     bxe_set_bit(ECORE_Q_FLG_HC, &init_params->rx.flags);
11214     bxe_set_bit(ECORE_Q_FLG_HC, &init_params->tx.flags);
11215
11216     bxe_set_bit(ECORE_Q_FLG_HC_EN, &init_params->rx.flags);
11217     bxe_set_bit(ECORE_Q_FLG_HC_EN, &init_params->tx.flags);
11218
11219     /* HC rate */
11220     init_params->rx.hc_rate =
11221         sc->hc_rx_ticks ? (1000000 / sc->hc_rx_ticks) : 0;
11222     init_params->tx.hc_rate =
11223         sc->hc_tx_ticks ? (1000000 / sc->hc_tx_ticks) : 0;
11224
11225     /* FW SB ID */
11226     init_params->rx.fw_sb_id = init_params->tx.fw_sb_id = fp->fw_sb_id;
11227
11228     /* CQ index among the SB indices */
11229     init_params->rx.sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS;
11230     init_params->tx.sb_cq_index = HC_INDEX_ETH_FIRST_TX_CQ_CONS;
11231
11232     /* set maximum number of COSs supported by this queue */
11233     init_params->max_cos = sc->max_cos;
11234
11235     BLOGD(sc, DBG_LOAD, "fp %d setting queue params max cos to %d\n",
11236           fp->index, init_params->max_cos);
11237
11238     /* set the context pointers queue object */
11239     for (cos = FIRST_TX_COS_INDEX; cos < init_params->max_cos; cos++) {
11240         /* XXX change index/cid here if ever support multiple tx CoS */
11241         /* fp->txdata[cos]->cid */
11242         cxt_index = fp->index / ILT_PAGE_CIDS;
11243         cxt_offset = fp->index - (cxt_index * ILT_PAGE_CIDS);
11244         init_params->cxts[cos] = &sc->context[cxt_index].vcxt[cxt_offset].eth;
11245     }
11246 }
11247
11248 /* set flags that are common for the Tx-only and not normal connections */
11249 static unsigned long
11250 bxe_get_common_flags(struct bxe_softc    *sc,
11251                      struct bxe_fastpath *fp,
11252                      uint8_t             zero_stats)
11253 {
11254     unsigned long flags = 0;
11255
11256     /* PF driver will always initialize the Queue to an ACTIVE state */
11257     bxe_set_bit(ECORE_Q_FLG_ACTIVE, &flags);
11258
11259     /*
11260      * tx only connections collect statistics (on the same index as the
11261      * parent connection). The statistics are zeroed when the parent
11262      * connection is initialized.
11263      */
11264
11265     bxe_set_bit(ECORE_Q_FLG_STATS, &flags);
11266     if (zero_stats) {
11267         bxe_set_bit(ECORE_Q_FLG_ZERO_STATS, &flags);
11268     }
11269
11270     /*
11271      * tx only connections can support tx-switching, though their
11272      * CoS-ness doesn't survive the loopback
11273      */
11274     if (sc->flags & BXE_TX_SWITCHING) {
11275         bxe_set_bit(ECORE_Q_FLG_TX_SWITCH, &flags);
11276     }
11277
11278     bxe_set_bit(ECORE_Q_FLG_PCSUM_ON_PKT, &flags);
11279
11280     return (flags);
11281 }
11282
11283 static unsigned long
11284 bxe_get_q_flags(struct bxe_softc    *sc,
11285                 struct bxe_fastpath *fp,
11286                 uint8_t             leading)
11287 {
11288     unsigned long flags = 0;
11289
11290     if (IS_MF_SD(sc)) {
11291         bxe_set_bit(ECORE_Q_FLG_OV, &flags);
11292     }
11293
11294     if (sc->ifnet->if_capenable & IFCAP_LRO) {
11295         bxe_set_bit(ECORE_Q_FLG_TPA, &flags);
11296         bxe_set_bit(ECORE_Q_FLG_TPA_IPV6, &flags);
11297     }
11298
11299     if (leading) {
11300         bxe_set_bit(ECORE_Q_FLG_LEADING_RSS, &flags);
11301         bxe_set_bit(ECORE_Q_FLG_MCAST, &flags);
11302     }
11303
11304     bxe_set_bit(ECORE_Q_FLG_VLAN, &flags);
11305
11306     /* merge with common flags */
11307     return (flags | bxe_get_common_flags(sc, fp, TRUE));
11308 }
11309
11310 static void
11311 bxe_pf_q_prep_general(struct bxe_softc                  *sc,
11312                       struct bxe_fastpath               *fp,
11313                       struct ecore_general_setup_params *gen_init,
11314                       uint8_t                           cos)
11315 {
11316     gen_init->stat_id = bxe_stats_id(fp);
11317     gen_init->spcl_id = fp->cl_id;
11318     gen_init->mtu = sc->mtu;
11319     gen_init->cos = cos;
11320 }
11321
11322 static void
11323 bxe_pf_rx_q_prep(struct bxe_softc              *sc,
11324                  struct bxe_fastpath           *fp,
11325                  struct rxq_pause_params       *pause,
11326                  struct ecore_rxq_setup_params *rxq_init)
11327 {
11328     uint8_t max_sge = 0;
11329     uint16_t sge_sz = 0;
11330     uint16_t tpa_agg_size = 0;
11331
11332     pause->sge_th_lo = SGE_TH_LO(sc);
11333     pause->sge_th_hi = SGE_TH_HI(sc);
11334
11335     /* validate SGE ring has enough to cross high threshold */
11336     if (sc->dropless_fc &&
11337             (pause->sge_th_hi + FW_PREFETCH_CNT) >
11338             (RX_SGE_USABLE_PER_PAGE * RX_SGE_NUM_PAGES)) {
11339         BLOGW(sc, "sge ring threshold limit\n");
11340     }
11341
11342     /* minimum max_aggregation_size is 2*MTU (two full buffers) */
11343     tpa_agg_size = (2 * sc->mtu);
11344     if (tpa_agg_size < sc->max_aggregation_size) {
11345         tpa_agg_size = sc->max_aggregation_size;
11346     }
11347
11348     max_sge = SGE_PAGE_ALIGN(sc->mtu) >> SGE_PAGE_SHIFT;
11349     max_sge = ((max_sge + PAGES_PER_SGE - 1) &
11350                    (~(PAGES_PER_SGE - 1))) >> PAGES_PER_SGE_SHIFT;
11351     sge_sz = (uint16_t)min(SGE_PAGES, 0xffff);
11352
11353     /* pause - not for e1 */
11354     if (!CHIP_IS_E1(sc)) {
11355         pause->bd_th_lo = BD_TH_LO(sc);
11356         pause->bd_th_hi = BD_TH_HI(sc);
11357
11358         pause->rcq_th_lo = RCQ_TH_LO(sc);
11359         pause->rcq_th_hi = RCQ_TH_HI(sc);
11360
11361         /* validate rings have enough entries to cross high thresholds */
11362         if (sc->dropless_fc &&
11363             pause->bd_th_hi + FW_PREFETCH_CNT >
11364             sc->rx_ring_size) {
11365             BLOGW(sc, "rx bd ring threshold limit\n");
11366         }
11367
11368         if (sc->dropless_fc &&
11369             pause->rcq_th_hi + FW_PREFETCH_CNT >
11370             RCQ_NUM_PAGES * RCQ_USABLE_PER_PAGE) {
11371             BLOGW(sc, "rcq ring threshold limit\n");
11372         }
11373
11374         pause->pri_map = 1;
11375     }
11376
11377     /* rxq setup */
11378     rxq_init->dscr_map   = fp->rx_dma.paddr;
11379     rxq_init->sge_map    = fp->rx_sge_dma.paddr;
11380     rxq_init->rcq_map    = fp->rcq_dma.paddr;
11381     rxq_init->rcq_np_map = (fp->rcq_dma.paddr + BCM_PAGE_SIZE);
11382
11383     /*
11384      * This should be a maximum number of data bytes that may be
11385      * placed on the BD (not including paddings).
11386      */
11387     rxq_init->buf_sz = (fp->rx_buf_size -
11388                         IP_HEADER_ALIGNMENT_PADDING);
11389
11390     rxq_init->cl_qzone_id     = fp->cl_qzone_id;
11391     rxq_init->tpa_agg_sz      = tpa_agg_size;
11392     rxq_init->sge_buf_sz      = sge_sz;
11393     rxq_init->max_sges_pkt    = max_sge;
11394     rxq_init->rss_engine_id   = SC_FUNC(sc);
11395     rxq_init->mcast_engine_id = SC_FUNC(sc);
11396
11397     /*
11398      * Maximum number or simultaneous TPA aggregation for this Queue.
11399      * For PF Clients it should be the maximum available number.
11400      * VF driver(s) may want to define it to a smaller value.
11401      */
11402     rxq_init->max_tpa_queues = MAX_AGG_QS(sc);
11403
11404     rxq_init->cache_line_log = BXE_RX_ALIGN_SHIFT;
11405     rxq_init->fw_sb_id = fp->fw_sb_id;
11406
11407     rxq_init->sb_cq_index = HC_INDEX_ETH_RX_CQ_CONS;
11408
11409     /*
11410      * configure silent vlan removal
11411      * if multi function mode is afex, then mask default vlan
11412      */
11413     if (IS_MF_AFEX(sc)) {
11414         rxq_init->silent_removal_value =
11415             sc->devinfo.mf_info.afex_def_vlan_tag;
11416         rxq_init->silent_removal_mask = EVL_VLID_MASK;
11417     }
11418 }
11419
11420 static void
11421 bxe_pf_tx_q_prep(struct bxe_softc              *sc,
11422                  struct bxe_fastpath           *fp,
11423                  struct ecore_txq_setup_params *txq_init,
11424                  uint8_t                       cos)
11425 {
11426     /*
11427      * XXX If multiple CoS is ever supported then each fastpath structure
11428      * will need to maintain tx producer/consumer/dma/etc values *per* CoS.
11429      * fp->txdata[cos]->tx_dma.paddr;
11430      */
11431     txq_init->dscr_map     = fp->tx_dma.paddr;
11432     txq_init->sb_cq_index  = HC_INDEX_ETH_FIRST_TX_CQ_CONS + cos;
11433     txq_init->traffic_type = LLFC_TRAFFIC_TYPE_NW;
11434     txq_init->fw_sb_id     = fp->fw_sb_id;
11435
11436     /*
11437      * set the TSS leading client id for TX classfication to the
11438      * leading RSS client id
11439      */
11440     txq_init->tss_leading_cl_id = BXE_FP(sc, 0, cl_id);
11441 }
11442
11443 /*
11444  * This function performs 2 steps in a queue state machine:
11445  *   1) RESET->INIT
11446  *   2) INIT->SETUP
11447  */
11448 static int
11449 bxe_setup_queue(struct bxe_softc    *sc,
11450                 struct bxe_fastpath *fp,
11451                 uint8_t             leading)
11452 {
11453     struct ecore_queue_state_params q_params = { NULL };
11454     struct ecore_queue_setup_params *setup_params =
11455                         &q_params.params.setup;
11456     int rc;
11457
11458     BLOGD(sc, DBG_LOAD, "setting up queue %d\n", fp->index);
11459
11460     bxe_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
11461
11462     q_params.q_obj = &BXE_SP_OBJ(sc, fp).q_obj;
11463
11464     /* we want to wait for completion in this context */
11465     bxe_set_bit(RAMROD_COMP_WAIT, &q_params.ramrod_flags);
11466
11467     /* prepare the INIT parameters */
11468     bxe_pf_q_prep_init(sc, fp, &q_params.params.init);
11469
11470     /* Set the command */
11471     q_params.cmd = ECORE_Q_CMD_INIT;
11472
11473     /* Change the state to INIT */
11474     rc = ecore_queue_state_change(sc, &q_params);
11475     if (rc) {
11476         BLOGE(sc, "Queue(%d) INIT failed rc = %d\n", fp->index, rc);
11477         return (rc);
11478     }
11479
11480     BLOGD(sc, DBG_LOAD, "init complete\n");
11481
11482     /* now move the Queue to the SETUP state */
11483     memset(setup_params, 0, sizeof(*setup_params));
11484
11485     /* set Queue flags */
11486     setup_params->flags = bxe_get_q_flags(sc, fp, leading);
11487
11488     /* set general SETUP parameters */
11489     bxe_pf_q_prep_general(sc, fp, &setup_params->gen_params,
11490                           FIRST_TX_COS_INDEX);
11491
11492     bxe_pf_rx_q_prep(sc, fp,
11493                      &setup_params->pause_params,
11494                      &setup_params->rxq_params);
11495
11496     bxe_pf_tx_q_prep(sc, fp,
11497                      &setup_params->txq_params,
11498                      FIRST_TX_COS_INDEX);
11499
11500     /* Set the command */
11501     q_params.cmd = ECORE_Q_CMD_SETUP;
11502
11503     /* change the state to SETUP */
11504     rc = ecore_queue_state_change(sc, &q_params);
11505     if (rc) {
11506         BLOGE(sc, "Queue(%d) SETUP failed (rc = %d)\n", fp->index, rc);
11507         return (rc);
11508     }
11509
11510     return (rc);
11511 }
11512
11513 static int
11514 bxe_setup_leading(struct bxe_softc *sc)
11515 {
11516     return (bxe_setup_queue(sc, &sc->fp[0], TRUE));
11517 }
11518
11519 static int
11520 bxe_config_rss_pf(struct bxe_softc            *sc,
11521                   struct ecore_rss_config_obj *rss_obj,
11522                   uint8_t                     config_hash)
11523 {
11524     struct ecore_config_rss_params params = { NULL };
11525     int i;
11526
11527     /*
11528      * Although RSS is meaningless when there is a single HW queue we
11529      * still need it enabled in order to have HW Rx hash generated.
11530      */
11531
11532     params.rss_obj = rss_obj;
11533
11534     bxe_set_bit(RAMROD_COMP_WAIT, &params.ramrod_flags);
11535
11536     bxe_set_bit(ECORE_RSS_MODE_REGULAR, &params.rss_flags);
11537
11538     /* RSS configuration */
11539     bxe_set_bit(ECORE_RSS_IPV4, &params.rss_flags);
11540     bxe_set_bit(ECORE_RSS_IPV4_TCP, &params.rss_flags);
11541     bxe_set_bit(ECORE_RSS_IPV6, &params.rss_flags);
11542     bxe_set_bit(ECORE_RSS_IPV6_TCP, &params.rss_flags);
11543     if (rss_obj->udp_rss_v4) {
11544         bxe_set_bit(ECORE_RSS_IPV4_UDP, &params.rss_flags);
11545     }
11546     if (rss_obj->udp_rss_v6) {
11547         bxe_set_bit(ECORE_RSS_IPV6_UDP, &params.rss_flags);
11548     }
11549
11550     /* Hash bits */
11551     params.rss_result_mask = MULTI_MASK;
11552
11553     memcpy(params.ind_table, rss_obj->ind_table, sizeof(params.ind_table));
11554
11555     if (config_hash) {
11556         /* RSS keys */
11557         for (i = 0; i < sizeof(params.rss_key) / 4; i++) {
11558             params.rss_key[i] = arc4random();
11559         }
11560
11561         bxe_set_bit(ECORE_RSS_SET_SRCH, &params.rss_flags);
11562     }
11563
11564     return (ecore_config_rss(sc, &params));
11565 }
11566
11567 static int
11568 bxe_config_rss_eth(struct bxe_softc *sc,
11569                    uint8_t          config_hash)
11570 {
11571     return (bxe_config_rss_pf(sc, &sc->rss_conf_obj, config_hash));
11572 }
11573
11574 static int
11575 bxe_init_rss_pf(struct bxe_softc *sc)
11576 {
11577     uint8_t num_eth_queues = BXE_NUM_ETH_QUEUES(sc);
11578     int i;
11579
11580     /*
11581      * Prepare the initial contents of the indirection table if
11582      * RSS is enabled
11583      */
11584     for (i = 0; i < sizeof(sc->rss_conf_obj.ind_table); i++) {
11585         sc->rss_conf_obj.ind_table[i] =
11586             (sc->fp->cl_id + (i % num_eth_queues));
11587     }
11588
11589     if (sc->udp_rss) {
11590         sc->rss_conf_obj.udp_rss_v4 = sc->rss_conf_obj.udp_rss_v6 = 1;
11591     }
11592
11593     /*
11594      * For 57710 and 57711 SEARCHER configuration (rss_keys) is
11595      * per-port, so if explicit configuration is needed, do it only
11596      * for a PMF.
11597      *
11598      * For 57712 and newer it's a per-function configuration.
11599      */
11600     return (bxe_config_rss_eth(sc, sc->port.pmf || !CHIP_IS_E1x(sc)));
11601 }
11602
11603 static int
11604 bxe_set_mac_one(struct bxe_softc          *sc,
11605                 uint8_t                   *mac,
11606                 struct ecore_vlan_mac_obj *obj,
11607                 uint8_t                   set,
11608                 int                       mac_type,
11609                 unsigned long             *ramrod_flags)
11610 {
11611     struct ecore_vlan_mac_ramrod_params ramrod_param;
11612     int rc;
11613
11614     memset(&ramrod_param, 0, sizeof(ramrod_param));
11615
11616     /* fill in general parameters */
11617     ramrod_param.vlan_mac_obj = obj;
11618     ramrod_param.ramrod_flags = *ramrod_flags;
11619
11620     /* fill a user request section if needed */
11621     if (!bxe_test_bit(RAMROD_CONT, ramrod_flags)) {
11622         memcpy(ramrod_param.user_req.u.mac.mac, mac, ETH_ALEN);
11623
11624         bxe_set_bit(mac_type, &ramrod_param.user_req.vlan_mac_flags);
11625
11626         /* Set the command: ADD or DEL */
11627         ramrod_param.user_req.cmd = (set) ? ECORE_VLAN_MAC_ADD :
11628                                             ECORE_VLAN_MAC_DEL;
11629     }
11630
11631     rc = ecore_config_vlan_mac(sc, &ramrod_param);
11632
11633     if (rc == ECORE_EXISTS) {
11634         BLOGD(sc, DBG_SP, "Failed to schedule ADD operations (EEXIST)\n");
11635         /* do not treat adding same MAC as error */
11636         rc = 0;
11637     } else if (rc < 0) {
11638         BLOGE(sc, "%s MAC failed (%d)\n", (set ? "Set" : "Delete"), rc);
11639     }
11640
11641     return (rc);
11642 }
11643
11644 static int
11645 bxe_set_eth_mac(struct bxe_softc *sc,
11646                 uint8_t          set)
11647 {
11648     unsigned long ramrod_flags = 0;
11649
11650     BLOGD(sc, DBG_LOAD, "Adding Ethernet MAC\n");
11651
11652     bxe_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
11653
11654     /* Eth MAC is set on RSS leading client (fp[0]) */
11655     return (bxe_set_mac_one(sc, sc->link_params.mac_addr,
11656                             &sc->sp_objs->mac_obj,
11657                             set, ECORE_ETH_MAC, &ramrod_flags));
11658 }
11659
11660 static int
11661 bxe_get_cur_phy_idx(struct bxe_softc *sc)
11662 {
11663     uint32_t sel_phy_idx = 0;
11664
11665     if (sc->link_params.num_phys <= 1) {
11666         return (ELINK_INT_PHY);
11667     }
11668
11669     if (sc->link_vars.link_up) {
11670         sel_phy_idx = ELINK_EXT_PHY1;
11671         /* In case link is SERDES, check if the ELINK_EXT_PHY2 is the one */
11672         if ((sc->link_vars.link_status & LINK_STATUS_SERDES_LINK) &&
11673             (sc->link_params.phy[ELINK_EXT_PHY2].supported &
11674              ELINK_SUPPORTED_FIBRE))
11675             sel_phy_idx = ELINK_EXT_PHY2;
11676     } else {
11677         switch (elink_phy_selection(&sc->link_params)) {
11678         case PORT_HW_CFG_PHY_SELECTION_HARDWARE_DEFAULT:
11679         case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY:
11680         case PORT_HW_CFG_PHY_SELECTION_FIRST_PHY_PRIORITY:
11681                sel_phy_idx = ELINK_EXT_PHY1;
11682                break;
11683         case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY:
11684         case PORT_HW_CFG_PHY_SELECTION_SECOND_PHY_PRIORITY:
11685                sel_phy_idx = ELINK_EXT_PHY2;
11686                break;
11687         }
11688     }
11689
11690     return (sel_phy_idx);
11691 }
11692
11693 static int
11694 bxe_get_link_cfg_idx(struct bxe_softc *sc)
11695 {
11696     uint32_t sel_phy_idx = bxe_get_cur_phy_idx(sc);
11697
11698     /*
11699      * The selected activated PHY is always after swapping (in case PHY
11700      * swapping is enabled). So when swapping is enabled, we need to reverse
11701      * the configuration
11702      */
11703
11704     if (sc->link_params.multi_phy_config & PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
11705         if (sel_phy_idx == ELINK_EXT_PHY1)
11706             sel_phy_idx = ELINK_EXT_PHY2;
11707         else if (sel_phy_idx == ELINK_EXT_PHY2)
11708             sel_phy_idx = ELINK_EXT_PHY1;
11709     }
11710
11711     return (ELINK_LINK_CONFIG_IDX(sel_phy_idx));
11712 }
11713
11714 static void
11715 bxe_set_requested_fc(struct bxe_softc *sc)
11716 {
11717     /*
11718      * Initialize link parameters structure variables
11719      * It is recommended to turn off RX FC for jumbo frames
11720      * for better performance
11721      */
11722     if (CHIP_IS_E1x(sc) && (sc->mtu > 5000)) {
11723         sc->link_params.req_fc_auto_adv = ELINK_FLOW_CTRL_TX;
11724     } else {
11725         sc->link_params.req_fc_auto_adv = ELINK_FLOW_CTRL_BOTH;
11726     }
11727 }
11728
11729 static void
11730 bxe_calc_fc_adv(struct bxe_softc *sc)
11731 {
11732     uint8_t cfg_idx = bxe_get_link_cfg_idx(sc);
11733     switch (sc->link_vars.ieee_fc &
11734             MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
11735     case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
11736     default:
11737         sc->port.advertising[cfg_idx] &= ~(ADVERTISED_Asym_Pause |
11738                                            ADVERTISED_Pause);
11739         break;
11740
11741     case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH:
11742         sc->port.advertising[cfg_idx] |= (ADVERTISED_Asym_Pause |
11743                                           ADVERTISED_Pause);
11744         break;
11745
11746     case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_ASYMMETRIC:
11747         sc->port.advertising[cfg_idx] |= ADVERTISED_Asym_Pause;
11748         break;
11749     }
11750 }
11751
11752 static uint16_t
11753 bxe_get_mf_speed(struct bxe_softc *sc)
11754 {
11755     uint16_t line_speed = sc->link_vars.line_speed;
11756     if (IS_MF(sc)) {
11757         uint16_t maxCfg =
11758             bxe_extract_max_cfg(sc, sc->devinfo.mf_info.mf_config[SC_VN(sc)]);
11759
11760         /* calculate the current MAX line speed limit for the MF devices */
11761         if (IS_MF_SI(sc)) {
11762             line_speed = (line_speed * maxCfg) / 100;
11763         } else { /* SD mode */
11764             uint16_t vn_max_rate = maxCfg * 100;
11765
11766             if (vn_max_rate < line_speed) {
11767                 line_speed = vn_max_rate;
11768             }
11769         }
11770     }
11771
11772     return (line_speed);
11773 }
11774
11775 static void
11776 bxe_fill_report_data(struct bxe_softc            *sc,
11777                      struct bxe_link_report_data *data)
11778 {
11779     uint16_t line_speed = bxe_get_mf_speed(sc);
11780
11781     memset(data, 0, sizeof(*data));
11782
11783     /* fill the report data with the effective line speed */
11784     data->line_speed = line_speed;
11785
11786     /* Link is down */
11787     if (!sc->link_vars.link_up || (sc->flags & BXE_MF_FUNC_DIS)) {
11788         bxe_set_bit(BXE_LINK_REPORT_LINK_DOWN, &data->link_report_flags);
11789     }
11790
11791     /* Full DUPLEX */
11792     if (sc->link_vars.duplex == DUPLEX_FULL) {
11793         bxe_set_bit(BXE_LINK_REPORT_FULL_DUPLEX, &data->link_report_flags);
11794     }
11795
11796     /* Rx Flow Control is ON */
11797     if (sc->link_vars.flow_ctrl & ELINK_FLOW_CTRL_RX) {
11798         bxe_set_bit(BXE_LINK_REPORT_RX_FC_ON, &data->link_report_flags);
11799     }
11800
11801     /* Tx Flow Control is ON */
11802     if (sc->link_vars.flow_ctrl & ELINK_FLOW_CTRL_TX) {
11803         bxe_set_bit(BXE_LINK_REPORT_TX_FC_ON, &data->link_report_flags);
11804     }
11805 }
11806
11807 /* report link status to OS, should be called under phy_lock */
11808 static void
11809 bxe_link_report_locked(struct bxe_softc *sc)
11810 {
11811     struct bxe_link_report_data cur_data;
11812
11813     /* reread mf_cfg */
11814     if (IS_PF(sc) && !CHIP_IS_E1(sc)) {
11815         bxe_read_mf_cfg(sc);
11816     }
11817
11818     /* Read the current link report info */
11819     bxe_fill_report_data(sc, &cur_data);
11820
11821     /* Don't report link down or exactly the same link status twice */
11822     if (!memcmp(&cur_data, &sc->last_reported_link, sizeof(cur_data)) ||
11823         (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11824                       &sc->last_reported_link.link_report_flags) &&
11825          bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11826                       &cur_data.link_report_flags))) {
11827         return;
11828     }
11829
11830     sc->link_cnt++;
11831
11832     /* report new link params and remember the state for the next time */
11833     memcpy(&sc->last_reported_link, &cur_data, sizeof(cur_data));
11834
11835     if (bxe_test_bit(BXE_LINK_REPORT_LINK_DOWN,
11836                      &cur_data.link_report_flags)) {
11837         if_link_state_change(sc->ifnet, LINK_STATE_DOWN);
11838         BLOGI(sc, "NIC Link is Down\n");
11839     } else {
11840         const char *duplex;
11841         const char *flow;
11842
11843         if (bxe_test_and_clear_bit(BXE_LINK_REPORT_FULL_DUPLEX,
11844                                    &cur_data.link_report_flags)) {
11845             duplex = "full";
11846         } else {
11847             duplex = "half";
11848         }
11849
11850         /*
11851          * Handle the FC at the end so that only these flags would be
11852          * possibly set. This way we may easily check if there is no FC
11853          * enabled.
11854          */
11855         if (cur_data.link_report_flags) {
11856             if (bxe_test_bit(BXE_LINK_REPORT_RX_FC_ON,
11857                              &cur_data.link_report_flags) &&
11858                 bxe_test_bit(BXE_LINK_REPORT_TX_FC_ON,
11859                              &cur_data.link_report_flags)) {
11860                 flow = "ON - receive & transmit";
11861             } else if (bxe_test_bit(BXE_LINK_REPORT_RX_FC_ON,
11862                                     &cur_data.link_report_flags) &&
11863                        !bxe_test_bit(BXE_LINK_REPORT_TX_FC_ON,
11864                                      &cur_data.link_report_flags)) {
11865                 flow = "ON - receive";
11866             } else if (!bxe_test_bit(BXE_LINK_REPORT_RX_FC_ON,
11867                                      &cur_data.link_report_flags) &&
11868                        bxe_test_bit(BXE_LINK_REPORT_TX_FC_ON,
11869                                     &cur_data.link_report_flags)) {
11870                 flow = "ON - transmit";
11871             } else {
11872                 flow = "none"; /* possible? */
11873             }
11874         } else {
11875             flow = "none";
11876         }
11877
11878         if_link_state_change(sc->ifnet, LINK_STATE_UP);
11879         BLOGI(sc, "NIC Link is Up, %d Mbps %s duplex, Flow control: %s\n",
11880               cur_data.line_speed, duplex, flow);
11881     }
11882 }
11883
11884 static void
11885 bxe_link_report(struct bxe_softc *sc)
11886 {
11887     bxe_acquire_phy_lock(sc);
11888     bxe_link_report_locked(sc);
11889     bxe_release_phy_lock(sc);
11890 }
11891
11892 static void
11893 bxe_link_status_update(struct bxe_softc *sc)
11894 {
11895     if (sc->state != BXE_STATE_OPEN) {
11896         return;
11897     }
11898
11899     if (IS_PF(sc) && !CHIP_REV_IS_SLOW(sc)) {
11900         elink_link_status_update(&sc->link_params, &sc->link_vars);
11901     } else {
11902         sc->port.supported[0] |= (ELINK_SUPPORTED_10baseT_Half |
11903                                   ELINK_SUPPORTED_10baseT_Full |
11904                                   ELINK_SUPPORTED_100baseT_Half |
11905                                   ELINK_SUPPORTED_100baseT_Full |
11906                                   ELINK_SUPPORTED_1000baseT_Full |
11907                                   ELINK_SUPPORTED_2500baseX_Full |
11908                                   ELINK_SUPPORTED_10000baseT_Full |
11909                                   ELINK_SUPPORTED_TP |
11910                                   ELINK_SUPPORTED_FIBRE |
11911                                   ELINK_SUPPORTED_Autoneg |
11912                                   ELINK_SUPPORTED_Pause |
11913                                   ELINK_SUPPORTED_Asym_Pause);
11914         sc->port.advertising[0] = sc->port.supported[0];
11915
11916         sc->link_params.sc                = sc;
11917         sc->link_params.port              = SC_PORT(sc);
11918         sc->link_params.req_duplex[0]     = DUPLEX_FULL;
11919         sc->link_params.req_flow_ctrl[0]  = ELINK_FLOW_CTRL_NONE;
11920         sc->link_params.req_line_speed[0] = SPEED_10000;
11921         sc->link_params.speed_cap_mask[0] = 0x7f0000;
11922         sc->link_params.switch_cfg        = ELINK_SWITCH_CFG_10G;
11923
11924         if (CHIP_REV_IS_FPGA(sc)) {
11925             sc->link_vars.mac_type    = ELINK_MAC_TYPE_EMAC;
11926             sc->link_vars.line_speed  = ELINK_SPEED_1000;
11927             sc->link_vars.link_status = (LINK_STATUS_LINK_UP |
11928                                          LINK_STATUS_SPEED_AND_DUPLEX_1000TFD);
11929         } else {
11930             sc->link_vars.mac_type    = ELINK_MAC_TYPE_BMAC;
11931             sc->link_vars.line_speed  = ELINK_SPEED_10000;
11932             sc->link_vars.link_status = (LINK_STATUS_LINK_UP |
11933                                          LINK_STATUS_SPEED_AND_DUPLEX_10GTFD);
11934         }
11935
11936         sc->link_vars.link_up = 1;
11937
11938         sc->link_vars.duplex    = DUPLEX_FULL;
11939         sc->link_vars.flow_ctrl = ELINK_FLOW_CTRL_NONE;
11940
11941         if (IS_PF(sc)) {
11942             REG_WR(sc, NIG_REG_EGRESS_DRAIN0_MODE + sc->link_params.port*4, 0);
11943             bxe_stats_handle(sc, STATS_EVENT_LINK_UP);
11944             bxe_link_report(sc);
11945         }
11946     }
11947
11948     if (IS_PF(sc)) {
11949         if (sc->link_vars.link_up) {
11950             bxe_stats_handle(sc, STATS_EVENT_LINK_UP);
11951         } else {
11952             bxe_stats_handle(sc, STATS_EVENT_STOP);
11953         }
11954         bxe_link_report(sc);
11955     } else {
11956         bxe_link_report(sc);
11957         bxe_stats_handle(sc, STATS_EVENT_LINK_UP);
11958     }
11959 }
11960
11961 static int
11962 bxe_initial_phy_init(struct bxe_softc *sc,
11963                      int              load_mode)
11964 {
11965     int rc, cfg_idx = bxe_get_link_cfg_idx(sc);
11966     uint16_t req_line_speed = sc->link_params.req_line_speed[cfg_idx];
11967     struct elink_params *lp = &sc->link_params;
11968
11969     bxe_set_requested_fc(sc);
11970
11971     if (CHIP_REV_IS_SLOW(sc)) {
11972         uint32_t bond = CHIP_BOND_ID(sc);
11973         uint32_t feat = 0;
11974
11975         if (CHIP_IS_E2(sc) && CHIP_IS_MODE_4_PORT(sc)) {
11976             feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_BMAC;
11977         } else if (bond & 0x4) {
11978             if (CHIP_IS_E3(sc)) {
11979                 feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_XMAC;
11980             } else {
11981                 feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_BMAC;
11982             }
11983         } else if (bond & 0x8) {
11984             if (CHIP_IS_E3(sc)) {
11985                 feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_UMAC;
11986             } else {
11987                 feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_EMAC;
11988             }
11989         }
11990
11991         /* disable EMAC for E3 and above */
11992         if (bond & 0x2) {
11993             feat |= ELINK_FEATURE_CONFIG_EMUL_DISABLE_EMAC;
11994         }
11995
11996         sc->link_params.feature_config_flags |= feat;
11997     }
11998
11999     bxe_acquire_phy_lock(sc);
12000
12001     if (load_mode == LOAD_DIAG) {
12002         lp->loopback_mode = ELINK_LOOPBACK_XGXS;
12003         /* Prefer doing PHY loopback at 10G speed, if possible */
12004         if (lp->req_line_speed[cfg_idx] < ELINK_SPEED_10000) {
12005             if (lp->speed_cap_mask[cfg_idx] &
12006                 PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
12007                 lp->req_line_speed[cfg_idx] = ELINK_SPEED_10000;
12008             } else {
12009                 lp->req_line_speed[cfg_idx] = ELINK_SPEED_1000;
12010             }
12011         }
12012     }
12013
12014     if (load_mode == LOAD_LOOPBACK_EXT) {
12015         lp->loopback_mode = ELINK_LOOPBACK_EXT;
12016     }
12017
12018     rc = elink_phy_init(&sc->link_params, &sc->link_vars);
12019
12020     bxe_release_phy_lock(sc);
12021
12022     bxe_calc_fc_adv(sc);
12023
12024     if (sc->link_vars.link_up) {
12025         bxe_stats_handle(sc, STATS_EVENT_LINK_UP);
12026         bxe_link_report(sc);
12027     }
12028
12029     if (!CHIP_REV_IS_SLOW(sc)) {
12030         bxe_periodic_start(sc);
12031     }
12032
12033     sc->link_params.req_line_speed[cfg_idx] = req_line_speed;
12034     return (rc);
12035 }
12036
12037 /* must be called under IF_ADDR_LOCK */
12038 static int
12039 bxe_init_mcast_macs_list(struct bxe_softc                 *sc,
12040                          struct ecore_mcast_ramrod_params *p)
12041 {
12042     struct ifnet *ifp = sc->ifnet;
12043     int mc_count = 0;
12044     struct ifmultiaddr *ifma;
12045     struct ecore_mcast_list_elem *mc_mac;
12046
12047     TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
12048         if (ifma->ifma_addr->sa_family != AF_LINK) {
12049             continue;
12050         }
12051
12052         mc_count++;
12053     }
12054
12055     ECORE_LIST_INIT(&p->mcast_list);
12056     p->mcast_list_len = 0;
12057
12058     if (!mc_count) {
12059         return (0);
12060     }
12061
12062     mc_mac = malloc(sizeof(*mc_mac) * mc_count, M_DEVBUF,
12063                     (M_NOWAIT | M_ZERO));
12064     if (!mc_mac) {
12065         BLOGE(sc, "Failed to allocate temp mcast list\n");
12066         return (-1);
12067     }
12068     bzero(mc_mac, (sizeof(*mc_mac) * mc_count));
12069
12070     TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
12071         if (ifma->ifma_addr->sa_family != AF_LINK) {
12072             continue;
12073         }
12074
12075         mc_mac->mac = (uint8_t *)LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
12076         ECORE_LIST_PUSH_TAIL(&mc_mac->link, &p->mcast_list);
12077
12078         BLOGD(sc, DBG_LOAD,
12079               "Setting MCAST %02X:%02X:%02X:%02X:%02X:%02X\n",
12080               mc_mac->mac[0], mc_mac->mac[1], mc_mac->mac[2],
12081               mc_mac->mac[3], mc_mac->mac[4], mc_mac->mac[5]);
12082
12083         mc_mac++;
12084     }
12085
12086     p->mcast_list_len = mc_count;
12087
12088     return (0);
12089 }
12090
12091 static void
12092 bxe_free_mcast_macs_list(struct ecore_mcast_ramrod_params *p)
12093 {
12094     struct ecore_mcast_list_elem *mc_mac =
12095         ECORE_LIST_FIRST_ENTRY(&p->mcast_list,
12096                                struct ecore_mcast_list_elem,
12097                                link);
12098
12099     if (mc_mac) {
12100         /* only a single free as all mc_macs are in the same heap array */
12101         free(mc_mac, M_DEVBUF);
12102     }
12103 }
12104
12105 static int
12106 bxe_set_mc_list(struct bxe_softc *sc)
12107 {
12108     struct ecore_mcast_ramrod_params rparam = { NULL };
12109     int rc = 0;
12110
12111     rparam.mcast_obj = &sc->mcast_obj;
12112
12113     BXE_MCAST_LOCK(sc);
12114
12115     /* first, clear all configured multicast MACs */
12116     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
12117     if (rc < 0) {
12118         BLOGE(sc, "Failed to clear multicast configuration: %d\n", rc);
12119         BXE_MCAST_UNLOCK(sc);
12120         return (rc);
12121     }
12122
12123     /* configure a new MACs list */
12124     rc = bxe_init_mcast_macs_list(sc, &rparam);
12125     if (rc) {
12126         BLOGE(sc, "Failed to create mcast MACs list (%d)\n", rc);
12127         BXE_MCAST_UNLOCK(sc);
12128         return (rc);
12129     }
12130
12131     /* Now add the new MACs */
12132     rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_ADD);
12133     if (rc < 0) {
12134         BLOGE(sc, "Failed to set new mcast config (%d)\n", rc);
12135     }
12136
12137     bxe_free_mcast_macs_list(&rparam);
12138
12139     BXE_MCAST_UNLOCK(sc);
12140
12141     return (rc);
12142 }
12143
12144 static int
12145 bxe_set_uc_list(struct bxe_softc *sc)
12146 {
12147     struct ifnet *ifp = sc->ifnet;
12148     struct ecore_vlan_mac_obj *mac_obj = &sc->sp_objs->mac_obj;
12149     struct ifaddr *ifa;
12150     unsigned long ramrod_flags = 0;
12151     int rc;
12152
12153 #if __FreeBSD_version < 800000
12154     IF_ADDR_LOCK(ifp);
12155 #else
12156     if_addr_rlock(ifp);
12157 #endif
12158
12159     /* first schedule a cleanup up of old configuration */
12160     rc = bxe_del_all_macs(sc, mac_obj, ECORE_UC_LIST_MAC, FALSE);
12161     if (rc < 0) {
12162         BLOGE(sc, "Failed to schedule delete of all ETH MACs (%d)\n", rc);
12163 #if __FreeBSD_version < 800000
12164         IF_ADDR_UNLOCK(ifp);
12165 #else
12166         if_addr_runlock(ifp);
12167 #endif
12168         return (rc);
12169     }
12170
12171     ifa = ifp->if_addr;
12172     while (ifa) {
12173         if (ifa->ifa_addr->sa_family != AF_LINK) {
12174             ifa = TAILQ_NEXT(ifa, ifa_link);
12175             continue;
12176         }
12177
12178         rc = bxe_set_mac_one(sc, (uint8_t *)LLADDR((struct sockaddr_dl *)ifa->ifa_addr),
12179                              mac_obj, TRUE, ECORE_UC_LIST_MAC, &ramrod_flags);
12180         if (rc == -EEXIST) {
12181             BLOGD(sc, DBG_SP, "Failed to schedule ADD operations (EEXIST)\n");
12182             /* do not treat adding same MAC as an error */
12183             rc = 0;
12184         } else if (rc < 0) {
12185             BLOGE(sc, "Failed to schedule ADD operations (%d)\n", rc);
12186 #if __FreeBSD_version < 800000
12187             IF_ADDR_UNLOCK(ifp);
12188 #else
12189             if_addr_runlock(ifp);
12190 #endif
12191             return (rc);
12192         }
12193
12194         ifa = TAILQ_NEXT(ifa, ifa_link);
12195     }
12196
12197 #if __FreeBSD_version < 800000
12198     IF_ADDR_UNLOCK(ifp);
12199 #else
12200     if_addr_runlock(ifp);
12201 #endif
12202
12203     /* Execute the pending commands */
12204     bit_set(&ramrod_flags, RAMROD_CONT);
12205     return (bxe_set_mac_one(sc, NULL, mac_obj, FALSE /* don't care */,
12206                             ECORE_UC_LIST_MAC, &ramrod_flags));
12207 }
12208
12209 static void
12210 bxe_set_rx_mode(struct bxe_softc *sc)
12211 {
12212     struct ifnet *ifp = sc->ifnet;
12213     uint32_t rx_mode = BXE_RX_MODE_NORMAL;
12214
12215     if (sc->state != BXE_STATE_OPEN) {
12216         BLOGD(sc, DBG_SP, "state is %x, returning\n", sc->state);
12217         return;
12218     }
12219
12220     BLOGD(sc, DBG_SP, "ifp->if_flags=0x%x\n", ifp->if_flags);
12221
12222     if (ifp->if_flags & IFF_PROMISC) {
12223         rx_mode = BXE_RX_MODE_PROMISC;
12224     } else if ((ifp->if_flags & IFF_ALLMULTI) ||
12225                ((ifp->if_amcount > BXE_MAX_MULTICAST) &&
12226                 CHIP_IS_E1(sc))) {
12227         rx_mode = BXE_RX_MODE_ALLMULTI;
12228     } else {
12229         if (IS_PF(sc)) {
12230             /* some multicasts */
12231             if (bxe_set_mc_list(sc) < 0) {
12232                 rx_mode = BXE_RX_MODE_ALLMULTI;
12233             }
12234             if (bxe_set_uc_list(sc) < 0) {
12235                 rx_mode = BXE_RX_MODE_PROMISC;
12236             }
12237         }
12238     }
12239
12240     sc->rx_mode = rx_mode;
12241
12242     /* schedule the rx_mode command */
12243     if (bxe_test_bit(ECORE_FILTER_RX_MODE_PENDING, &sc->sp_state)) {
12244         BLOGD(sc, DBG_LOAD, "Scheduled setting rx_mode with ECORE...\n");
12245         bxe_set_bit(ECORE_FILTER_RX_MODE_SCHED, &sc->sp_state);
12246         return;
12247     }
12248
12249     if (IS_PF(sc)) {
12250         bxe_set_storm_rx_mode(sc);
12251     }
12252 }
12253
12254
12255 /* update flags in shmem */
12256 static void
12257 bxe_update_drv_flags(struct bxe_softc *sc,
12258                      uint32_t         flags,
12259                      uint32_t         set)
12260 {
12261     uint32_t drv_flags;
12262
12263     if (SHMEM2_HAS(sc, drv_flags)) {
12264         bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_DRV_FLAGS);
12265         drv_flags = SHMEM2_RD(sc, drv_flags);
12266
12267         if (set) {
12268             SET_FLAGS(drv_flags, flags);
12269         } else {
12270             RESET_FLAGS(drv_flags, flags);
12271         }
12272
12273         SHMEM2_WR(sc, drv_flags, drv_flags);
12274         BLOGD(sc, DBG_LOAD, "drv_flags 0x%08x\n", drv_flags);
12275
12276         bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_DRV_FLAGS);
12277     }
12278 }
12279
12280 /* periodic timer callout routine, only runs when the interface is up */
12281
12282 static void
12283 bxe_periodic_callout_func(void *xsc)
12284 {
12285     struct bxe_softc *sc = (struct bxe_softc *)xsc;
12286     int i;
12287
12288     if (!BXE_CORE_TRYLOCK(sc)) {
12289         /* just bail and try again next time */
12290
12291         if ((sc->state == BXE_STATE_OPEN) &&
12292             (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
12293             /* schedule the next periodic callout */
12294             callout_reset(&sc->periodic_callout, hz,
12295                           bxe_periodic_callout_func, sc);
12296         }
12297
12298         return;
12299     }
12300
12301     if ((sc->state != BXE_STATE_OPEN) ||
12302         (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_STOP)) {
12303         BLOGW(sc, "periodic callout exit (state=0x%x)\n", sc->state);
12304         BXE_CORE_UNLOCK(sc);
12305         return;
12306     }
12307
12308     /* Check for TX timeouts on any fastpath. */
12309     FOR_EACH_QUEUE(sc, i) {
12310         if (bxe_watchdog(sc, &sc->fp[i]) != 0) {
12311             /* Ruh-Roh, chip was reset! */
12312             break;
12313         }
12314     }
12315
12316     if (!CHIP_REV_IS_SLOW(sc)) {
12317         /*
12318          * This barrier is needed to ensure the ordering between the writing
12319          * to the sc->port.pmf in the bxe_nic_load() or bxe_pmf_update() and
12320          * the reading here.
12321          */
12322         mb();
12323         if (sc->port.pmf) {
12324             bxe_acquire_phy_lock(sc);
12325             elink_period_func(&sc->link_params, &sc->link_vars);
12326             bxe_release_phy_lock(sc);
12327         }
12328     }
12329
12330     if (IS_PF(sc) && !(sc->flags & BXE_NO_PULSE)) {
12331         int mb_idx = SC_FW_MB_IDX(sc);
12332         uint32_t drv_pulse;
12333         uint32_t mcp_pulse;
12334
12335         ++sc->fw_drv_pulse_wr_seq;
12336         sc->fw_drv_pulse_wr_seq &= DRV_PULSE_SEQ_MASK;
12337
12338         drv_pulse = sc->fw_drv_pulse_wr_seq;
12339         bxe_drv_pulse(sc);
12340
12341         mcp_pulse = (SHMEM_RD(sc, func_mb[mb_idx].mcp_pulse_mb) &
12342                      MCP_PULSE_SEQ_MASK);
12343
12344         /*
12345          * The delta between driver pulse and mcp response should
12346          * be 1 (before mcp response) or 0 (after mcp response).
12347          */
12348         if ((drv_pulse != mcp_pulse) &&
12349             (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
12350             /* someone lost a heartbeat... */
12351             BLOGE(sc, "drv_pulse (0x%x) != mcp_pulse (0x%x)\n",
12352                   drv_pulse, mcp_pulse);
12353         }
12354     }
12355
12356     /* state is BXE_STATE_OPEN */
12357     bxe_stats_handle(sc, STATS_EVENT_UPDATE);
12358
12359     BXE_CORE_UNLOCK(sc);
12360
12361     if ((sc->state == BXE_STATE_OPEN) &&
12362         (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO)) {
12363         /* schedule the next periodic callout */
12364         callout_reset(&sc->periodic_callout, hz,
12365                       bxe_periodic_callout_func, sc);
12366     }
12367 }
12368
12369 static void
12370 bxe_periodic_start(struct bxe_softc *sc)
12371 {
12372     atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
12373     callout_reset(&sc->periodic_callout, hz, bxe_periodic_callout_func, sc);
12374 }
12375
12376 static void
12377 bxe_periodic_stop(struct bxe_softc *sc)
12378 {
12379     atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
12380     callout_drain(&sc->periodic_callout);
12381 }
12382
12383 /* start the controller */
12384 static __noinline int
12385 bxe_nic_load(struct bxe_softc *sc,
12386              int              load_mode)
12387 {
12388     uint32_t val;
12389     int load_code = 0;
12390     int i, rc = 0;
12391
12392     BXE_CORE_LOCK_ASSERT(sc);
12393
12394     BLOGD(sc, DBG_LOAD, "Starting NIC load...\n");
12395
12396     sc->state = BXE_STATE_OPENING_WAITING_LOAD;
12397
12398     if (IS_PF(sc)) {
12399         /* must be called before memory allocation and HW init */
12400         bxe_ilt_set_info(sc);
12401     }
12402
12403     sc->last_reported_link_state = LINK_STATE_UNKNOWN;
12404
12405     bxe_set_fp_rx_buf_size(sc);
12406
12407     if (bxe_alloc_fp_buffers(sc) != 0) {
12408         BLOGE(sc, "Failed to allocate fastpath memory\n");
12409         sc->state = BXE_STATE_CLOSED;
12410         rc = ENOMEM;
12411         goto bxe_nic_load_error0;
12412     }
12413
12414     if (bxe_alloc_mem(sc) != 0) {
12415         sc->state = BXE_STATE_CLOSED;
12416         rc = ENOMEM;
12417         goto bxe_nic_load_error0;
12418     }
12419
12420     if (bxe_alloc_fw_stats_mem(sc) != 0) {
12421         sc->state = BXE_STATE_CLOSED;
12422         rc = ENOMEM;
12423         goto bxe_nic_load_error0;
12424     }
12425
12426     if (IS_PF(sc)) {
12427         /* set pf load just before approaching the MCP */
12428         bxe_set_pf_load(sc);
12429
12430         /* if MCP exists send load request and analyze response */
12431         if (!BXE_NOMCP(sc)) {
12432             /* attempt to load pf */
12433             if (bxe_nic_load_request(sc, &load_code) != 0) {
12434                 sc->state = BXE_STATE_CLOSED;
12435                 rc = ENXIO;
12436                 goto bxe_nic_load_error1;
12437             }
12438
12439             /* what did the MCP say? */
12440             if (bxe_nic_load_analyze_req(sc, load_code) != 0) {
12441                 bxe_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
12442                 sc->state = BXE_STATE_CLOSED;
12443                 rc = ENXIO;
12444                 goto bxe_nic_load_error2;
12445             }
12446         } else {
12447             BLOGI(sc, "Device has no MCP!\n");
12448             load_code = bxe_nic_load_no_mcp(sc);
12449         }
12450
12451         /* mark PMF if applicable */
12452         bxe_nic_load_pmf(sc, load_code);
12453
12454         /* Init Function state controlling object */
12455         bxe_init_func_obj(sc);
12456
12457         /* Initialize HW */
12458         if (bxe_init_hw(sc, load_code) != 0) {
12459             BLOGE(sc, "HW init failed\n");
12460             bxe_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
12461             sc->state = BXE_STATE_CLOSED;
12462             rc = ENXIO;
12463             goto bxe_nic_load_error2;
12464         }
12465     }
12466
12467     /* set ALWAYS_ALIVE bit in shmem */
12468     sc->fw_drv_pulse_wr_seq |= DRV_PULSE_ALWAYS_ALIVE;
12469     bxe_drv_pulse(sc);
12470     sc->flags |= BXE_NO_PULSE;
12471
12472     /* attach interrupts */
12473     if (bxe_interrupt_attach(sc) != 0) {
12474         sc->state = BXE_STATE_CLOSED;
12475         rc = ENXIO;
12476         goto bxe_nic_load_error2;
12477     }
12478
12479     bxe_nic_init(sc, load_code);
12480
12481     /* Init per-function objects */
12482     if (IS_PF(sc)) {
12483         bxe_init_objs(sc);
12484         // XXX bxe_iov_nic_init(sc);
12485
12486         /* set AFEX default VLAN tag to an invalid value */
12487         sc->devinfo.mf_info.afex_def_vlan_tag = -1;
12488         // XXX bxe_nic_load_afex_dcc(sc, load_code);
12489
12490         sc->state = BXE_STATE_OPENING_WAITING_PORT;
12491         rc = bxe_func_start(sc);
12492         if (rc) {
12493             BLOGE(sc, "Function start failed! rc = %d\n", rc);
12494             bxe_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
12495             sc->state = BXE_STATE_ERROR;
12496             goto bxe_nic_load_error3;
12497         }
12498
12499         /* send LOAD_DONE command to MCP */
12500         if (!BXE_NOMCP(sc)) {
12501             load_code = bxe_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
12502             if (!load_code) {
12503                 BLOGE(sc, "MCP response failure, aborting\n");
12504                 sc->state = BXE_STATE_ERROR;
12505                 rc = ENXIO;
12506                 goto bxe_nic_load_error3;
12507             }
12508         }
12509
12510         rc = bxe_setup_leading(sc);
12511         if (rc) {
12512             BLOGE(sc, "Setup leading failed! rc = %d\n", rc);
12513             sc->state = BXE_STATE_ERROR;
12514             goto bxe_nic_load_error3;
12515         }
12516
12517         FOR_EACH_NONDEFAULT_ETH_QUEUE(sc, i) {
12518             rc = bxe_setup_queue(sc, &sc->fp[i], FALSE);
12519             if (rc) {
12520                 BLOGE(sc, "Queue(%d) setup failed rc = %d\n", i, rc);
12521                 sc->state = BXE_STATE_ERROR;
12522                 goto bxe_nic_load_error3;
12523             }
12524         }
12525
12526         rc = bxe_init_rss_pf(sc);
12527         if (rc) {
12528             BLOGE(sc, "PF RSS init failed\n");
12529             sc->state = BXE_STATE_ERROR;
12530             goto bxe_nic_load_error3;
12531         }
12532     }
12533     /* XXX VF */
12534
12535     /* now when Clients are configured we are ready to work */
12536     sc->state = BXE_STATE_OPEN;
12537
12538     /* Configure a ucast MAC */
12539     if (IS_PF(sc)) {
12540         rc = bxe_set_eth_mac(sc, TRUE);
12541     }
12542     if (rc) {
12543         BLOGE(sc, "Setting Ethernet MAC failed rc = %d\n", rc);
12544         sc->state = BXE_STATE_ERROR;
12545         goto bxe_nic_load_error3;
12546     }
12547
12548     if (sc->port.pmf) {
12549         rc = bxe_initial_phy_init(sc, /* XXX load_mode */LOAD_OPEN);
12550         if (rc) {
12551             sc->state = BXE_STATE_ERROR;
12552             goto bxe_nic_load_error3;
12553         }
12554     }
12555
12556     sc->link_params.feature_config_flags &=
12557         ~ELINK_FEATURE_CONFIG_BOOT_FROM_SAN;
12558
12559     /* start fast path */
12560
12561     /* Initialize Rx filter */
12562     bxe_set_rx_mode(sc);
12563
12564     /* start the Tx */
12565     switch (/* XXX load_mode */LOAD_OPEN) {
12566     case LOAD_NORMAL:
12567     case LOAD_OPEN:
12568         break;
12569
12570     case LOAD_DIAG:
12571     case LOAD_LOOPBACK_EXT:
12572         sc->state = BXE_STATE_DIAG;
12573         break;
12574
12575     default:
12576         break;
12577     }
12578
12579     if (sc->port.pmf) {
12580         bxe_update_drv_flags(sc, 1 << DRV_FLAGS_PORT_MASK, 0);
12581     } else {
12582         bxe_link_status_update(sc);
12583     }
12584
12585     /* start the periodic timer callout */
12586     bxe_periodic_start(sc);
12587
12588     if (IS_PF(sc) && SHMEM2_HAS(sc, drv_capabilities_flag)) {
12589         /* mark driver is loaded in shmem2 */
12590         val = SHMEM2_RD(sc, drv_capabilities_flag[SC_FW_MB_IDX(sc)]);
12591         SHMEM2_WR(sc, drv_capabilities_flag[SC_FW_MB_IDX(sc)],
12592                   (val |
12593                    DRV_FLAGS_CAPABILITIES_LOADED_SUPPORTED |
12594                    DRV_FLAGS_CAPABILITIES_LOADED_L2));
12595     }
12596
12597     /* wait for all pending SP commands to complete */
12598     if (IS_PF(sc) && !bxe_wait_sp_comp(sc, ~0x0UL)) {
12599         BLOGE(sc, "Timeout waiting for all SPs to complete!\n");
12600         bxe_periodic_stop(sc);
12601         bxe_nic_unload(sc, UNLOAD_CLOSE, FALSE);
12602         return (ENXIO);
12603     }
12604
12605     /* Tell the stack the driver is running! */
12606     sc->ifnet->if_drv_flags = IFF_DRV_RUNNING;
12607
12608     BLOGD(sc, DBG_LOAD, "NIC successfully loaded\n");
12609
12610     return (0);
12611
12612 bxe_nic_load_error3:
12613
12614     if (IS_PF(sc)) {
12615         bxe_int_disable_sync(sc, 1);
12616
12617         /* clean out queued objects */
12618         bxe_squeeze_objects(sc);
12619     }
12620
12621     bxe_interrupt_detach(sc);
12622
12623 bxe_nic_load_error2:
12624
12625     if (IS_PF(sc) && !BXE_NOMCP(sc)) {
12626         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP, 0);
12627         bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE, 0);
12628     }
12629
12630     sc->port.pmf = 0;
12631
12632 bxe_nic_load_error1:
12633
12634     /* clear pf_load status, as it was already set */
12635     if (IS_PF(sc)) {
12636         bxe_clear_pf_load(sc);
12637     }
12638
12639 bxe_nic_load_error0:
12640
12641     bxe_free_fw_stats_mem(sc);
12642     bxe_free_fp_buffers(sc);
12643     bxe_free_mem(sc);
12644
12645     return (rc);
12646 }
12647
12648 static int
12649 bxe_init_locked(struct bxe_softc *sc)
12650 {
12651     int other_engine = SC_PATH(sc) ? 0 : 1;
12652     uint8_t other_load_status, load_status;
12653     uint8_t global = FALSE;
12654     int rc;
12655
12656     BXE_CORE_LOCK_ASSERT(sc);
12657
12658     /* check if the driver is already running */
12659     if (sc->ifnet->if_drv_flags & IFF_DRV_RUNNING) {
12660         BLOGD(sc, DBG_LOAD, "Init called while driver is running!\n");
12661         return (0);
12662     }
12663
12664     bxe_set_power_state(sc, PCI_PM_D0);
12665
12666     /*
12667      * If parity occurred during the unload, then attentions and/or
12668      * RECOVERY_IN_PROGRES may still be set. If so we want the first function
12669      * loaded on the current engine to complete the recovery. Parity recovery
12670      * is only relevant for PF driver.
12671      */
12672     if (IS_PF(sc)) {
12673         other_load_status = bxe_get_load_status(sc, other_engine);
12674         load_status = bxe_get_load_status(sc, SC_PATH(sc));
12675
12676         if (!bxe_reset_is_done(sc, SC_PATH(sc)) ||
12677             bxe_chk_parity_attn(sc, &global, TRUE)) {
12678             do {
12679                 /*
12680                  * If there are attentions and they are in global blocks, set
12681                  * the GLOBAL_RESET bit regardless whether it will be this
12682                  * function that will complete the recovery or not.
12683                  */
12684                 if (global) {
12685                     bxe_set_reset_global(sc);
12686                 }
12687
12688                 /*
12689                  * Only the first function on the current engine should try
12690                  * to recover in open. In case of attentions in global blocks
12691                  * only the first in the chip should try to recover.
12692                  */
12693                 if ((!load_status && (!global || !other_load_status)) &&
12694                     bxe_trylock_leader_lock(sc) && !bxe_leader_reset(sc)) {
12695                     BLOGI(sc, "Recovered during init\n");
12696                     break;
12697                 }
12698
12699                 /* recovery has failed... */
12700                 bxe_set_power_state(sc, PCI_PM_D3hot);
12701                 sc->recovery_state = BXE_RECOVERY_FAILED;
12702
12703                 BLOGE(sc, "Recovery flow hasn't properly "
12704                           "completed yet, try again later. "
12705                           "If you still see this message after a "
12706                           "few retries then power cycle is required.\n");
12707
12708                 rc = ENXIO;
12709                 goto bxe_init_locked_done;
12710             } while (0);
12711         }
12712     }
12713
12714     sc->recovery_state = BXE_RECOVERY_DONE;
12715
12716     rc = bxe_nic_load(sc, LOAD_OPEN);
12717
12718 bxe_init_locked_done:
12719
12720     if (rc) {
12721         /* Tell the stack the driver is NOT running! */
12722         BLOGE(sc, "Initialization failed, "
12723                   "stack notified driver is NOT running!\n");
12724         sc->ifnet->if_drv_flags &= ~IFF_DRV_RUNNING;
12725     }
12726
12727     return (rc);
12728 }
12729
12730 static int
12731 bxe_stop_locked(struct bxe_softc *sc)
12732 {
12733     BXE_CORE_LOCK_ASSERT(sc);
12734     return (bxe_nic_unload(sc, UNLOAD_NORMAL, TRUE));
12735 }
12736
12737 /*
12738  * Handles controller initialization when called from an unlocked routine.
12739  * ifconfig calls this function.
12740  *
12741  * Returns:
12742  *   void
12743  */
12744 static void
12745 bxe_init(void *xsc)
12746 {
12747     struct bxe_softc *sc = (struct bxe_softc *)xsc;
12748
12749     BXE_CORE_LOCK(sc);
12750     bxe_init_locked(sc);
12751     BXE_CORE_UNLOCK(sc);
12752 }
12753
12754 static int
12755 bxe_init_ifnet(struct bxe_softc *sc)
12756 {
12757     struct ifnet *ifp;
12758
12759     /* ifconfig entrypoint for media type/status reporting */
12760     ifmedia_init(&sc->ifmedia, IFM_IMASK,
12761                  bxe_ifmedia_update,
12762                  bxe_ifmedia_status);
12763
12764     /* set the default interface values */
12765     ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_FDX | sc->media), 0, NULL);
12766     ifmedia_add(&sc->ifmedia, (IFM_ETHER | IFM_AUTO), 0, NULL);
12767     ifmedia_set(&sc->ifmedia, (IFM_ETHER | IFM_AUTO));
12768
12769     sc->ifmedia.ifm_media = sc->ifmedia.ifm_cur->ifm_media; /* XXX ? */
12770
12771     /* allocate the ifnet structure */
12772     if ((ifp = if_alloc(IFT_ETHER)) == NULL) {
12773         BLOGE(sc, "Interface allocation failed!\n");
12774         return (ENXIO);
12775     }
12776
12777     ifp->if_softc = sc;
12778     if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
12779     ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
12780     ifp->if_ioctl = bxe_ioctl;
12781     ifp->if_start = bxe_tx_start;
12782 #if __FreeBSD_version >= 800000
12783     ifp->if_transmit = bxe_tx_mq_start;
12784     ifp->if_qflush = bxe_mq_flush;
12785 #endif
12786 #ifdef FreeBSD8_0
12787     ifp->if_timer = 0;
12788 #endif
12789     ifp->if_init = bxe_init;
12790     ifp->if_mtu = sc->mtu;
12791     ifp->if_hwassist = (CSUM_IP       |
12792                         CSUM_TCP      |
12793                         CSUM_UDP      |
12794                         CSUM_TSO      |
12795                         CSUM_TCP_IPV6 |
12796                         CSUM_UDP_IPV6);
12797     ifp->if_capabilities =
12798 #if __FreeBSD_version < 700000
12799         (IFCAP_VLAN_MTU       |
12800          IFCAP_VLAN_HWTAGGING |
12801          IFCAP_HWCSUM         |
12802          IFCAP_JUMBO_MTU      |
12803          IFCAP_LRO);
12804 #else
12805         (IFCAP_VLAN_MTU       |
12806          IFCAP_VLAN_HWTAGGING |
12807          IFCAP_VLAN_HWTSO     |
12808          IFCAP_VLAN_HWFILTER  |
12809          IFCAP_VLAN_HWCSUM    |
12810          IFCAP_HWCSUM         |
12811          IFCAP_JUMBO_MTU      |
12812          IFCAP_LRO            |
12813          IFCAP_TSO4           |
12814          IFCAP_TSO6           |
12815          IFCAP_WOL_MAGIC);
12816 #endif
12817     ifp->if_capenable = ifp->if_capabilities;
12818     ifp->if_capenable &= ~IFCAP_WOL_MAGIC; /* XXX not yet... */
12819 #if __FreeBSD_version < 1000025
12820     ifp->if_baudrate = 1000000000;
12821 #else
12822     if_initbaudrate(ifp, IF_Gbps(10));
12823 #endif
12824     ifp->if_snd.ifq_drv_maxlen = sc->tx_ring_size;
12825
12826     IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen);
12827     IFQ_SET_READY(&ifp->if_snd);
12828
12829     sc->ifnet = ifp;
12830
12831     /* attach to the Ethernet interface list */
12832     ether_ifattach(ifp, sc->link_params.mac_addr);
12833
12834     return (0);
12835 }
12836
12837 static void
12838 bxe_deallocate_bars(struct bxe_softc *sc)
12839 {
12840     int i;
12841
12842     for (i = 0; i < MAX_BARS; i++) {
12843         if (sc->bar[i].resource != NULL) {
12844             bus_release_resource(sc->dev,
12845                                  SYS_RES_MEMORY,
12846                                  sc->bar[i].rid,
12847                                  sc->bar[i].resource);
12848             BLOGD(sc, DBG_LOAD, "Released PCI BAR%d [%02x] memory\n",
12849                   i, PCIR_BAR(i));
12850         }
12851     }
12852 }
12853
12854 static int
12855 bxe_allocate_bars(struct bxe_softc *sc)
12856 {
12857     u_int flags;
12858     int i;
12859
12860     memset(sc->bar, 0, sizeof(sc->bar));
12861
12862     for (i = 0; i < MAX_BARS; i++) {
12863
12864         /* memory resources reside at BARs 0, 2, 4 */
12865         /* Run `pciconf -lb` to see mappings */
12866         if ((i != 0) && (i != 2) && (i != 4)) {
12867             continue;
12868         }
12869
12870         sc->bar[i].rid = PCIR_BAR(i);
12871
12872         flags = RF_ACTIVE;
12873         if (i == 0) {
12874             flags |= RF_SHAREABLE;
12875         }
12876
12877         if ((sc->bar[i].resource =
12878              bus_alloc_resource_any(sc->dev,
12879                                     SYS_RES_MEMORY,
12880                                     &sc->bar[i].rid,
12881                                     flags)) == NULL) {
12882             return (0);
12883         }
12884
12885         sc->bar[i].tag    = rman_get_bustag(sc->bar[i].resource);
12886         sc->bar[i].handle = rman_get_bushandle(sc->bar[i].resource);
12887         sc->bar[i].kva    = (vm_offset_t)rman_get_virtual(sc->bar[i].resource);
12888
12889         BLOGI(sc, "PCI BAR%d [%02x] memory allocated: %p-%p (%ld) -> %p\n",
12890               i, PCIR_BAR(i),
12891               (void *)rman_get_start(sc->bar[i].resource),
12892               (void *)rman_get_end(sc->bar[i].resource),
12893               rman_get_size(sc->bar[i].resource),
12894               (void *)sc->bar[i].kva);
12895     }
12896
12897     return (0);
12898 }
12899
12900 static void
12901 bxe_get_function_num(struct bxe_softc *sc)
12902 {
12903     uint32_t val = 0;
12904
12905     /*
12906      * Read the ME register to get the function number. The ME register
12907      * holds the relative-function number and absolute-function number. The
12908      * absolute-function number appears only in E2 and above. Before that
12909      * these bits always contained zero, therefore we cannot blindly use them.
12910      */
12911
12912     val = REG_RD(sc, BAR_ME_REGISTER);
12913
12914     sc->pfunc_rel =
12915         (uint8_t)((val & ME_REG_PF_NUM) >> ME_REG_PF_NUM_SHIFT);
12916     sc->path_id =
12917         (uint8_t)((val & ME_REG_ABS_PF_NUM) >> ME_REG_ABS_PF_NUM_SHIFT) & 1;
12918
12919     if (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) {
12920         sc->pfunc_abs = ((sc->pfunc_rel << 1) | sc->path_id);
12921     } else {
12922         sc->pfunc_abs = (sc->pfunc_rel | sc->path_id);
12923     }
12924
12925     BLOGD(sc, DBG_LOAD,
12926           "Relative function %d, Absolute function %d, Path %d\n",
12927           sc->pfunc_rel, sc->pfunc_abs, sc->path_id);
12928 }
12929
12930 static uint32_t
12931 bxe_get_shmem_mf_cfg_base(struct bxe_softc *sc)
12932 {
12933     uint32_t shmem2_size;
12934     uint32_t offset;
12935     uint32_t mf_cfg_offset_value;
12936
12937     /* Non 57712 */
12938     offset = (SHMEM_RD(sc, func_mb) +
12939               (MAX_FUNC_NUM * sizeof(struct drv_func_mb)));
12940
12941     /* 57712 plus */
12942     if (sc->devinfo.shmem2_base != 0) {
12943         shmem2_size = SHMEM2_RD(sc, size);
12944         if (shmem2_size > offsetof(struct shmem2_region, mf_cfg_addr)) {
12945             mf_cfg_offset_value = SHMEM2_RD(sc, mf_cfg_addr);
12946             if (SHMEM_MF_CFG_ADDR_NONE != mf_cfg_offset_value) {
12947                 offset = mf_cfg_offset_value;
12948             }
12949         }
12950     }
12951
12952     return (offset);
12953 }
12954
12955 static uint32_t
12956 bxe_pcie_capability_read(struct bxe_softc *sc,
12957                          int    reg,
12958                          int    width)
12959 {
12960     int pcie_reg;
12961
12962     /* ensure PCIe capability is enabled */
12963     if (pci_find_cap(sc->dev, PCIY_EXPRESS, &pcie_reg) == 0) {
12964         if (pcie_reg != 0) {
12965             BLOGD(sc, DBG_LOAD, "PCIe capability at 0x%04x\n", pcie_reg);
12966             return (pci_read_config(sc->dev, (pcie_reg + reg), width));
12967         }
12968     }
12969
12970     BLOGE(sc, "PCIe capability NOT FOUND!!!\n");
12971
12972     return (0);
12973 }
12974
12975 static uint8_t
12976 bxe_is_pcie_pending(struct bxe_softc *sc)
12977 {
12978     return (bxe_pcie_capability_read(sc, PCIR_EXPRESS_DEVICE_STA, 2) &
12979             PCIM_EXP_STA_TRANSACTION_PND);
12980 }
12981
12982 /*
12983  * Walk the PCI capabiites list for the device to find what features are
12984  * supported. These capabilites may be enabled/disabled by firmware so it's
12985  * best to walk the list rather than make assumptions.
12986  */
12987 static void
12988 bxe_probe_pci_caps(struct bxe_softc *sc)
12989 {
12990     uint16_t link_status;
12991     int reg;
12992
12993     /* check if PCI Power Management is enabled */
12994     if (pci_find_cap(sc->dev, PCIY_PMG, &reg) == 0) {
12995         if (reg != 0) {
12996             BLOGD(sc, DBG_LOAD, "Found PM capability at 0x%04x\n", reg);
12997
12998             sc->devinfo.pcie_cap_flags |= BXE_PM_CAPABLE_FLAG;
12999             sc->devinfo.pcie_pm_cap_reg = (uint16_t)reg;
13000         }
13001     }
13002
13003     link_status = bxe_pcie_capability_read(sc, PCIR_EXPRESS_LINK_STA, 2);
13004
13005     /* handle PCIe 2.0 workarounds for 57710 */
13006     if (CHIP_IS_E1(sc)) {
13007         /* workaround for 57710 errata E4_57710_27462 */
13008         sc->devinfo.pcie_link_speed =
13009             (REG_RD(sc, 0x3d04) & (1 << 24)) ? 2 : 1;
13010
13011         /* workaround for 57710 errata E4_57710_27488 */
13012         sc->devinfo.pcie_link_width =
13013             ((link_status & PCIM_LINK_STA_WIDTH) >> 4);
13014         if (sc->devinfo.pcie_link_speed > 1) {
13015             sc->devinfo.pcie_link_width =
13016                 ((link_status & PCIM_LINK_STA_WIDTH) >> 4) >> 1;
13017         }
13018     } else {
13019         sc->devinfo.pcie_link_speed =
13020             (link_status & PCIM_LINK_STA_SPEED);
13021         sc->devinfo.pcie_link_width =
13022             ((link_status & PCIM_LINK_STA_WIDTH) >> 4);
13023     }
13024
13025     BLOGD(sc, DBG_LOAD, "PCIe link speed=%d width=%d\n",
13026           sc->devinfo.pcie_link_speed, sc->devinfo.pcie_link_width);
13027
13028     sc->devinfo.pcie_cap_flags |= BXE_PCIE_CAPABLE_FLAG;
13029     sc->devinfo.pcie_pcie_cap_reg = (uint16_t)reg;
13030
13031     /* check if MSI capability is enabled */
13032     if (pci_find_cap(sc->dev, PCIY_MSI, &reg) == 0) {
13033         if (reg != 0) {
13034             BLOGD(sc, DBG_LOAD, "Found MSI capability at 0x%04x\n", reg);
13035
13036             sc->devinfo.pcie_cap_flags |= BXE_MSI_CAPABLE_FLAG;
13037             sc->devinfo.pcie_msi_cap_reg = (uint16_t)reg;
13038         }
13039     }
13040
13041     /* check if MSI-X capability is enabled */
13042     if (pci_find_cap(sc->dev, PCIY_MSIX, &reg) == 0) {
13043         if (reg != 0) {
13044             BLOGD(sc, DBG_LOAD, "Found MSI-X capability at 0x%04x\n", reg);
13045
13046             sc->devinfo.pcie_cap_flags |= BXE_MSIX_CAPABLE_FLAG;
13047             sc->devinfo.pcie_msix_cap_reg = (uint16_t)reg;
13048         }
13049     }
13050 }
13051
13052 static int
13053 bxe_get_shmem_mf_cfg_info_sd(struct bxe_softc *sc)
13054 {
13055     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
13056     uint32_t val;
13057
13058     /* get the outer vlan if we're in switch-dependent mode */
13059
13060     val = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].e1hov_tag);
13061     mf_info->ext_id = (uint16_t)val;
13062
13063     mf_info->multi_vnics_mode = 1;
13064
13065     if (!VALID_OVLAN(mf_info->ext_id)) {
13066         BLOGE(sc, "Invalid VLAN (%d)\n", mf_info->ext_id);
13067         return (1);
13068     }
13069
13070     /* get the capabilities */
13071     if ((mf_info->mf_config[SC_VN(sc)] & FUNC_MF_CFG_PROTOCOL_MASK) ==
13072         FUNC_MF_CFG_PROTOCOL_ISCSI) {
13073         mf_info->mf_protos_supported |= MF_PROTO_SUPPORT_ISCSI;
13074     } else if ((mf_info->mf_config[SC_VN(sc)] & FUNC_MF_CFG_PROTOCOL_MASK) ==
13075                FUNC_MF_CFG_PROTOCOL_FCOE) {
13076         mf_info->mf_protos_supported |= MF_PROTO_SUPPORT_FCOE;
13077     } else {
13078         mf_info->mf_protos_supported |= MF_PROTO_SUPPORT_ETHERNET;
13079     }
13080
13081     mf_info->vnics_per_port =
13082         (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) ? 2 : 4;
13083
13084     return (0);
13085 }
13086
13087 static uint32_t
13088 bxe_get_shmem_ext_proto_support_flags(struct bxe_softc *sc)
13089 {
13090     uint32_t retval = 0;
13091     uint32_t val;
13092
13093     val = MFCFG_RD(sc, func_ext_config[SC_ABS_FUNC(sc)].func_cfg);
13094
13095     if (val & MACP_FUNC_CFG_FLAGS_ENABLED) {
13096         if (val & MACP_FUNC_CFG_FLAGS_ETHERNET) {
13097             retval |= MF_PROTO_SUPPORT_ETHERNET;
13098         }
13099         if (val & MACP_FUNC_CFG_FLAGS_ISCSI_OFFLOAD) {
13100             retval |= MF_PROTO_SUPPORT_ISCSI;
13101         }
13102         if (val & MACP_FUNC_CFG_FLAGS_FCOE_OFFLOAD) {
13103             retval |= MF_PROTO_SUPPORT_FCOE;
13104         }
13105     }
13106
13107     return (retval);
13108 }
13109
13110 static int
13111 bxe_get_shmem_mf_cfg_info_si(struct bxe_softc *sc)
13112 {
13113     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
13114     uint32_t val;
13115
13116     /*
13117      * There is no outer vlan if we're in switch-independent mode.
13118      * If the mac is valid then assume multi-function.
13119      */
13120
13121     val = MFCFG_RD(sc, func_ext_config[SC_ABS_FUNC(sc)].func_cfg);
13122
13123     mf_info->multi_vnics_mode = ((val & MACP_FUNC_CFG_FLAGS_MASK) != 0);
13124
13125     mf_info->mf_protos_supported = bxe_get_shmem_ext_proto_support_flags(sc);
13126
13127     mf_info->vnics_per_port =
13128         (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) ? 2 : 4;
13129
13130     return (0);
13131 }
13132
13133 static int
13134 bxe_get_shmem_mf_cfg_info_niv(struct bxe_softc *sc)
13135 {
13136     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
13137     uint32_t e1hov_tag;
13138     uint32_t func_config;
13139     uint32_t niv_config;
13140
13141     mf_info->multi_vnics_mode = 1;
13142
13143     e1hov_tag   = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].e1hov_tag);
13144     func_config = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].config);
13145     niv_config  = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].afex_config);
13146
13147     mf_info->ext_id =
13148         (uint16_t)((e1hov_tag & FUNC_MF_CFG_E1HOV_TAG_MASK) >>
13149                    FUNC_MF_CFG_E1HOV_TAG_SHIFT);
13150
13151     mf_info->default_vlan =
13152         (uint16_t)((e1hov_tag & FUNC_MF_CFG_AFEX_VLAN_MASK) >>
13153                    FUNC_MF_CFG_AFEX_VLAN_SHIFT);
13154
13155     mf_info->niv_allowed_priorities =
13156         (uint8_t)((niv_config & FUNC_MF_CFG_AFEX_COS_FILTER_MASK) >>
13157                   FUNC_MF_CFG_AFEX_COS_FILTER_SHIFT);
13158
13159     mf_info->niv_default_cos =
13160         (uint8_t)((func_config & FUNC_MF_CFG_TRANSMIT_PRIORITY_MASK) >>
13161                   FUNC_MF_CFG_TRANSMIT_PRIORITY_SHIFT);
13162
13163     mf_info->afex_vlan_mode =
13164         ((niv_config & FUNC_MF_CFG_AFEX_VLAN_MODE_MASK) >>
13165          FUNC_MF_CFG_AFEX_VLAN_MODE_SHIFT);
13166
13167     mf_info->niv_mba_enabled =
13168         ((niv_config & FUNC_MF_CFG_AFEX_MBA_ENABLED_MASK) >>
13169          FUNC_MF_CFG_AFEX_MBA_ENABLED_SHIFT);
13170
13171     mf_info->mf_protos_supported = bxe_get_shmem_ext_proto_support_flags(sc);
13172
13173     mf_info->vnics_per_port =
13174         (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) ? 2 : 4;
13175
13176     return (0);
13177 }
13178
13179 static int
13180 bxe_check_valid_mf_cfg(struct bxe_softc *sc)
13181 {
13182     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
13183     uint32_t mf_cfg1;
13184     uint32_t mf_cfg2;
13185     uint32_t ovlan1;
13186     uint32_t ovlan2;
13187     uint8_t i, j;
13188
13189     BLOGD(sc, DBG_LOAD, "MF config parameters for function %d\n",
13190           SC_PORT(sc));
13191     BLOGD(sc, DBG_LOAD, "\tmf_config=0x%x\n",
13192           mf_info->mf_config[SC_VN(sc)]);
13193     BLOGD(sc, DBG_LOAD, "\tmulti_vnics_mode=%d\n",
13194           mf_info->multi_vnics_mode);
13195     BLOGD(sc, DBG_LOAD, "\tvnics_per_port=%d\n",
13196           mf_info->vnics_per_port);
13197     BLOGD(sc, DBG_LOAD, "\tovlan/vifid=%d\n",
13198           mf_info->ext_id);
13199     BLOGD(sc, DBG_LOAD, "\tmin_bw=%d/%d/%d/%d\n",
13200           mf_info->min_bw[0], mf_info->min_bw[1],
13201           mf_info->min_bw[2], mf_info->min_bw[3]);
13202     BLOGD(sc, DBG_LOAD, "\tmax_bw=%d/%d/%d/%d\n",
13203           mf_info->max_bw[0], mf_info->max_bw[1],
13204           mf_info->max_bw[2], mf_info->max_bw[3]);
13205     BLOGD(sc, DBG_LOAD, "\tmac_addr: %s\n",
13206           sc->mac_addr_str);
13207
13208     /* various MF mode sanity checks... */
13209
13210     if (mf_info->mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_HIDE) {
13211         BLOGE(sc, "Enumerated function %d is marked as hidden\n",
13212               SC_PORT(sc));
13213         return (1);
13214     }
13215
13216     if ((mf_info->vnics_per_port > 1) && !mf_info->multi_vnics_mode) {
13217         BLOGE(sc, "vnics_per_port=%d multi_vnics_mode=%d\n",
13218               mf_info->vnics_per_port, mf_info->multi_vnics_mode);
13219         return (1);
13220     }
13221
13222     if (mf_info->mf_mode == MULTI_FUNCTION_SD) {
13223         /* vnic id > 0 must have valid ovlan in switch-dependent mode */
13224         if ((SC_VN(sc) > 0) && !VALID_OVLAN(OVLAN(sc))) {
13225             BLOGE(sc, "mf_mode=SD vnic_id=%d ovlan=%d\n",
13226                   SC_VN(sc), OVLAN(sc));
13227             return (1);
13228         }
13229
13230         if (!VALID_OVLAN(OVLAN(sc)) && mf_info->multi_vnics_mode) {
13231             BLOGE(sc, "mf_mode=SD multi_vnics_mode=%d ovlan=%d\n",
13232                   mf_info->multi_vnics_mode, OVLAN(sc));
13233             return (1);
13234         }
13235
13236         /*
13237          * Verify all functions are either MF or SF mode. If MF, make sure
13238          * sure that all non-hidden functions have a valid ovlan. If SF,
13239          * make sure that all non-hidden functions have an invalid ovlan.
13240          */
13241         FOREACH_ABS_FUNC_IN_PORT(sc, i) {
13242             mf_cfg1 = MFCFG_RD(sc, func_mf_config[i].config);
13243             ovlan1  = MFCFG_RD(sc, func_mf_config[i].e1hov_tag);
13244             if (!(mf_cfg1 & FUNC_MF_CFG_FUNC_HIDE) &&
13245                 (((mf_info->multi_vnics_mode) && !VALID_OVLAN(ovlan1)) ||
13246                  ((!mf_info->multi_vnics_mode) && VALID_OVLAN(ovlan1)))) {
13247                 BLOGE(sc, "mf_mode=SD function %d MF config "
13248                           "mismatch, multi_vnics_mode=%d ovlan=%d\n",
13249                       i, mf_info->multi_vnics_mode, ovlan1);
13250                 return (1);
13251             }
13252         }
13253
13254         /* Verify all funcs on the same port each have a different ovlan. */
13255         FOREACH_ABS_FUNC_IN_PORT(sc, i) {
13256             mf_cfg1 = MFCFG_RD(sc, func_mf_config[i].config);
13257             ovlan1  = MFCFG_RD(sc, func_mf_config[i].e1hov_tag);
13258             /* iterate from the next function on the port to the max func */
13259             for (j = i + 2; j < MAX_FUNC_NUM; j += 2) {
13260                 mf_cfg2 = MFCFG_RD(sc, func_mf_config[j].config);
13261                 ovlan2  = MFCFG_RD(sc, func_mf_config[j].e1hov_tag);
13262                 if (!(mf_cfg1 & FUNC_MF_CFG_FUNC_HIDE) &&
13263                     VALID_OVLAN(ovlan1) &&
13264                     !(mf_cfg2 & FUNC_MF_CFG_FUNC_HIDE) &&
13265                     VALID_OVLAN(ovlan2) &&
13266                     (ovlan1 == ovlan2)) {
13267                     BLOGE(sc, "mf_mode=SD functions %d and %d "
13268                               "have the same ovlan (%d)\n",
13269                           i, j, ovlan1);
13270                     return (1);
13271                 }
13272             }
13273         }
13274     } /* MULTI_FUNCTION_SD */
13275
13276     return (0);
13277 }
13278
13279 static int
13280 bxe_get_mf_cfg_info(struct bxe_softc *sc)
13281 {
13282     struct bxe_mf_info *mf_info = &sc->devinfo.mf_info;
13283     uint32_t val, mac_upper;
13284     uint8_t i, vnic;
13285
13286     /* initialize mf_info defaults */
13287     mf_info->vnics_per_port   = 1;
13288     mf_info->multi_vnics_mode = FALSE;
13289     mf_info->path_has_ovlan   = FALSE;
13290     mf_info->mf_mode          = SINGLE_FUNCTION;
13291
13292     if (!CHIP_IS_MF_CAP(sc)) {
13293         return (0);
13294     }
13295
13296     if (sc->devinfo.mf_cfg_base == SHMEM_MF_CFG_ADDR_NONE) {
13297         BLOGE(sc, "Invalid mf_cfg_base!\n");
13298         return (1);
13299     }
13300
13301     /* get the MF mode (switch dependent / independent / single-function) */
13302
13303     val = SHMEM_RD(sc, dev_info.shared_feature_config.config);
13304
13305     switch (val & SHARED_FEAT_CFG_FORCE_SF_MODE_MASK)
13306     {
13307     case SHARED_FEAT_CFG_FORCE_SF_MODE_SWITCH_INDEPT:
13308
13309         mac_upper = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].mac_upper);
13310
13311         /* check for legal upper mac bytes */
13312         if (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT) {
13313             mf_info->mf_mode = MULTI_FUNCTION_SI;
13314         } else {
13315             BLOGE(sc, "Invalid config for Switch Independent mode\n");
13316         }
13317
13318         break;
13319
13320     case SHARED_FEAT_CFG_FORCE_SF_MODE_MF_ALLOWED:
13321     case SHARED_FEAT_CFG_FORCE_SF_MODE_SPIO4:
13322
13323         /* get outer vlan configuration */
13324         val = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].e1hov_tag);
13325
13326         if ((val & FUNC_MF_CFG_E1HOV_TAG_MASK) !=
13327             FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
13328             mf_info->mf_mode = MULTI_FUNCTION_SD;
13329         } else {
13330             BLOGE(sc, "Invalid config for Switch Dependent mode\n");
13331         }
13332
13333         break;
13334
13335     case SHARED_FEAT_CFG_FORCE_SF_MODE_FORCED_SF:
13336
13337         /* not in MF mode, vnics_per_port=1 and multi_vnics_mode=FALSE */
13338         return (0);
13339
13340     case SHARED_FEAT_CFG_FORCE_SF_MODE_AFEX_MODE:
13341
13342         /*
13343          * Mark MF mode as NIV if MCP version includes NPAR-SD support
13344          * and the MAC address is valid.
13345          */
13346         mac_upper = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].mac_upper);
13347
13348         if ((SHMEM2_HAS(sc, afex_driver_support)) &&
13349             (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT)) {
13350             mf_info->mf_mode = MULTI_FUNCTION_AFEX;
13351         } else {
13352             BLOGE(sc, "Invalid config for AFEX mode\n");
13353         }
13354
13355         break;
13356
13357     default:
13358
13359         BLOGE(sc, "Unknown MF mode (0x%08x)\n",
13360               (val & SHARED_FEAT_CFG_FORCE_SF_MODE_MASK));
13361
13362         return (1);
13363     }
13364
13365     /* set path mf_mode (which could be different than function mf_mode) */
13366     if (mf_info->mf_mode == MULTI_FUNCTION_SD) {
13367         mf_info->path_has_ovlan = TRUE;
13368     } else if (mf_info->mf_mode == SINGLE_FUNCTION) {
13369         /*
13370          * Decide on path multi vnics mode. If we're not in MF mode and in
13371          * 4-port mode, this is good enough to check vnic-0 of the other port
13372          * on the same path
13373          */
13374         if (CHIP_PORT_MODE(sc) == CHIP_4_PORT_MODE) {
13375             uint8_t other_port = !(PORT_ID(sc) & 1);
13376             uint8_t abs_func_other_port = (SC_PATH(sc) + (2 * other_port));
13377
13378             val = MFCFG_RD(sc, func_mf_config[abs_func_other_port].e1hov_tag);
13379
13380             mf_info->path_has_ovlan = VALID_OVLAN((uint16_t)val) ? 1 : 0;
13381         }
13382     }
13383
13384     if (mf_info->mf_mode == SINGLE_FUNCTION) {
13385         /* invalid MF config */
13386         if (SC_VN(sc) >= 1) {
13387             BLOGE(sc, "VNIC ID >= 1 in SF mode\n");
13388             return (1);
13389         }
13390
13391         return (0);
13392     }
13393
13394     /* get the MF configuration */
13395     mf_info->mf_config[SC_VN(sc)] =
13396         MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].config);
13397
13398     switch(mf_info->mf_mode)
13399     {
13400     case MULTI_FUNCTION_SD:
13401
13402         bxe_get_shmem_mf_cfg_info_sd(sc);
13403         break;
13404
13405     case MULTI_FUNCTION_SI:
13406
13407         bxe_get_shmem_mf_cfg_info_si(sc);
13408         break;
13409
13410     case MULTI_FUNCTION_AFEX:
13411
13412         bxe_get_shmem_mf_cfg_info_niv(sc);
13413         break;
13414
13415     default:
13416
13417         BLOGE(sc, "Get MF config failed (mf_mode=0x%08x)\n",
13418               mf_info->mf_mode);
13419         return (1);
13420     }
13421
13422     /* get the congestion management parameters */
13423
13424     vnic = 0;
13425     FOREACH_ABS_FUNC_IN_PORT(sc, i) {
13426         /* get min/max bw */
13427         val = MFCFG_RD(sc, func_mf_config[i].config);
13428         mf_info->min_bw[vnic] =
13429             ((val & FUNC_MF_CFG_MIN_BW_MASK) >> FUNC_MF_CFG_MIN_BW_SHIFT);
13430         mf_info->max_bw[vnic] =
13431             ((val & FUNC_MF_CFG_MAX_BW_MASK) >> FUNC_MF_CFG_MAX_BW_SHIFT);
13432         vnic++;
13433     }
13434
13435     return (bxe_check_valid_mf_cfg(sc));
13436 }
13437
13438 static int
13439 bxe_get_shmem_info(struct bxe_softc *sc)
13440 {
13441     int port;
13442     uint32_t mac_hi, mac_lo, val;
13443
13444     port = SC_PORT(sc);
13445     mac_hi = mac_lo = 0;
13446
13447     sc->link_params.sc   = sc;
13448     sc->link_params.port = port;
13449
13450     /* get the hardware config info */
13451     sc->devinfo.hw_config =
13452         SHMEM_RD(sc, dev_info.shared_hw_config.config);
13453     sc->devinfo.hw_config2 =
13454         SHMEM_RD(sc, dev_info.shared_hw_config.config2);
13455
13456     sc->link_params.hw_led_mode =
13457         ((sc->devinfo.hw_config & SHARED_HW_CFG_LED_MODE_MASK) >>
13458          SHARED_HW_CFG_LED_MODE_SHIFT);
13459
13460     /* get the port feature config */
13461     sc->port.config =
13462         SHMEM_RD(sc, dev_info.port_feature_config[port].config),
13463
13464     /* get the link params */
13465     sc->link_params.speed_cap_mask[0] =
13466         SHMEM_RD(sc, dev_info.port_hw_config[port].speed_capability_mask);
13467     sc->link_params.speed_cap_mask[1] =
13468         SHMEM_RD(sc, dev_info.port_hw_config[port].speed_capability_mask2);
13469
13470     /* get the lane config */
13471     sc->link_params.lane_config =
13472         SHMEM_RD(sc, dev_info.port_hw_config[port].lane_config);
13473
13474     /* get the link config */
13475     val = SHMEM_RD(sc, dev_info.port_feature_config[port].link_config);
13476     sc->port.link_config[ELINK_INT_PHY] = val;
13477     sc->link_params.switch_cfg = (val & PORT_FEATURE_CONNECTED_SWITCH_MASK);
13478     sc->port.link_config[ELINK_EXT_PHY1] =
13479         SHMEM_RD(sc, dev_info.port_feature_config[port].link_config2);
13480
13481     /* get the override preemphasis flag and enable it or turn it off */
13482     val = SHMEM_RD(sc, dev_info.shared_feature_config.config);
13483     if (val & SHARED_FEAT_CFG_OVERRIDE_PREEMPHASIS_CFG_ENABLED) {
13484         sc->link_params.feature_config_flags |=
13485             ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
13486     } else {
13487         sc->link_params.feature_config_flags &=
13488             ~ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
13489     }
13490
13491     /* get the initial value of the link params */
13492     sc->link_params.multi_phy_config =
13493         SHMEM_RD(sc, dev_info.port_hw_config[port].multi_phy_config);
13494
13495     /* get external phy info */
13496     sc->port.ext_phy_config =
13497         SHMEM_RD(sc, dev_info.port_hw_config[port].external_phy_config);
13498
13499     /* get the multifunction configuration */
13500     bxe_get_mf_cfg_info(sc);
13501
13502     /* get the mac address */
13503     if (IS_MF(sc)) {
13504         mac_hi = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].mac_upper);
13505         mac_lo = MFCFG_RD(sc, func_mf_config[SC_ABS_FUNC(sc)].mac_lower);
13506     } else {
13507         mac_hi = SHMEM_RD(sc, dev_info.port_hw_config[port].mac_upper);
13508         mac_lo = SHMEM_RD(sc, dev_info.port_hw_config[port].mac_lower);
13509     }
13510
13511     if ((mac_lo == 0) && (mac_hi == 0)) {
13512         *sc->mac_addr_str = 0;
13513         BLOGE(sc, "No Ethernet address programmed!\n");
13514     } else {
13515         sc->link_params.mac_addr[0] = (uint8_t)(mac_hi >> 8);
13516         sc->link_params.mac_addr[1] = (uint8_t)(mac_hi);
13517         sc->link_params.mac_addr[2] = (uint8_t)(mac_lo >> 24);
13518         sc->link_params.mac_addr[3] = (uint8_t)(mac_lo >> 16);
13519         sc->link_params.mac_addr[4] = (uint8_t)(mac_lo >> 8);
13520         sc->link_params.mac_addr[5] = (uint8_t)(mac_lo);
13521         snprintf(sc->mac_addr_str, sizeof(sc->mac_addr_str),
13522                  "%02x:%02x:%02x:%02x:%02x:%02x",
13523                  sc->link_params.mac_addr[0], sc->link_params.mac_addr[1],
13524                  sc->link_params.mac_addr[2], sc->link_params.mac_addr[3],
13525                  sc->link_params.mac_addr[4], sc->link_params.mac_addr[5]);
13526         BLOGD(sc, DBG_LOAD, "Ethernet address: %s\n", sc->mac_addr_str);
13527     }
13528
13529     return (0);
13530 }
13531
13532 static void
13533 bxe_get_tunable_params(struct bxe_softc *sc)
13534 {
13535     /* sanity checks */
13536
13537     if ((bxe_interrupt_mode != INTR_MODE_INTX) &&
13538         (bxe_interrupt_mode != INTR_MODE_MSI)  &&
13539         (bxe_interrupt_mode != INTR_MODE_MSIX)) {
13540         BLOGW(sc, "invalid interrupt_mode value (%d)\n", bxe_interrupt_mode);
13541         bxe_interrupt_mode = INTR_MODE_MSIX;
13542     }
13543
13544     if ((bxe_queue_count < 0) || (bxe_queue_count > MAX_RSS_CHAINS)) {
13545         BLOGW(sc, "invalid queue_count value (%d)\n", bxe_queue_count);
13546         bxe_queue_count = 0;
13547     }
13548
13549     if ((bxe_max_rx_bufs < 1) || (bxe_max_rx_bufs > RX_BD_USABLE)) {
13550         if (bxe_max_rx_bufs == 0) {
13551             bxe_max_rx_bufs = RX_BD_USABLE;
13552         } else {
13553             BLOGW(sc, "invalid max_rx_bufs (%d)\n", bxe_max_rx_bufs);
13554             bxe_max_rx_bufs = 2048;
13555         }
13556     }
13557
13558     if ((bxe_hc_rx_ticks < 1) || (bxe_hc_rx_ticks > 100)) {
13559         BLOGW(sc, "invalid hc_rx_ticks (%d)\n", bxe_hc_rx_ticks);
13560         bxe_hc_rx_ticks = 25;
13561     }
13562
13563     if ((bxe_hc_tx_ticks < 1) || (bxe_hc_tx_ticks > 100)) {
13564         BLOGW(sc, "invalid hc_tx_ticks (%d)\n", bxe_hc_tx_ticks);
13565         bxe_hc_tx_ticks = 50;
13566     }
13567
13568     if (bxe_max_aggregation_size == 0) {
13569         bxe_max_aggregation_size = TPA_AGG_SIZE;
13570     }
13571
13572     if (bxe_max_aggregation_size > 0xffff) {
13573         BLOGW(sc, "invalid max_aggregation_size (%d)\n",
13574               bxe_max_aggregation_size);
13575         bxe_max_aggregation_size = TPA_AGG_SIZE;
13576     }
13577
13578     if ((bxe_mrrs < -1) || (bxe_mrrs > 3)) {
13579         BLOGW(sc, "invalid mrrs (%d)\n", bxe_mrrs);
13580         bxe_mrrs = -1;
13581     }
13582
13583     if ((bxe_autogreeen < 0) || (bxe_autogreeen > 2)) {
13584         BLOGW(sc, "invalid autogreeen (%d)\n", bxe_autogreeen);
13585         bxe_autogreeen = 0;
13586     }
13587
13588     if ((bxe_udp_rss < 0) || (bxe_udp_rss > 1)) {
13589         BLOGW(sc, "invalid udp_rss (%d)\n", bxe_udp_rss);
13590         bxe_udp_rss = 0;
13591     }
13592
13593     /* pull in user settings */
13594
13595     sc->interrupt_mode       = bxe_interrupt_mode;
13596     sc->max_rx_bufs          = bxe_max_rx_bufs;
13597     sc->hc_rx_ticks          = bxe_hc_rx_ticks;
13598     sc->hc_tx_ticks          = bxe_hc_tx_ticks;
13599     sc->max_aggregation_size = bxe_max_aggregation_size;
13600     sc->mrrs                 = bxe_mrrs;
13601     sc->autogreeen           = bxe_autogreeen;
13602     sc->udp_rss              = bxe_udp_rss;
13603
13604     if (bxe_interrupt_mode == INTR_MODE_INTX) {
13605         sc->num_queues = 1;
13606     } else { /* INTR_MODE_MSI or INTR_MODE_MSIX */
13607         sc->num_queues =
13608             min((bxe_queue_count ? bxe_queue_count : mp_ncpus),
13609                 MAX_RSS_CHAINS);
13610         if (sc->num_queues > mp_ncpus) {
13611             sc->num_queues = mp_ncpus;
13612         }
13613     }
13614
13615     BLOGD(sc, DBG_LOAD,
13616           "User Config: "
13617           "debug=0x%lx "
13618           "interrupt_mode=%d "
13619           "queue_count=%d "
13620           "hc_rx_ticks=%d "
13621           "hc_tx_ticks=%d "
13622           "rx_budget=%d "
13623           "max_aggregation_size=%d "
13624           "mrrs=%d "
13625           "autogreeen=%d "
13626           "udp_rss=%d\n",
13627           bxe_debug,
13628           sc->interrupt_mode,
13629           sc->num_queues,
13630           sc->hc_rx_ticks,
13631           sc->hc_tx_ticks,
13632           bxe_rx_budget,
13633           sc->max_aggregation_size,
13634           sc->mrrs,
13635           sc->autogreeen,
13636           sc->udp_rss);
13637 }
13638
13639 static void
13640 bxe_media_detect(struct bxe_softc *sc)
13641 {
13642     uint32_t phy_idx = bxe_get_cur_phy_idx(sc);
13643     switch (sc->link_params.phy[phy_idx].media_type) {
13644     case ELINK_ETH_PHY_SFPP_10G_FIBER:
13645     case ELINK_ETH_PHY_XFP_FIBER:
13646         BLOGI(sc, "Found 10Gb Fiber media.\n");
13647         sc->media = IFM_10G_SR;
13648         break;
13649     case ELINK_ETH_PHY_SFP_1G_FIBER:
13650         BLOGI(sc, "Found 1Gb Fiber media.\n");
13651         sc->media = IFM_1000_SX;
13652         break;
13653     case ELINK_ETH_PHY_KR:
13654     case ELINK_ETH_PHY_CX4:
13655         BLOGI(sc, "Found 10GBase-CX4 media.\n");
13656         sc->media = IFM_10G_CX4;
13657         break;
13658     case ELINK_ETH_PHY_DA_TWINAX:
13659         BLOGI(sc, "Found 10Gb Twinax media.\n");
13660         sc->media = IFM_10G_TWINAX;
13661         break;
13662     case ELINK_ETH_PHY_BASE_T:
13663         if (sc->link_params.speed_cap_mask[0] &
13664             PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) {
13665             BLOGI(sc, "Found 10GBase-T media.\n");
13666             sc->media = IFM_10G_T;
13667         } else {
13668             BLOGI(sc, "Found 1000Base-T media.\n");
13669             sc->media = IFM_1000_T;
13670         }
13671         break;
13672     case ELINK_ETH_PHY_NOT_PRESENT:
13673         BLOGI(sc, "Media not present.\n");
13674         sc->media = 0;
13675         break;
13676     case ELINK_ETH_PHY_UNSPECIFIED:
13677     default:
13678         BLOGI(sc, "Unknown media!\n");
13679         sc->media = 0;
13680         break;
13681     }
13682 }
13683
13684 #define GET_FIELD(value, fname)                     \
13685     (((value) & (fname##_MASK)) >> (fname##_SHIFT))
13686 #define IGU_FID(val) GET_FIELD((val), IGU_REG_MAPPING_MEMORY_FID)
13687 #define IGU_VEC(val) GET_FIELD((val), IGU_REG_MAPPING_MEMORY_VECTOR)
13688
13689 static int
13690 bxe_get_igu_cam_info(struct bxe_softc *sc)
13691 {
13692     int pfid = SC_FUNC(sc);
13693     int igu_sb_id;
13694     uint32_t val;
13695     uint8_t fid, igu_sb_cnt = 0;
13696
13697     sc->igu_base_sb = 0xff;
13698
13699     if (CHIP_INT_MODE_IS_BC(sc)) {
13700         int vn = SC_VN(sc);
13701         igu_sb_cnt = sc->igu_sb_cnt;
13702         sc->igu_base_sb = ((CHIP_IS_MODE_4_PORT(sc) ? pfid : vn) *
13703                            FP_SB_MAX_E1x);
13704         sc->igu_dsb_id = (E1HVN_MAX * FP_SB_MAX_E1x +
13705                           (CHIP_IS_MODE_4_PORT(sc) ? pfid : vn));
13706         return (0);
13707     }
13708
13709     /* IGU in normal mode - read CAM */
13710     for (igu_sb_id = 0;
13711          igu_sb_id < IGU_REG_MAPPING_MEMORY_SIZE;
13712          igu_sb_id++) {
13713         val = REG_RD(sc, IGU_REG_MAPPING_MEMORY + igu_sb_id * 4);
13714         if (!(val & IGU_REG_MAPPING_MEMORY_VALID)) {
13715             continue;
13716         }
13717         fid = IGU_FID(val);
13718         if ((fid & IGU_FID_ENCODE_IS_PF)) {
13719             if ((fid & IGU_FID_PF_NUM_MASK) != pfid) {
13720                 continue;
13721             }
13722             if (IGU_VEC(val) == 0) {
13723                 /* default status block */
13724                 sc->igu_dsb_id = igu_sb_id;
13725             } else {
13726                 if (sc->igu_base_sb == 0xff) {
13727                     sc->igu_base_sb = igu_sb_id;
13728                 }
13729                 igu_sb_cnt++;
13730             }
13731         }
13732     }
13733
13734     /*
13735      * Due to new PF resource allocation by MFW T7.4 and above, it's optional
13736      * that number of CAM entries will not be equal to the value advertised in
13737      * PCI. Driver should use the minimal value of both as the actual status
13738      * block count
13739      */
13740     sc->igu_sb_cnt = min(sc->igu_sb_cnt, igu_sb_cnt);
13741
13742     if (igu_sb_cnt == 0) {
13743         BLOGE(sc, "CAM configuration error\n");
13744         return (-1);
13745     }
13746
13747     return (0);
13748 }
13749
13750 /*
13751  * Gather various information from the device config space, the device itself,
13752  * shmem, and the user input.
13753  */
13754 static int
13755 bxe_get_device_info(struct bxe_softc *sc)
13756 {
13757     uint32_t val;
13758     int rc;
13759
13760     /* Get the data for the device */
13761     sc->devinfo.vendor_id    = pci_get_vendor(sc->dev);
13762     sc->devinfo.device_id    = pci_get_device(sc->dev);
13763     sc->devinfo.subvendor_id = pci_get_subvendor(sc->dev);
13764     sc->devinfo.subdevice_id = pci_get_subdevice(sc->dev);
13765
13766     /* get the chip revision (chip metal comes from pci config space) */
13767     sc->devinfo.chip_id     =
13768     sc->link_params.chip_id =
13769         (((REG_RD(sc, MISC_REG_CHIP_NUM)                   & 0xffff) << 16) |
13770          ((REG_RD(sc, MISC_REG_CHIP_REV)                   & 0xf)    << 12) |
13771          (((REG_RD(sc, PCICFG_OFFSET + PCI_ID_VAL3) >> 24) & 0xf)    << 4)  |
13772          ((REG_RD(sc, MISC_REG_BOND_ID)                    & 0xf)    << 0));
13773
13774     /* force 57811 according to MISC register */
13775     if (REG_RD(sc, MISC_REG_CHIP_TYPE) & MISC_REG_CHIP_TYPE_57811_MASK) {
13776         if (CHIP_IS_57810(sc)) {
13777             sc->devinfo.chip_id = ((CHIP_NUM_57811 << 16) |
13778                                    (sc->devinfo.chip_id & 0x0000ffff));
13779         } else if (CHIP_IS_57810_MF(sc)) {
13780             sc->devinfo.chip_id = ((CHIP_NUM_57811_MF << 16) |
13781                                    (sc->devinfo.chip_id & 0x0000ffff));
13782         }
13783         sc->devinfo.chip_id |= 0x1;
13784     }
13785
13786     BLOGD(sc, DBG_LOAD,
13787           "chip_id=0x%08x (num=0x%04x rev=0x%01x metal=0x%02x bond=0x%01x)\n",
13788           sc->devinfo.chip_id,
13789           ((sc->devinfo.chip_id >> 16) & 0xffff),
13790           ((sc->devinfo.chip_id >> 12) & 0xf),
13791           ((sc->devinfo.chip_id >>  4) & 0xff),
13792           ((sc->devinfo.chip_id >>  0) & 0xf));
13793
13794     val = (REG_RD(sc, 0x2874) & 0x55);
13795     if ((sc->devinfo.chip_id & 0x1) ||
13796         (CHIP_IS_E1(sc) && val) ||
13797         (CHIP_IS_E1H(sc) && (val == 0x55))) {
13798         sc->flags |= BXE_ONE_PORT_FLAG;
13799         BLOGD(sc, DBG_LOAD, "single port device\n");
13800     }
13801
13802     /* set the doorbell size */
13803     sc->doorbell_size = (1 << BXE_DB_SHIFT);
13804
13805     /* determine whether the device is in 2 port or 4 port mode */
13806     sc->devinfo.chip_port_mode = CHIP_PORT_MODE_NONE; /* E1 & E1h*/
13807     if (CHIP_IS_E2E3(sc)) {
13808         /*
13809          * Read port4mode_en_ovwr[0]:
13810          *   If 1, four port mode is in port4mode_en_ovwr[1].
13811          *   If 0, four port mode is in port4mode_en[0].
13812          */
13813         val = REG_RD(sc, MISC_REG_PORT4MODE_EN_OVWR);
13814         if (val & 1) {
13815             val = ((val >> 1) & 1);
13816         } else {
13817             val = REG_RD(sc, MISC_REG_PORT4MODE_EN);
13818         }
13819
13820         sc->devinfo.chip_port_mode =
13821             (val) ? CHIP_4_PORT_MODE : CHIP_2_PORT_MODE;
13822
13823         BLOGD(sc, DBG_LOAD, "Port mode = %s\n", (val) ? "4" : "2");
13824     }
13825
13826     /* get the function and path info for the device */
13827     bxe_get_function_num(sc);
13828
13829     /* get the shared memory base address */
13830     sc->devinfo.shmem_base     =
13831     sc->link_params.shmem_base =
13832         REG_RD(sc, MISC_REG_SHARED_MEM_ADDR);
13833     sc->devinfo.shmem2_base =
13834         REG_RD(sc, (SC_PATH(sc) ? MISC_REG_GENERIC_CR_1 :
13835                                   MISC_REG_GENERIC_CR_0));
13836
13837     BLOGD(sc, DBG_LOAD, "shmem_base=0x%08x, shmem2_base=0x%08x\n",
13838           sc->devinfo.shmem_base, sc->devinfo.shmem2_base);
13839
13840     if (!sc->devinfo.shmem_base) {
13841         /* this should ONLY prevent upcoming shmem reads */
13842         BLOGI(sc, "MCP not active\n");
13843         sc->flags |= BXE_NO_MCP_FLAG;
13844         return (0);
13845     }
13846
13847     /* make sure the shared memory contents are valid */
13848     val = SHMEM_RD(sc, validity_map[SC_PORT(sc)]);
13849     if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) !=
13850         (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) {
13851         BLOGE(sc, "Invalid SHMEM validity signature: 0x%08x\n", val);
13852         return (0);
13853     }
13854     BLOGD(sc, DBG_LOAD, "Valid SHMEM validity signature: 0x%08x\n", val);
13855
13856     /* get the bootcode version */
13857     sc->devinfo.bc_ver = SHMEM_RD(sc, dev_info.bc_rev);
13858     snprintf(sc->devinfo.bc_ver_str,
13859              sizeof(sc->devinfo.bc_ver_str),
13860              "%d.%d.%d",
13861              ((sc->devinfo.bc_ver >> 24) & 0xff),
13862              ((sc->devinfo.bc_ver >> 16) & 0xff),
13863              ((sc->devinfo.bc_ver >>  8) & 0xff));
13864     BLOGD(sc, DBG_LOAD, "Bootcode version: %s\n", sc->devinfo.bc_ver_str);
13865
13866     /* get the bootcode shmem address */
13867     sc->devinfo.mf_cfg_base = bxe_get_shmem_mf_cfg_base(sc);
13868     BLOGD(sc, DBG_LOAD, "mf_cfg_base=0x08%x \n", sc->devinfo.mf_cfg_base);
13869
13870     /* clean indirect addresses as they're not used */
13871     pci_write_config(sc->dev, PCICFG_GRC_ADDRESS, 0, 4);
13872     if (IS_PF(sc)) {
13873         REG_WR(sc, PXP2_REG_PGL_ADDR_88_F0, 0);
13874         REG_WR(sc, PXP2_REG_PGL_ADDR_8C_F0, 0);
13875         REG_WR(sc, PXP2_REG_PGL_ADDR_90_F0, 0);
13876         REG_WR(sc, PXP2_REG_PGL_ADDR_94_F0, 0);
13877         if (CHIP_IS_E1x(sc)) {
13878             REG_WR(sc, PXP2_REG_PGL_ADDR_88_F1, 0);
13879             REG_WR(sc, PXP2_REG_PGL_ADDR_8C_F1, 0);
13880             REG_WR(sc, PXP2_REG_PGL_ADDR_90_F1, 0);
13881             REG_WR(sc, PXP2_REG_PGL_ADDR_94_F1, 0);
13882         }
13883
13884         /*
13885          * Enable internal target-read (in case we are probed after PF
13886          * FLR). Must be done prior to any BAR read access. Only for
13887          * 57712 and up
13888          */
13889         if (!CHIP_IS_E1x(sc)) {
13890             REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
13891         }
13892     }
13893
13894     /* get the nvram size */
13895     val = REG_RD(sc, MCP_REG_MCPR_NVM_CFG4);
13896     sc->devinfo.flash_size =
13897         (NVRAM_1MB_SIZE << (val & MCPR_NVM_CFG4_FLASH_SIZE));
13898     BLOGD(sc, DBG_LOAD, "nvram flash size: %d\n", sc->devinfo.flash_size);
13899
13900     /* get PCI capabilites */
13901     bxe_probe_pci_caps(sc);
13902
13903     bxe_set_power_state(sc, PCI_PM_D0);
13904
13905     /* get various configuration parameters from shmem */
13906     bxe_get_shmem_info(sc);
13907
13908     if (sc->devinfo.pcie_msix_cap_reg != 0) {
13909         val = pci_read_config(sc->dev,
13910                               (sc->devinfo.pcie_msix_cap_reg +
13911                                PCIR_MSIX_CTRL),
13912                               2);
13913         sc->igu_sb_cnt = (val & PCIM_MSIXCTRL_TABLE_SIZE);
13914     } else {
13915         sc->igu_sb_cnt = 1;
13916     }
13917
13918     sc->igu_base_addr = BAR_IGU_INTMEM;
13919
13920     /* initialize IGU parameters */
13921     if (CHIP_IS_E1x(sc)) {
13922         sc->devinfo.int_block = INT_BLOCK_HC;
13923         sc->igu_dsb_id = DEF_SB_IGU_ID;
13924         sc->igu_base_sb = 0;
13925     } else {
13926         sc->devinfo.int_block = INT_BLOCK_IGU;
13927
13928         /* do not allow device reset during IGU info preocessing */
13929         bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
13930
13931         val = REG_RD(sc, IGU_REG_BLOCK_CONFIGURATION);
13932
13933         if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
13934             int tout = 5000;
13935
13936             BLOGD(sc, DBG_LOAD, "FORCING IGU Normal Mode\n");
13937
13938             val &= ~(IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN);
13939             REG_WR(sc, IGU_REG_BLOCK_CONFIGURATION, val);
13940             REG_WR(sc, IGU_REG_RESET_MEMORIES, 0x7f);
13941
13942             while (tout && REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
13943                 tout--;
13944                 DELAY(1000);
13945             }
13946
13947             if (REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
13948                 BLOGD(sc, DBG_LOAD, "FORCING IGU Normal Mode failed!!!\n");
13949                 bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
13950                 return (-1);
13951             }
13952         }
13953
13954         if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
13955             BLOGD(sc, DBG_LOAD, "IGU Backward Compatible Mode\n");
13956             sc->devinfo.int_block |= INT_BLOCK_MODE_BW_COMP;
13957         } else {
13958             BLOGD(sc, DBG_LOAD, "IGU Normal Mode\n");
13959         }
13960
13961         rc = bxe_get_igu_cam_info(sc);
13962
13963         bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
13964
13965         if (rc) {
13966             return (rc);
13967         }
13968     }
13969
13970     /*
13971      * Get base FW non-default (fast path) status block ID. This value is
13972      * used to initialize the fw_sb_id saved on the fp/queue structure to
13973      * determine the id used by the FW.
13974      */
13975     if (CHIP_IS_E1x(sc)) {
13976         sc->base_fw_ndsb = ((SC_PORT(sc) * FP_SB_MAX_E1x) + SC_L_ID(sc));
13977     } else {
13978         /*
13979          * 57712+ - We currently use one FW SB per IGU SB (Rx and Tx of
13980          * the same queue are indicated on the same IGU SB). So we prefer
13981          * FW and IGU SBs to be the same value.
13982          */
13983         sc->base_fw_ndsb = sc->igu_base_sb;
13984     }
13985
13986     BLOGD(sc, DBG_LOAD,
13987           "igu_dsb_id=%d igu_base_sb=%d igu_sb_cnt=%d base_fw_ndsb=%d\n",
13988           sc->igu_dsb_id, sc->igu_base_sb,
13989           sc->igu_sb_cnt, sc->base_fw_ndsb);
13990
13991     elink_phy_probe(&sc->link_params);
13992
13993     return (0);
13994 }
13995
13996 static void
13997 bxe_link_settings_supported(struct bxe_softc *sc,
13998                             uint32_t         switch_cfg)
13999 {
14000     uint32_t cfg_size = 0;
14001     uint32_t idx;
14002     uint8_t port = SC_PORT(sc);
14003
14004     /* aggregation of supported attributes of all external phys */
14005     sc->port.supported[0] = 0;
14006     sc->port.supported[1] = 0;
14007
14008     switch (sc->link_params.num_phys) {
14009     case 1:
14010         sc->port.supported[0] = sc->link_params.phy[ELINK_INT_PHY].supported;
14011         cfg_size = 1;
14012         break;
14013     case 2:
14014         sc->port.supported[0] = sc->link_params.phy[ELINK_EXT_PHY1].supported;
14015         cfg_size = 1;
14016         break;
14017     case 3:
14018         if (sc->link_params.multi_phy_config &
14019             PORT_HW_CFG_PHY_SWAPPED_ENABLED) {
14020             sc->port.supported[1] =
14021                 sc->link_params.phy[ELINK_EXT_PHY1].supported;
14022             sc->port.supported[0] =
14023                 sc->link_params.phy[ELINK_EXT_PHY2].supported;
14024         } else {
14025             sc->port.supported[0] =
14026                 sc->link_params.phy[ELINK_EXT_PHY1].supported;
14027             sc->port.supported[1] =
14028                 sc->link_params.phy[ELINK_EXT_PHY2].supported;
14029         }
14030         cfg_size = 2;
14031         break;
14032     }
14033
14034     if (!(sc->port.supported[0] || sc->port.supported[1])) {
14035         BLOGE(sc, "Invalid phy config in NVRAM (PHY1=0x%08x PHY2=0x%08x)\n",
14036               SHMEM_RD(sc,
14037                        dev_info.port_hw_config[port].external_phy_config),
14038               SHMEM_RD(sc,
14039                        dev_info.port_hw_config[port].external_phy_config2));
14040         return;
14041     }
14042
14043     if (CHIP_IS_E3(sc))
14044         sc->port.phy_addr = REG_RD(sc, MISC_REG_WC0_CTRL_PHY_ADDR);
14045     else {
14046         switch (switch_cfg) {
14047         case ELINK_SWITCH_CFG_1G:
14048             sc->port.phy_addr =
14049                 REG_RD(sc, NIG_REG_SERDES0_CTRL_PHY_ADDR + port*0x10);
14050             break;
14051         case ELINK_SWITCH_CFG_10G:
14052             sc->port.phy_addr =
14053                 REG_RD(sc, NIG_REG_XGXS0_CTRL_PHY_ADDR + port*0x18);
14054             break;
14055         default:
14056             BLOGE(sc, "Invalid switch config in link_config=0x%08x\n",
14057                   sc->port.link_config[0]);
14058             return;
14059         }
14060     }
14061
14062     BLOGD(sc, DBG_LOAD, "PHY addr 0x%08x\n", sc->port.phy_addr);
14063
14064     /* mask what we support according to speed_cap_mask per configuration */
14065     for (idx = 0; idx < cfg_size; idx++) {
14066         if (!(sc->link_params.speed_cap_mask[idx] &
14067               PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF)) {
14068             sc->port.supported[idx] &= ~ELINK_SUPPORTED_10baseT_Half;
14069         }
14070
14071         if (!(sc->link_params.speed_cap_mask[idx] &
14072               PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL)) {
14073             sc->port.supported[idx] &= ~ELINK_SUPPORTED_10baseT_Full;
14074         }
14075
14076         if (!(sc->link_params.speed_cap_mask[idx] &
14077               PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF)) {
14078             sc->port.supported[idx] &= ~ELINK_SUPPORTED_100baseT_Half;
14079         }
14080
14081         if (!(sc->link_params.speed_cap_mask[idx] &
14082               PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL)) {
14083             sc->port.supported[idx] &= ~ELINK_SUPPORTED_100baseT_Full;
14084         }
14085
14086         if (!(sc->link_params.speed_cap_mask[idx] &
14087               PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)) {
14088             sc->port.supported[idx] &= ~ELINK_SUPPORTED_1000baseT_Full;
14089         }
14090
14091         if (!(sc->link_params.speed_cap_mask[idx] &
14092               PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G)) {
14093             sc->port.supported[idx] &= ~ELINK_SUPPORTED_2500baseX_Full;
14094         }
14095
14096         if (!(sc->link_params.speed_cap_mask[idx] &
14097               PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
14098             sc->port.supported[idx] &= ~ELINK_SUPPORTED_10000baseT_Full;
14099         }
14100
14101         if (!(sc->link_params.speed_cap_mask[idx] &
14102               PORT_HW_CFG_SPEED_CAPABILITY_D0_20G)) {
14103             sc->port.supported[idx] &= ~ELINK_SUPPORTED_20000baseKR2_Full;
14104         }
14105     }
14106
14107     BLOGD(sc, DBG_LOAD, "PHY supported 0=0x%08x 1=0x%08x\n",
14108           sc->port.supported[0], sc->port.supported[1]);
14109 }
14110
14111 static void
14112 bxe_link_settings_requested(struct bxe_softc *sc)
14113 {
14114     uint32_t link_config;
14115     uint32_t idx;
14116     uint32_t cfg_size = 0;
14117
14118     sc->port.advertising[0] = 0;
14119     sc->port.advertising[1] = 0;
14120
14121     switch (sc->link_params.num_phys) {
14122     case 1:
14123     case 2:
14124         cfg_size = 1;
14125         break;
14126     case 3:
14127         cfg_size = 2;
14128         break;
14129     }
14130
14131     for (idx = 0; idx < cfg_size; idx++) {
14132         sc->link_params.req_duplex[idx] = DUPLEX_FULL;
14133         link_config = sc->port.link_config[idx];
14134
14135         switch (link_config & PORT_FEATURE_LINK_SPEED_MASK) {
14136         case PORT_FEATURE_LINK_SPEED_AUTO:
14137             if (sc->port.supported[idx] & ELINK_SUPPORTED_Autoneg) {
14138                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_AUTO_NEG;
14139                 sc->port.advertising[idx] |= sc->port.supported[idx];
14140                 if (sc->link_params.phy[ELINK_EXT_PHY1].type ==
14141                     PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BCM84833)
14142                     sc->port.advertising[idx] |=
14143                         (ELINK_SUPPORTED_100baseT_Half |
14144                          ELINK_SUPPORTED_100baseT_Full);
14145             } else {
14146                 /* force 10G, no AN */
14147                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10000;
14148                 sc->port.advertising[idx] |=
14149                     (ADVERTISED_10000baseT_Full | ADVERTISED_FIBRE);
14150                 continue;
14151             }
14152             break;
14153
14154         case PORT_FEATURE_LINK_SPEED_10M_FULL:
14155             if (sc->port.supported[idx] & ELINK_SUPPORTED_10baseT_Full) {
14156                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10;
14157                 sc->port.advertising[idx] |= (ADVERTISED_10baseT_Full |
14158                                               ADVERTISED_TP);
14159             } else {
14160                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14161                           "speed_cap_mask=0x%08x\n",
14162                       link_config, sc->link_params.speed_cap_mask[idx]);
14163                 return;
14164             }
14165             break;
14166
14167         case PORT_FEATURE_LINK_SPEED_10M_HALF:
14168             if (sc->port.supported[idx] & ELINK_SUPPORTED_10baseT_Half) {
14169                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10;
14170                 sc->link_params.req_duplex[idx] = DUPLEX_HALF;
14171                 sc->port.advertising[idx] |= (ADVERTISED_10baseT_Half |
14172                                               ADVERTISED_TP);
14173             } else {
14174                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14175                           "speed_cap_mask=0x%08x\n",
14176                       link_config, sc->link_params.speed_cap_mask[idx]);
14177                 return;
14178             }
14179             break;
14180
14181         case PORT_FEATURE_LINK_SPEED_100M_FULL:
14182             if (sc->port.supported[idx] & ELINK_SUPPORTED_100baseT_Full) {
14183                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_100;
14184                 sc->port.advertising[idx] |= (ADVERTISED_100baseT_Full |
14185                                               ADVERTISED_TP);
14186             } else {
14187                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14188                           "speed_cap_mask=0x%08x\n",
14189                       link_config, sc->link_params.speed_cap_mask[idx]);
14190                 return;
14191             }
14192             break;
14193
14194         case PORT_FEATURE_LINK_SPEED_100M_HALF:
14195             if (sc->port.supported[idx] & ELINK_SUPPORTED_100baseT_Half) {
14196                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_100;
14197                 sc->link_params.req_duplex[idx] = DUPLEX_HALF;
14198                 sc->port.advertising[idx] |= (ADVERTISED_100baseT_Half |
14199                                               ADVERTISED_TP);
14200             } else {
14201                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14202                           "speed_cap_mask=0x%08x\n",
14203                       link_config, sc->link_params.speed_cap_mask[idx]);
14204                 return;
14205             }
14206             break;
14207
14208         case PORT_FEATURE_LINK_SPEED_1G:
14209             if (sc->port.supported[idx] & ELINK_SUPPORTED_1000baseT_Full) {
14210                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_1000;
14211                 sc->port.advertising[idx] |= (ADVERTISED_1000baseT_Full |
14212                                               ADVERTISED_TP);
14213             } else {
14214                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14215                           "speed_cap_mask=0x%08x\n",
14216                       link_config, sc->link_params.speed_cap_mask[idx]);
14217                 return;
14218             }
14219             break;
14220
14221         case PORT_FEATURE_LINK_SPEED_2_5G:
14222             if (sc->port.supported[idx] & ELINK_SUPPORTED_2500baseX_Full) {
14223                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_2500;
14224                 sc->port.advertising[idx] |= (ADVERTISED_2500baseX_Full |
14225                                               ADVERTISED_TP);
14226             } else {
14227                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14228                           "speed_cap_mask=0x%08x\n",
14229                       link_config, sc->link_params.speed_cap_mask[idx]);
14230                 return;
14231             }
14232             break;
14233
14234         case PORT_FEATURE_LINK_SPEED_10G_CX4:
14235             if (sc->port.supported[idx] & ELINK_SUPPORTED_10000baseT_Full) {
14236                 sc->link_params.req_line_speed[idx] = ELINK_SPEED_10000;
14237                 sc->port.advertising[idx] |= (ADVERTISED_10000baseT_Full |
14238                                               ADVERTISED_FIBRE);
14239             } else {
14240                 BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14241                           "speed_cap_mask=0x%08x\n",
14242                       link_config, sc->link_params.speed_cap_mask[idx]);
14243                 return;
14244             }
14245             break;
14246
14247         case PORT_FEATURE_LINK_SPEED_20G:
14248             sc->link_params.req_line_speed[idx] = ELINK_SPEED_20000;
14249             break;
14250
14251         default:
14252             BLOGE(sc, "Invalid NVRAM config link_config=0x%08x "
14253                       "speed_cap_mask=0x%08x\n",
14254                   link_config, sc->link_params.speed_cap_mask[idx]);
14255             sc->link_params.req_line_speed[idx] = ELINK_SPEED_AUTO_NEG;
14256             sc->port.advertising[idx] = sc->port.supported[idx];
14257             break;
14258         }
14259
14260         sc->link_params.req_flow_ctrl[idx] =
14261             (link_config & PORT_FEATURE_FLOW_CONTROL_MASK);
14262
14263         if (sc->link_params.req_flow_ctrl[idx] == ELINK_FLOW_CTRL_AUTO) {
14264             if (!(sc->port.supported[idx] & ELINK_SUPPORTED_Autoneg)) {
14265                 sc->link_params.req_flow_ctrl[idx] = ELINK_FLOW_CTRL_NONE;
14266             } else {
14267                 bxe_set_requested_fc(sc);
14268             }
14269         }
14270
14271         BLOGD(sc, DBG_LOAD, "req_line_speed=%d req_duplex=%d "
14272                             "req_flow_ctrl=0x%x advertising=0x%x\n",
14273               sc->link_params.req_line_speed[idx],
14274               sc->link_params.req_duplex[idx],
14275               sc->link_params.req_flow_ctrl[idx],
14276               sc->port.advertising[idx]);
14277     }
14278 }
14279
14280 static void
14281 bxe_get_phy_info(struct bxe_softc *sc)
14282 {
14283     uint8_t port = SC_PORT(sc);
14284     uint32_t config = sc->port.config;
14285     uint32_t eee_mode;
14286
14287     /* shmem data already read in bxe_get_shmem_info() */
14288
14289     BLOGD(sc, DBG_LOAD, "lane_config=0x%08x speed_cap_mask0=0x%08x "
14290                         "link_config0=0x%08x\n",
14291                sc->link_params.lane_config,
14292                sc->link_params.speed_cap_mask[0],
14293                sc->port.link_config[0]);
14294
14295     bxe_link_settings_supported(sc, sc->link_params.switch_cfg);
14296     bxe_link_settings_requested(sc);
14297
14298     if (sc->autogreeen == AUTO_GREEN_FORCE_ON) {
14299         sc->link_params.feature_config_flags |=
14300             ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED;
14301     } else if (sc->autogreeen == AUTO_GREEN_FORCE_OFF) {
14302         sc->link_params.feature_config_flags &=
14303             ~ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED;
14304     } else if (config & PORT_FEAT_CFG_AUTOGREEEN_ENABLED) {
14305         sc->link_params.feature_config_flags |=
14306             ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED;
14307     }
14308
14309     /* configure link feature according to nvram value */
14310     eee_mode =
14311         (((SHMEM_RD(sc, dev_info.port_feature_config[port].eee_power_mode)) &
14312           PORT_FEAT_CFG_EEE_POWER_MODE_MASK) >>
14313          PORT_FEAT_CFG_EEE_POWER_MODE_SHIFT);
14314     if (eee_mode != PORT_FEAT_CFG_EEE_POWER_MODE_DISABLED) {
14315         sc->link_params.eee_mode = (ELINK_EEE_MODE_ADV_LPI |
14316                                     ELINK_EEE_MODE_ENABLE_LPI |
14317                                     ELINK_EEE_MODE_OUTPUT_TIME);
14318     } else {
14319         sc->link_params.eee_mode = 0;
14320     }
14321
14322     /* get the media type */
14323     bxe_media_detect(sc);
14324 }
14325
14326 static void
14327 bxe_get_params(struct bxe_softc *sc)
14328 {
14329     /* get user tunable params */
14330     bxe_get_tunable_params(sc);
14331
14332     /* select the RX and TX ring sizes */
14333     sc->tx_ring_size = TX_BD_USABLE;
14334     sc->rx_ring_size = RX_BD_USABLE;
14335
14336     /* XXX disable WoL */
14337     sc->wol = 0;
14338 }
14339
14340 static void
14341 bxe_set_modes_bitmap(struct bxe_softc *sc)
14342 {
14343     uint32_t flags = 0;
14344
14345     if (CHIP_REV_IS_FPGA(sc)) {
14346         SET_FLAGS(flags, MODE_FPGA);
14347     } else if (CHIP_REV_IS_EMUL(sc)) {
14348         SET_FLAGS(flags, MODE_EMUL);
14349     } else {
14350         SET_FLAGS(flags, MODE_ASIC);
14351     }
14352
14353     if (CHIP_IS_MODE_4_PORT(sc)) {
14354         SET_FLAGS(flags, MODE_PORT4);
14355     } else {
14356         SET_FLAGS(flags, MODE_PORT2);
14357     }
14358
14359     if (CHIP_IS_E2(sc)) {
14360         SET_FLAGS(flags, MODE_E2);
14361     } else if (CHIP_IS_E3(sc)) {
14362         SET_FLAGS(flags, MODE_E3);
14363         if (CHIP_REV(sc) == CHIP_REV_Ax) {
14364             SET_FLAGS(flags, MODE_E3_A0);
14365         } else /*if (CHIP_REV(sc) == CHIP_REV_Bx)*/ {
14366             SET_FLAGS(flags, MODE_E3_B0 | MODE_COS3);
14367         }
14368     }
14369
14370     if (IS_MF(sc)) {
14371         SET_FLAGS(flags, MODE_MF);
14372         switch (sc->devinfo.mf_info.mf_mode) {
14373         case MULTI_FUNCTION_SD:
14374             SET_FLAGS(flags, MODE_MF_SD);
14375             break;
14376         case MULTI_FUNCTION_SI:
14377             SET_FLAGS(flags, MODE_MF_SI);
14378             break;
14379         case MULTI_FUNCTION_AFEX:
14380             SET_FLAGS(flags, MODE_MF_AFEX);
14381             break;
14382         }
14383     } else {
14384         SET_FLAGS(flags, MODE_SF);
14385     }
14386
14387 #if defined(__LITTLE_ENDIAN)
14388     SET_FLAGS(flags, MODE_LITTLE_ENDIAN);
14389 #else /* __BIG_ENDIAN */
14390     SET_FLAGS(flags, MODE_BIG_ENDIAN);
14391 #endif
14392
14393     INIT_MODE_FLAGS(sc) = flags;
14394 }
14395
14396 static int
14397 bxe_alloc_hsi_mem(struct bxe_softc *sc)
14398 {
14399     struct bxe_fastpath *fp;
14400     bus_addr_t busaddr;
14401     int max_agg_queues;
14402     int max_segments;
14403     bus_size_t max_size;
14404     bus_size_t max_seg_size;
14405     char buf[32];
14406     int rc;
14407     int i, j;
14408
14409     /* XXX zero out all vars here and call bxe_alloc_hsi_mem on error */
14410
14411     /* allocate the parent bus DMA tag */
14412     rc = bus_dma_tag_create(bus_get_dma_tag(sc->dev), /* parent tag */
14413                             1,                        /* alignment */
14414                             0,                        /* boundary limit */
14415                             BUS_SPACE_MAXADDR,        /* restricted low */
14416                             BUS_SPACE_MAXADDR,        /* restricted hi */
14417                             NULL,                     /* addr filter() */
14418                             NULL,                     /* addr filter() arg */
14419                             BUS_SPACE_MAXSIZE_32BIT,  /* max map size */
14420                             BUS_SPACE_UNRESTRICTED,   /* num discontinuous */
14421                             BUS_SPACE_MAXSIZE_32BIT,  /* max seg size */
14422                             0,                        /* flags */
14423                             NULL,                     /* lock() */
14424                             NULL,                     /* lock() arg */
14425                             &sc->parent_dma_tag);     /* returned dma tag */
14426     if (rc != 0) {
14427         BLOGE(sc, "Failed to alloc parent DMA tag (%d)!\n", rc);
14428         return (1);
14429     }
14430
14431     /************************/
14432     /* DEFAULT STATUS BLOCK */
14433     /************************/
14434
14435     if (bxe_dma_alloc(sc, sizeof(struct host_sp_status_block),
14436                       &sc->def_sb_dma, "default status block") != 0) {
14437         /* XXX */
14438         bus_dma_tag_destroy(sc->parent_dma_tag);
14439         return (1);
14440     }
14441
14442     sc->def_sb = (struct host_sp_status_block *)sc->def_sb_dma.vaddr;
14443
14444     /***************/
14445     /* EVENT QUEUE */
14446     /***************/
14447
14448     if (bxe_dma_alloc(sc, BCM_PAGE_SIZE,
14449                       &sc->eq_dma, "event queue") != 0) {
14450         /* XXX */
14451         bxe_dma_free(sc, &sc->def_sb_dma);
14452         sc->def_sb = NULL;
14453         bus_dma_tag_destroy(sc->parent_dma_tag);
14454         return (1);
14455     }
14456
14457     sc->eq = (union event_ring_elem * )sc->eq_dma.vaddr;
14458
14459     /*************/
14460     /* SLOW PATH */
14461     /*************/
14462
14463     if (bxe_dma_alloc(sc, sizeof(struct bxe_slowpath),
14464                       &sc->sp_dma, "slow path") != 0) {
14465         /* XXX */
14466         bxe_dma_free(sc, &sc->eq_dma);
14467         sc->eq = NULL;
14468         bxe_dma_free(sc, &sc->def_sb_dma);
14469         sc->def_sb = NULL;
14470         bus_dma_tag_destroy(sc->parent_dma_tag);
14471         return (1);
14472     }
14473
14474     sc->sp = (struct bxe_slowpath *)sc->sp_dma.vaddr;
14475
14476     /*******************/
14477     /* SLOW PATH QUEUE */
14478     /*******************/
14479
14480     if (bxe_dma_alloc(sc, BCM_PAGE_SIZE,
14481                       &sc->spq_dma, "slow path queue") != 0) {
14482         /* XXX */
14483         bxe_dma_free(sc, &sc->sp_dma);
14484         sc->sp = NULL;
14485         bxe_dma_free(sc, &sc->eq_dma);
14486         sc->eq = NULL;
14487         bxe_dma_free(sc, &sc->def_sb_dma);
14488         sc->def_sb = NULL;
14489         bus_dma_tag_destroy(sc->parent_dma_tag);
14490         return (1);
14491     }
14492
14493     sc->spq = (struct eth_spe *)sc->spq_dma.vaddr;
14494
14495     /***************************/
14496     /* FW DECOMPRESSION BUFFER */
14497     /***************************/
14498
14499     if (bxe_dma_alloc(sc, FW_BUF_SIZE, &sc->gz_buf_dma,
14500                       "fw decompression buffer") != 0) {
14501         /* XXX */
14502         bxe_dma_free(sc, &sc->spq_dma);
14503         sc->spq = NULL;
14504         bxe_dma_free(sc, &sc->sp_dma);
14505         sc->sp = NULL;
14506         bxe_dma_free(sc, &sc->eq_dma);
14507         sc->eq = NULL;
14508         bxe_dma_free(sc, &sc->def_sb_dma);
14509         sc->def_sb = NULL;
14510         bus_dma_tag_destroy(sc->parent_dma_tag);
14511         return (1);
14512     }
14513
14514     sc->gz_buf = (void *)sc->gz_buf_dma.vaddr;
14515
14516     if ((sc->gz_strm =
14517          malloc(sizeof(*sc->gz_strm), M_DEVBUF, M_NOWAIT)) == NULL) {
14518         /* XXX */
14519         bxe_dma_free(sc, &sc->gz_buf_dma);
14520         sc->gz_buf = NULL;
14521         bxe_dma_free(sc, &sc->spq_dma);
14522         sc->spq = NULL;
14523         bxe_dma_free(sc, &sc->sp_dma);
14524         sc->sp = NULL;
14525         bxe_dma_free(sc, &sc->eq_dma);
14526         sc->eq = NULL;
14527         bxe_dma_free(sc, &sc->def_sb_dma);
14528         sc->def_sb = NULL;
14529         bus_dma_tag_destroy(sc->parent_dma_tag);
14530         return (1);
14531     }
14532
14533     /*************/
14534     /* FASTPATHS */
14535     /*************/
14536
14537     /* allocate DMA memory for each fastpath structure */
14538     for (i = 0; i < sc->num_queues; i++) {
14539         fp = &sc->fp[i];
14540         fp->sc    = sc;
14541         fp->index = i;
14542
14543         /*******************/
14544         /* FP STATUS BLOCK */
14545         /*******************/
14546
14547         snprintf(buf, sizeof(buf), "fp %d status block", i);
14548         if (bxe_dma_alloc(sc, sizeof(union bxe_host_hc_status_block),
14549                           &fp->sb_dma, buf) != 0) {
14550             /* XXX unwind and free previous fastpath allocations */
14551             BLOGE(sc, "Failed to alloc %s\n", buf);
14552             return (1);
14553         } else {
14554             if (CHIP_IS_E2E3(sc)) {
14555                 fp->status_block.e2_sb =
14556                     (struct host_hc_status_block_e2 *)fp->sb_dma.vaddr;
14557             } else {
14558                 fp->status_block.e1x_sb =
14559                     (struct host_hc_status_block_e1x *)fp->sb_dma.vaddr;
14560             }
14561         }
14562
14563         /******************/
14564         /* FP TX BD CHAIN */
14565         /******************/
14566
14567         snprintf(buf, sizeof(buf), "fp %d tx bd chain", i);
14568         if (bxe_dma_alloc(sc, (BCM_PAGE_SIZE * TX_BD_NUM_PAGES),
14569                           &fp->tx_dma, buf) != 0) {
14570             /* XXX unwind and free previous fastpath allocations */
14571             BLOGE(sc, "Failed to alloc %s\n", buf);
14572             return (1);
14573         } else {
14574             fp->tx_chain = (union eth_tx_bd_types *)fp->tx_dma.vaddr;
14575         }
14576
14577         /* link together the tx bd chain pages */
14578         for (j = 1; j <= TX_BD_NUM_PAGES; j++) {
14579             /* index into the tx bd chain array to last entry per page */
14580             struct eth_tx_next_bd *tx_next_bd =
14581                 &fp->tx_chain[TX_BD_TOTAL_PER_PAGE * j - 1].next_bd;
14582             /* point to the next page and wrap from last page */
14583             busaddr = (fp->tx_dma.paddr +
14584                        (BCM_PAGE_SIZE * (j % TX_BD_NUM_PAGES)));
14585             tx_next_bd->addr_hi = htole32(U64_HI(busaddr));
14586             tx_next_bd->addr_lo = htole32(U64_LO(busaddr));
14587         }
14588
14589         /******************/
14590         /* FP RX BD CHAIN */
14591         /******************/
14592
14593         snprintf(buf, sizeof(buf), "fp %d rx bd chain", i);
14594         if (bxe_dma_alloc(sc, (BCM_PAGE_SIZE * RX_BD_NUM_PAGES),
14595                           &fp->rx_dma, buf) != 0) {
14596             /* XXX unwind and free previous fastpath allocations */
14597             BLOGE(sc, "Failed to alloc %s\n", buf);
14598             return (1);
14599         } else {
14600             fp->rx_chain = (struct eth_rx_bd *)fp->rx_dma.vaddr;
14601         }
14602
14603         /* link together the rx bd chain pages */
14604         for (j = 1; j <= RX_BD_NUM_PAGES; j++) {
14605             /* index into the rx bd chain array to last entry per page */
14606             struct eth_rx_bd *rx_bd =
14607                 &fp->rx_chain[RX_BD_TOTAL_PER_PAGE * j - 2];
14608             /* point to the next page and wrap from last page */
14609             busaddr = (fp->rx_dma.paddr +
14610                        (BCM_PAGE_SIZE * (j % RX_BD_NUM_PAGES)));
14611             rx_bd->addr_hi = htole32(U64_HI(busaddr));
14612             rx_bd->addr_lo = htole32(U64_LO(busaddr));
14613         }
14614
14615         /*******************/
14616         /* FP RX RCQ CHAIN */
14617         /*******************/
14618
14619         snprintf(buf, sizeof(buf), "fp %d rcq chain", i);
14620         if (bxe_dma_alloc(sc, (BCM_PAGE_SIZE * RCQ_NUM_PAGES),
14621                           &fp->rcq_dma, buf) != 0) {
14622             /* XXX unwind and free previous fastpath allocations */
14623             BLOGE(sc, "Failed to alloc %s\n", buf);
14624             return (1);
14625         } else {
14626             fp->rcq_chain = (union eth_rx_cqe *)fp->rcq_dma.vaddr;
14627         }
14628
14629         /* link together the rcq chain pages */
14630         for (j = 1; j <= RCQ_NUM_PAGES; j++) {
14631             /* index into the rcq chain array to last entry per page */
14632             struct eth_rx_cqe_next_page *rx_cqe_next =
14633                 (struct eth_rx_cqe_next_page *)
14634                 &fp->rcq_chain[RCQ_TOTAL_PER_PAGE * j - 1];
14635             /* point to the next page and wrap from last page */
14636             busaddr = (fp->rcq_dma.paddr +
14637                        (BCM_PAGE_SIZE * (j % RCQ_NUM_PAGES)));
14638             rx_cqe_next->addr_hi = htole32(U64_HI(busaddr));
14639             rx_cqe_next->addr_lo = htole32(U64_LO(busaddr));
14640         }
14641
14642         /*******************/
14643         /* FP RX SGE CHAIN */
14644         /*******************/
14645
14646         snprintf(buf, sizeof(buf), "fp %d sge chain", i);
14647         if (bxe_dma_alloc(sc, (BCM_PAGE_SIZE * RX_SGE_NUM_PAGES),
14648                           &fp->rx_sge_dma, buf) != 0) {
14649             /* XXX unwind and free previous fastpath allocations */
14650             BLOGE(sc, "Failed to alloc %s\n", buf);
14651             return (1);
14652         } else {
14653             fp->rx_sge_chain = (struct eth_rx_sge *)fp->rx_sge_dma.vaddr;
14654         }
14655
14656         /* link together the sge chain pages */
14657         for (j = 1; j <= RX_SGE_NUM_PAGES; j++) {
14658             /* index into the rcq chain array to last entry per page */
14659             struct eth_rx_sge *rx_sge =
14660                 &fp->rx_sge_chain[RX_SGE_TOTAL_PER_PAGE * j - 2];
14661             /* point to the next page and wrap from last page */
14662             busaddr = (fp->rx_sge_dma.paddr +
14663                        (BCM_PAGE_SIZE * (j % RX_SGE_NUM_PAGES)));
14664             rx_sge->addr_hi = htole32(U64_HI(busaddr));
14665             rx_sge->addr_lo = htole32(U64_LO(busaddr));
14666         }
14667
14668         /***********************/
14669         /* FP TX MBUF DMA MAPS */
14670         /***********************/
14671
14672         /* set required sizes before mapping to conserve resources */
14673         if (sc->ifnet->if_capenable & (IFCAP_TSO4 | IFCAP_TSO6)) {
14674             max_size     = BXE_TSO_MAX_SIZE;
14675             max_segments = BXE_TSO_MAX_SEGMENTS;
14676             max_seg_size = BXE_TSO_MAX_SEG_SIZE;
14677         } else {
14678             max_size     = (MCLBYTES * BXE_MAX_SEGMENTS);
14679             max_segments = BXE_MAX_SEGMENTS;
14680             max_seg_size = MCLBYTES;
14681         }
14682
14683         /* create a dma tag for the tx mbufs */
14684         rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
14685                                 1,                  /* alignment */
14686                                 0,                  /* boundary limit */
14687                                 BUS_SPACE_MAXADDR,  /* restricted low */
14688                                 BUS_SPACE_MAXADDR,  /* restricted hi */
14689                                 NULL,               /* addr filter() */
14690                                 NULL,               /* addr filter() arg */
14691                                 max_size,           /* max map size */
14692                                 max_segments,       /* num discontinuous */
14693                                 max_seg_size,       /* max seg size */
14694                                 0,                  /* flags */
14695                                 NULL,               /* lock() */
14696                                 NULL,               /* lock() arg */
14697                                 &fp->tx_mbuf_tag);  /* returned dma tag */
14698         if (rc != 0) {
14699             /* XXX unwind and free previous fastpath allocations */
14700             BLOGE(sc, "Failed to create dma tag for "
14701                       "'fp %d tx mbufs' (%d)\n", i, rc);
14702             return (1);
14703         }
14704
14705         /* create dma maps for each of the tx mbuf clusters */
14706         for (j = 0; j < TX_BD_TOTAL; j++) {
14707             if (bus_dmamap_create(fp->tx_mbuf_tag,
14708                                   BUS_DMA_NOWAIT,
14709                                   &fp->tx_mbuf_chain[j].m_map)) {
14710                 /* XXX unwind and free previous fastpath allocations */
14711                 BLOGE(sc, "Failed to create dma map for "
14712                           "'fp %d tx mbuf %d' (%d)\n", i, j, rc);
14713                 return (1);
14714             }
14715         }
14716
14717         /***********************/
14718         /* FP RX MBUF DMA MAPS */
14719         /***********************/
14720
14721         /* create a dma tag for the rx mbufs */
14722         rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
14723                                 1,                  /* alignment */
14724                                 0,                  /* boundary limit */
14725                                 BUS_SPACE_MAXADDR,  /* restricted low */
14726                                 BUS_SPACE_MAXADDR,  /* restricted hi */
14727                                 NULL,               /* addr filter() */
14728                                 NULL,               /* addr filter() arg */
14729                                 MJUM9BYTES,         /* max map size */
14730                                 1,                  /* num discontinuous */
14731                                 MJUM9BYTES,         /* max seg size */
14732                                 0,                  /* flags */
14733                                 NULL,               /* lock() */
14734                                 NULL,               /* lock() arg */
14735                                 &fp->rx_mbuf_tag);  /* returned dma tag */
14736         if (rc != 0) {
14737             /* XXX unwind and free previous fastpath allocations */
14738             BLOGE(sc, "Failed to create dma tag for "
14739                       "'fp %d rx mbufs' (%d)\n", i, rc);
14740             return (1);
14741         }
14742
14743         /* create dma maps for each of the rx mbuf clusters */
14744         for (j = 0; j < RX_BD_TOTAL; j++) {
14745             if (bus_dmamap_create(fp->rx_mbuf_tag,
14746                                   BUS_DMA_NOWAIT,
14747                                   &fp->rx_mbuf_chain[j].m_map)) {
14748                 /* XXX unwind and free previous fastpath allocations */
14749                 BLOGE(sc, "Failed to create dma map for "
14750                           "'fp %d rx mbuf %d' (%d)\n", i, j, rc);
14751                 return (1);
14752             }
14753         }
14754
14755         /* create dma map for the spare rx mbuf cluster */
14756         if (bus_dmamap_create(fp->rx_mbuf_tag,
14757                               BUS_DMA_NOWAIT,
14758                               &fp->rx_mbuf_spare_map)) {
14759             /* XXX unwind and free previous fastpath allocations */
14760             BLOGE(sc, "Failed to create dma map for "
14761                       "'fp %d spare rx mbuf' (%d)\n", i, rc);
14762             return (1);
14763         }
14764
14765         /***************************/
14766         /* FP RX SGE MBUF DMA MAPS */
14767         /***************************/
14768
14769         /* create a dma tag for the rx sge mbufs */
14770         rc = bus_dma_tag_create(sc->parent_dma_tag, /* parent tag */
14771                                 1,                  /* alignment */
14772                                 0,                  /* boundary limit */
14773                                 BUS_SPACE_MAXADDR,  /* restricted low */
14774                                 BUS_SPACE_MAXADDR,  /* restricted hi */
14775                                 NULL,               /* addr filter() */
14776                                 NULL,               /* addr filter() arg */
14777                                 BCM_PAGE_SIZE,      /* max map size */
14778                                 1,                  /* num discontinuous */
14779                                 BCM_PAGE_SIZE,      /* max seg size */
14780                                 0,                  /* flags */
14781                                 NULL,               /* lock() */
14782                                 NULL,               /* lock() arg */
14783                                 &fp->rx_sge_mbuf_tag); /* returned dma tag */
14784         if (rc != 0) {
14785             /* XXX unwind and free previous fastpath allocations */
14786             BLOGE(sc, "Failed to create dma tag for "
14787                       "'fp %d rx sge mbufs' (%d)\n", i, rc);
14788             return (1);
14789         }
14790
14791         /* create dma maps for the rx sge mbuf clusters */
14792         for (j = 0; j < RX_SGE_TOTAL; j++) {
14793             if (bus_dmamap_create(fp->rx_sge_mbuf_tag,
14794                                   BUS_DMA_NOWAIT,
14795                                   &fp->rx_sge_mbuf_chain[j].m_map)) {
14796                 /* XXX unwind and free previous fastpath allocations */
14797                 BLOGE(sc, "Failed to create dma map for "
14798                           "'fp %d rx sge mbuf %d' (%d)\n", i, j, rc);
14799                 return (1);
14800             }
14801         }
14802
14803         /* create dma map for the spare rx sge mbuf cluster */
14804         if (bus_dmamap_create(fp->rx_sge_mbuf_tag,
14805                               BUS_DMA_NOWAIT,
14806                               &fp->rx_sge_mbuf_spare_map)) {
14807             /* XXX unwind and free previous fastpath allocations */
14808             BLOGE(sc, "Failed to create dma map for "
14809                       "'fp %d spare rx sge mbuf' (%d)\n", i, rc);
14810             return (1);
14811         }
14812
14813         /***************************/
14814         /* FP RX TPA MBUF DMA MAPS */
14815         /***************************/
14816
14817         /* create dma maps for the rx tpa mbuf clusters */
14818         max_agg_queues = MAX_AGG_QS(sc);
14819
14820         for (j = 0; j < max_agg_queues; j++) {
14821             if (bus_dmamap_create(fp->rx_mbuf_tag,
14822                                   BUS_DMA_NOWAIT,
14823                                   &fp->rx_tpa_info[j].bd.m_map)) {
14824                 /* XXX unwind and free previous fastpath allocations */
14825                 BLOGE(sc, "Failed to create dma map for "
14826                           "'fp %d rx tpa mbuf %d' (%d)\n", i, j, rc);
14827                 return (1);
14828             }
14829         }
14830
14831         /* create dma map for the spare rx tpa mbuf cluster */
14832         if (bus_dmamap_create(fp->rx_mbuf_tag,
14833                               BUS_DMA_NOWAIT,
14834                               &fp->rx_tpa_info_mbuf_spare_map)) {
14835             /* XXX unwind and free previous fastpath allocations */
14836             BLOGE(sc, "Failed to create dma map for "
14837                       "'fp %d spare rx tpa mbuf' (%d)\n", i, rc);
14838             return (1);
14839         }
14840
14841         bxe_init_sge_ring_bit_mask(fp);
14842     }
14843
14844     return (0);
14845 }
14846
14847 static void
14848 bxe_free_hsi_mem(struct bxe_softc *sc)
14849 {
14850     struct bxe_fastpath *fp;
14851     int max_agg_queues;
14852     int i, j;
14853
14854     if (sc->parent_dma_tag == NULL) {
14855         return; /* assume nothing was allocated */
14856     }
14857
14858     for (i = 0; i < sc->num_queues; i++) {
14859         fp = &sc->fp[i];
14860
14861         /*******************/
14862         /* FP STATUS BLOCK */
14863         /*******************/
14864
14865         bxe_dma_free(sc, &fp->sb_dma);
14866         memset(&fp->status_block, 0, sizeof(fp->status_block));
14867
14868         /******************/
14869         /* FP TX BD CHAIN */
14870         /******************/
14871
14872         bxe_dma_free(sc, &fp->tx_dma);
14873         fp->tx_chain = NULL;
14874
14875         /******************/
14876         /* FP RX BD CHAIN */
14877         /******************/
14878
14879         bxe_dma_free(sc, &fp->rx_dma);
14880         fp->rx_chain = NULL;
14881
14882         /*******************/
14883         /* FP RX RCQ CHAIN */
14884         /*******************/
14885
14886         bxe_dma_free(sc, &fp->rcq_dma);
14887         fp->rcq_chain = NULL;
14888
14889         /*******************/
14890         /* FP RX SGE CHAIN */
14891         /*******************/
14892
14893         bxe_dma_free(sc, &fp->rx_sge_dma);
14894         fp->rx_sge_chain = NULL;
14895
14896         /***********************/
14897         /* FP TX MBUF DMA MAPS */
14898         /***********************/
14899
14900         if (fp->tx_mbuf_tag != NULL) {
14901             for (j = 0; j < TX_BD_TOTAL; j++) {
14902                 if (fp->tx_mbuf_chain[j].m_map != NULL) {
14903                     bus_dmamap_unload(fp->tx_mbuf_tag,
14904                                       fp->tx_mbuf_chain[j].m_map);
14905                     bus_dmamap_destroy(fp->tx_mbuf_tag,
14906                                        fp->tx_mbuf_chain[j].m_map);
14907                 }
14908             }
14909
14910             bus_dma_tag_destroy(fp->tx_mbuf_tag);
14911             fp->tx_mbuf_tag = NULL;
14912         }
14913
14914         /***********************/
14915         /* FP RX MBUF DMA MAPS */
14916         /***********************/
14917
14918         if (fp->rx_mbuf_tag != NULL) {
14919             for (j = 0; j < RX_BD_TOTAL; j++) {
14920                 if (fp->rx_mbuf_chain[j].m_map != NULL) {
14921                     bus_dmamap_unload(fp->rx_mbuf_tag,
14922                                       fp->rx_mbuf_chain[j].m_map);
14923                     bus_dmamap_destroy(fp->rx_mbuf_tag,
14924                                        fp->rx_mbuf_chain[j].m_map);
14925                 }
14926             }
14927
14928             if (fp->rx_mbuf_spare_map != NULL) {
14929                 bus_dmamap_unload(fp->rx_mbuf_tag, fp->rx_mbuf_spare_map);
14930                 bus_dmamap_destroy(fp->rx_mbuf_tag, fp->rx_mbuf_spare_map);
14931             }
14932
14933             /***************************/
14934             /* FP RX TPA MBUF DMA MAPS */
14935             /***************************/
14936
14937             max_agg_queues = MAX_AGG_QS(sc);
14938
14939             for (j = 0; j < max_agg_queues; j++) {
14940                 if (fp->rx_tpa_info[j].bd.m_map != NULL) {
14941                     bus_dmamap_unload(fp->rx_mbuf_tag,
14942                                       fp->rx_tpa_info[j].bd.m_map);
14943                     bus_dmamap_destroy(fp->rx_mbuf_tag,
14944                                        fp->rx_tpa_info[j].bd.m_map);
14945                 }
14946             }
14947
14948             if (fp->rx_tpa_info_mbuf_spare_map != NULL) {
14949                 bus_dmamap_unload(fp->rx_mbuf_tag,
14950                                   fp->rx_tpa_info_mbuf_spare_map);
14951                 bus_dmamap_destroy(fp->rx_mbuf_tag,
14952                                    fp->rx_tpa_info_mbuf_spare_map);
14953             }
14954
14955             bus_dma_tag_destroy(fp->rx_mbuf_tag);
14956             fp->rx_mbuf_tag = NULL;
14957         }
14958
14959         /***************************/
14960         /* FP RX SGE MBUF DMA MAPS */
14961         /***************************/
14962
14963         if (fp->rx_sge_mbuf_tag != NULL) {
14964             for (j = 0; j < RX_SGE_TOTAL; j++) {
14965                 if (fp->rx_sge_mbuf_chain[j].m_map != NULL) {
14966                     bus_dmamap_unload(fp->rx_sge_mbuf_tag,
14967                                       fp->rx_sge_mbuf_chain[j].m_map);
14968                     bus_dmamap_destroy(fp->rx_sge_mbuf_tag,
14969                                        fp->rx_sge_mbuf_chain[j].m_map);
14970                 }
14971             }
14972
14973             if (fp->rx_sge_mbuf_spare_map != NULL) {
14974                 bus_dmamap_unload(fp->rx_sge_mbuf_tag,
14975                                   fp->rx_sge_mbuf_spare_map);
14976                 bus_dmamap_destroy(fp->rx_sge_mbuf_tag,
14977                                    fp->rx_sge_mbuf_spare_map);
14978             }
14979
14980             bus_dma_tag_destroy(fp->rx_sge_mbuf_tag);
14981             fp->rx_sge_mbuf_tag = NULL;
14982         }
14983     }
14984
14985     /***************************/
14986     /* FW DECOMPRESSION BUFFER */
14987     /***************************/
14988
14989     bxe_dma_free(sc, &sc->gz_buf_dma);
14990     sc->gz_buf = NULL;
14991     free(sc->gz_strm, M_DEVBUF);
14992     sc->gz_strm = NULL;
14993
14994     /*******************/
14995     /* SLOW PATH QUEUE */
14996     /*******************/
14997
14998     bxe_dma_free(sc, &sc->spq_dma);
14999     sc->spq = NULL;
15000
15001     /*************/
15002     /* SLOW PATH */
15003     /*************/
15004
15005     bxe_dma_free(sc, &sc->sp_dma);
15006     sc->sp = NULL;
15007
15008     /***************/
15009     /* EVENT QUEUE */
15010     /***************/
15011
15012     bxe_dma_free(sc, &sc->eq_dma);
15013     sc->eq = NULL;
15014
15015     /************************/
15016     /* DEFAULT STATUS BLOCK */
15017     /************************/
15018
15019     bxe_dma_free(sc, &sc->def_sb_dma);
15020     sc->def_sb = NULL;
15021
15022     bus_dma_tag_destroy(sc->parent_dma_tag);
15023     sc->parent_dma_tag = NULL;
15024 }
15025
15026 /*
15027  * Previous driver DMAE transaction may have occurred when pre-boot stage
15028  * ended and boot began. This would invalidate the addresses of the
15029  * transaction, resulting in was-error bit set in the PCI causing all
15030  * hw-to-host PCIe transactions to timeout. If this happened we want to clear
15031  * the interrupt which detected this from the pglueb and the was-done bit
15032  */
15033 static void
15034 bxe_prev_interrupted_dmae(struct bxe_softc *sc)
15035 {
15036     uint32_t val;
15037
15038     if (!CHIP_IS_E1x(sc)) {
15039         val = REG_RD(sc, PGLUE_B_REG_PGLUE_B_INT_STS);
15040         if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN) {
15041             BLOGD(sc, DBG_LOAD,
15042                   "Clearing 'was-error' bit that was set in pglueb");
15043             REG_WR(sc, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, 1 << SC_FUNC(sc));
15044         }
15045     }
15046 }
15047
15048 static int
15049 bxe_prev_mcp_done(struct bxe_softc *sc)
15050 {
15051     uint32_t rc = bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE,
15052                                  DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET);
15053     if (!rc) {
15054         BLOGE(sc, "MCP response failure, aborting\n");
15055         return (-1);
15056     }
15057
15058     return (0);
15059 }
15060
15061 static struct bxe_prev_list_node *
15062 bxe_prev_path_get_entry(struct bxe_softc *sc)
15063 {
15064     struct bxe_prev_list_node *tmp;
15065
15066     LIST_FOREACH(tmp, &bxe_prev_list, node) {
15067         if ((sc->pcie_bus == tmp->bus) &&
15068             (sc->pcie_device == tmp->slot) &&
15069             (SC_PATH(sc) == tmp->path)) {
15070             return (tmp);
15071         }
15072     }
15073
15074     return (NULL);
15075 }
15076
15077 static uint8_t
15078 bxe_prev_is_path_marked(struct bxe_softc *sc)
15079 {
15080     struct bxe_prev_list_node *tmp;
15081     int rc = FALSE;
15082
15083     mtx_lock(&bxe_prev_mtx);
15084
15085     tmp = bxe_prev_path_get_entry(sc);
15086     if (tmp) {
15087         if (tmp->aer) {
15088             BLOGD(sc, DBG_LOAD,
15089                   "Path %d/%d/%d was marked by AER\n",
15090                   sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
15091         } else {
15092             rc = TRUE;
15093             BLOGD(sc, DBG_LOAD,
15094                   "Path %d/%d/%d was already cleaned from previous drivers\n",
15095                   sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
15096         }
15097     }
15098
15099     mtx_unlock(&bxe_prev_mtx);
15100
15101     return (rc);
15102 }
15103
15104 static int
15105 bxe_prev_mark_path(struct bxe_softc *sc,
15106                    uint8_t          after_undi)
15107 {
15108     struct bxe_prev_list_node *tmp;
15109
15110     mtx_lock(&bxe_prev_mtx);
15111
15112     /* Check whether the entry for this path already exists */
15113     tmp = bxe_prev_path_get_entry(sc);
15114     if (tmp) {
15115         if (!tmp->aer) {
15116             BLOGD(sc, DBG_LOAD,
15117                   "Re-marking AER in path %d/%d/%d\n",
15118                   sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
15119         } else {
15120             BLOGD(sc, DBG_LOAD,
15121                   "Removing AER indication from path %d/%d/%d\n",
15122                   sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
15123             tmp->aer = 0;
15124         }
15125
15126         mtx_unlock(&bxe_prev_mtx);
15127         return (0);
15128     }
15129
15130     mtx_unlock(&bxe_prev_mtx);
15131
15132     /* Create an entry for this path and add it */
15133     tmp = malloc(sizeof(struct bxe_prev_list_node), M_DEVBUF,
15134                  (M_NOWAIT | M_ZERO));
15135     if (!tmp) {
15136         BLOGE(sc, "Failed to allocate 'bxe_prev_list_node'\n");
15137         return (-1);
15138     }
15139
15140     tmp->bus  = sc->pcie_bus;
15141     tmp->slot = sc->pcie_device;
15142     tmp->path = SC_PATH(sc);
15143     tmp->aer  = 0;
15144     tmp->undi = after_undi ? (1 << SC_PORT(sc)) : 0;
15145
15146     mtx_lock(&bxe_prev_mtx);
15147
15148     BLOGD(sc, DBG_LOAD,
15149           "Marked path %d/%d/%d - finished previous unload\n",
15150           sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
15151     LIST_INSERT_HEAD(&bxe_prev_list, tmp, node);
15152
15153     mtx_unlock(&bxe_prev_mtx);
15154
15155     return (0);
15156 }
15157
15158 static int
15159 bxe_do_flr(struct bxe_softc *sc)
15160 {
15161     int i;
15162
15163     /* only E2 and onwards support FLR */
15164     if (CHIP_IS_E1x(sc)) {
15165         BLOGD(sc, DBG_LOAD, "FLR not supported in E1/E1H\n");
15166         return (-1);
15167     }
15168
15169     /* only bootcode REQ_BC_VER_4_INITIATE_FLR and onwards support flr */
15170     if (sc->devinfo.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
15171         BLOGD(sc, DBG_LOAD, "FLR not supported by BC_VER: 0x%08x\n",
15172               sc->devinfo.bc_ver);
15173         return (-1);
15174     }
15175
15176     /* Wait for Transaction Pending bit clean */
15177     for (i = 0; i < 4; i++) {
15178         if (i) {
15179             DELAY(((1 << (i - 1)) * 100) * 1000);
15180         }
15181
15182         if (!bxe_is_pcie_pending(sc)) {
15183             goto clear;
15184         }
15185     }
15186
15187     BLOGE(sc, "PCIE transaction is not cleared, "
15188               "proceeding with reset anyway\n");
15189
15190 clear:
15191
15192     BLOGD(sc, DBG_LOAD, "Initiating FLR\n");
15193     bxe_fw_command(sc, DRV_MSG_CODE_INITIATE_FLR, 0);
15194
15195     return (0);
15196 }
15197
15198 struct bxe_mac_vals {
15199     uint32_t xmac_addr;
15200     uint32_t xmac_val;
15201     uint32_t emac_addr;
15202     uint32_t emac_val;
15203     uint32_t umac_addr;
15204     uint32_t umac_val;
15205     uint32_t bmac_addr;
15206     uint32_t bmac_val[2];
15207 };
15208
15209 static void
15210 bxe_prev_unload_close_mac(struct bxe_softc *sc,
15211                           struct bxe_mac_vals *vals)
15212 {
15213     uint32_t val, base_addr, offset, mask, reset_reg;
15214     uint8_t mac_stopped = FALSE;
15215     uint8_t port = SC_PORT(sc);
15216     uint32_t wb_data[2];
15217
15218     /* reset addresses as they also mark which values were changed */
15219     vals->bmac_addr = 0;
15220     vals->umac_addr = 0;
15221     vals->xmac_addr = 0;
15222     vals->emac_addr = 0;
15223
15224     reset_reg = REG_RD(sc, MISC_REG_RESET_REG_2);
15225
15226     if (!CHIP_IS_E3(sc)) {
15227         val = REG_RD(sc, NIG_REG_BMAC0_REGS_OUT_EN + port * 4);
15228         mask = MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << port;
15229         if ((mask & reset_reg) && val) {
15230             BLOGD(sc, DBG_LOAD, "Disable BMAC Rx\n");
15231             base_addr = SC_PORT(sc) ? NIG_REG_INGRESS_BMAC1_MEM
15232                                     : NIG_REG_INGRESS_BMAC0_MEM;
15233             offset = CHIP_IS_E2(sc) ? BIGMAC2_REGISTER_BMAC_CONTROL
15234                                     : BIGMAC_REGISTER_BMAC_CONTROL;
15235
15236             /*
15237              * use rd/wr since we cannot use dmae. This is safe
15238              * since MCP won't access the bus due to the request
15239              * to unload, and no function on the path can be
15240              * loaded at this time.
15241              */
15242             wb_data[0] = REG_RD(sc, base_addr + offset);
15243             wb_data[1] = REG_RD(sc, base_addr + offset + 0x4);
15244             vals->bmac_addr = base_addr + offset;
15245             vals->bmac_val[0] = wb_data[0];
15246             vals->bmac_val[1] = wb_data[1];
15247             wb_data[0] &= ~ELINK_BMAC_CONTROL_RX_ENABLE;
15248             REG_WR(sc, vals->bmac_addr, wb_data[0]);
15249             REG_WR(sc, vals->bmac_addr + 0x4, wb_data[1]);
15250         }
15251
15252         BLOGD(sc, DBG_LOAD, "Disable EMAC Rx\n");
15253         vals->emac_addr = NIG_REG_NIG_EMAC0_EN + SC_PORT(sc)*4;
15254         vals->emac_val = REG_RD(sc, vals->emac_addr);
15255         REG_WR(sc, vals->emac_addr, 0);
15256         mac_stopped = TRUE;
15257     } else {
15258         if (reset_reg & MISC_REGISTERS_RESET_REG_2_XMAC) {
15259             BLOGD(sc, DBG_LOAD, "Disable XMAC Rx\n");
15260             base_addr = SC_PORT(sc) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
15261             val = REG_RD(sc, base_addr + XMAC_REG_PFC_CTRL_HI);
15262             REG_WR(sc, base_addr + XMAC_REG_PFC_CTRL_HI, val & ~(1 << 1));
15263             REG_WR(sc, base_addr + XMAC_REG_PFC_CTRL_HI, val | (1 << 1));
15264             vals->xmac_addr = base_addr + XMAC_REG_CTRL;
15265             vals->xmac_val = REG_RD(sc, vals->xmac_addr);
15266             REG_WR(sc, vals->xmac_addr, 0);
15267             mac_stopped = TRUE;
15268         }
15269
15270         mask = MISC_REGISTERS_RESET_REG_2_UMAC0 << port;
15271         if (mask & reset_reg) {
15272             BLOGD(sc, DBG_LOAD, "Disable UMAC Rx\n");
15273             base_addr = SC_PORT(sc) ? GRCBASE_UMAC1 : GRCBASE_UMAC0;
15274             vals->umac_addr = base_addr + UMAC_REG_COMMAND_CONFIG;
15275             vals->umac_val = REG_RD(sc, vals->umac_addr);
15276             REG_WR(sc, vals->umac_addr, 0);
15277             mac_stopped = TRUE;
15278         }
15279     }
15280
15281     if (mac_stopped) {
15282         DELAY(20000);
15283     }
15284 }
15285
15286 #define BXE_PREV_UNDI_PROD_ADDR(p)  (BAR_TSTRORM_INTMEM + 0x1508 + ((p) << 4))
15287 #define BXE_PREV_UNDI_RCQ(val)      ((val) & 0xffff)
15288 #define BXE_PREV_UNDI_BD(val)       ((val) >> 16 & 0xffff)
15289 #define BXE_PREV_UNDI_PROD(rcq, bd) ((bd) << 16 | (rcq))
15290
15291 static void
15292 bxe_prev_unload_undi_inc(struct bxe_softc *sc,
15293                          uint8_t          port,
15294                          uint8_t          inc)
15295 {
15296     uint16_t rcq, bd;
15297     uint32_t tmp_reg = REG_RD(sc, BXE_PREV_UNDI_PROD_ADDR(port));
15298
15299     rcq = BXE_PREV_UNDI_RCQ(tmp_reg) + inc;
15300     bd = BXE_PREV_UNDI_BD(tmp_reg) + inc;
15301
15302     tmp_reg = BXE_PREV_UNDI_PROD(rcq, bd);
15303     REG_WR(sc, BXE_PREV_UNDI_PROD_ADDR(port), tmp_reg);
15304
15305     BLOGD(sc, DBG_LOAD,
15306           "UNDI producer [%d] rings bd -> 0x%04x, rcq -> 0x%04x\n",
15307           port, bd, rcq);
15308 }
15309
15310 static int
15311 bxe_prev_unload_common(struct bxe_softc *sc)
15312 {
15313     uint32_t reset_reg, tmp_reg = 0, rc;
15314     uint8_t prev_undi = FALSE;
15315     struct bxe_mac_vals mac_vals;
15316     uint32_t timer_count = 1000;
15317     uint32_t prev_brb;
15318
15319     /*
15320      * It is possible a previous function received 'common' answer,
15321      * but hasn't loaded yet, therefore creating a scenario of
15322      * multiple functions receiving 'common' on the same path.
15323      */
15324     BLOGD(sc, DBG_LOAD, "Common unload Flow\n");
15325
15326     memset(&mac_vals, 0, sizeof(mac_vals));
15327
15328     if (bxe_prev_is_path_marked(sc)) {
15329         return (bxe_prev_mcp_done(sc));
15330     }
15331
15332     reset_reg = REG_RD(sc, MISC_REG_RESET_REG_1);
15333
15334     /* Reset should be performed after BRB is emptied */
15335     if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_BRB1) {
15336         /* Close the MAC Rx to prevent BRB from filling up */
15337         bxe_prev_unload_close_mac(sc, &mac_vals);
15338
15339         /* close LLH filters towards the BRB */
15340         elink_set_rx_filter(&sc->link_params, 0);
15341
15342         /*
15343          * Check if the UNDI driver was previously loaded.
15344          * UNDI driver initializes CID offset for normal bell to 0x7
15345          */
15346         if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_DORQ) {
15347             tmp_reg = REG_RD(sc, DORQ_REG_NORM_CID_OFST);
15348             if (tmp_reg == 0x7) {
15349                 BLOGD(sc, DBG_LOAD, "UNDI previously loaded\n");
15350                 prev_undi = TRUE;
15351                 /* clear the UNDI indication */
15352                 REG_WR(sc, DORQ_REG_NORM_CID_OFST, 0);
15353                 /* clear possible idle check errors */
15354                 REG_RD(sc, NIG_REG_NIG_INT_STS_CLR_0);
15355             }
15356         }
15357
15358         /* wait until BRB is empty */
15359         tmp_reg = REG_RD(sc, BRB1_REG_NUM_OF_FULL_BLOCKS);
15360         while (timer_count) {
15361             prev_brb = tmp_reg;
15362
15363             tmp_reg = REG_RD(sc, BRB1_REG_NUM_OF_FULL_BLOCKS);
15364             if (!tmp_reg) {
15365                 break;
15366             }
15367
15368             BLOGD(sc, DBG_LOAD, "BRB still has 0x%08x\n", tmp_reg);
15369
15370             /* reset timer as long as BRB actually gets emptied */
15371             if (prev_brb > tmp_reg) {
15372                 timer_count = 1000;
15373             } else {
15374                 timer_count--;
15375             }
15376
15377             /* If UNDI resides in memory, manually increment it */
15378             if (prev_undi) {
15379                 bxe_prev_unload_undi_inc(sc, SC_PORT(sc), 1);
15380             }
15381
15382             DELAY(10);
15383         }
15384
15385         if (!timer_count) {
15386             BLOGE(sc, "Failed to empty BRB\n");
15387         }
15388     }
15389
15390     /* No packets are in the pipeline, path is ready for reset */
15391     bxe_reset_common(sc);
15392
15393     if (mac_vals.xmac_addr) {
15394         REG_WR(sc, mac_vals.xmac_addr, mac_vals.xmac_val);
15395     }
15396     if (mac_vals.umac_addr) {
15397         REG_WR(sc, mac_vals.umac_addr, mac_vals.umac_val);
15398     }
15399     if (mac_vals.emac_addr) {
15400         REG_WR(sc, mac_vals.emac_addr, mac_vals.emac_val);
15401     }
15402     if (mac_vals.bmac_addr) {
15403         REG_WR(sc, mac_vals.bmac_addr, mac_vals.bmac_val[0]);
15404         REG_WR(sc, mac_vals.bmac_addr + 4, mac_vals.bmac_val[1]);
15405     }
15406
15407     rc = bxe_prev_mark_path(sc, prev_undi);
15408     if (rc) {
15409         bxe_prev_mcp_done(sc);
15410         return (rc);
15411     }
15412
15413     return (bxe_prev_mcp_done(sc));
15414 }
15415
15416 static int
15417 bxe_prev_unload_uncommon(struct bxe_softc *sc)
15418 {
15419     int rc;
15420
15421     BLOGD(sc, DBG_LOAD, "Uncommon unload Flow\n");
15422
15423     /* Test if previous unload process was already finished for this path */
15424     if (bxe_prev_is_path_marked(sc)) {
15425         return (bxe_prev_mcp_done(sc));
15426     }
15427
15428     BLOGD(sc, DBG_LOAD, "Path is unmarked\n");
15429
15430     /*
15431      * If function has FLR capabilities, and existing FW version matches
15432      * the one required, then FLR will be sufficient to clean any residue
15433      * left by previous driver
15434      */
15435     rc = bxe_nic_load_analyze_req(sc, FW_MSG_CODE_DRV_LOAD_FUNCTION);
15436     if (!rc) {
15437         /* fw version is good */
15438         BLOGD(sc, DBG_LOAD, "FW version matches our own, attempting FLR\n");
15439         rc = bxe_do_flr(sc);
15440     }
15441
15442     if (!rc) {
15443         /* FLR was performed */
15444         BLOGD(sc, DBG_LOAD, "FLR successful\n");
15445         return (0);
15446     }
15447
15448     BLOGD(sc, DBG_LOAD, "Could not FLR\n");
15449
15450     /* Close the MCP request, return failure*/
15451     rc = bxe_prev_mcp_done(sc);
15452     if (!rc) {
15453         rc = BXE_PREV_WAIT_NEEDED;
15454     }
15455
15456     return (rc);
15457 }
15458
15459 static int
15460 bxe_prev_unload(struct bxe_softc *sc)
15461 {
15462     int time_counter = 10;
15463     uint32_t fw, hw_lock_reg, hw_lock_val;
15464     uint32_t rc = 0;
15465
15466     /*
15467      * Clear HW from errors which may have resulted from an interrupted
15468      * DMAE transaction.
15469      */
15470     bxe_prev_interrupted_dmae(sc);
15471
15472     /* Release previously held locks */
15473     hw_lock_reg =
15474         (SC_FUNC(sc) <= 5) ?
15475             (MISC_REG_DRIVER_CONTROL_1 + SC_FUNC(sc) * 8) :
15476             (MISC_REG_DRIVER_CONTROL_7 + (SC_FUNC(sc) - 6) * 8);
15477
15478     hw_lock_val = (REG_RD(sc, hw_lock_reg));
15479     if (hw_lock_val) {
15480         if (hw_lock_val & HW_LOCK_RESOURCE_NVRAM) {
15481             BLOGD(sc, DBG_LOAD, "Releasing previously held NVRAM lock\n");
15482             REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
15483                    (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << SC_PORT(sc)));
15484         }
15485         BLOGD(sc, DBG_LOAD, "Releasing previously held HW lock\n");
15486         REG_WR(sc, hw_lock_reg, 0xffffffff);
15487     } else {
15488         BLOGD(sc, DBG_LOAD, "No need to release HW/NVRAM locks\n");
15489     }
15490
15491     if (MCPR_ACCESS_LOCK_LOCK & REG_RD(sc, MCP_REG_MCPR_ACCESS_LOCK)) {
15492         BLOGD(sc, DBG_LOAD, "Releasing previously held ALR\n");
15493         REG_WR(sc, MCP_REG_MCPR_ACCESS_LOCK, 0);
15494     }
15495
15496     do {
15497         /* Lock MCP using an unload request */
15498         fw = bxe_fw_command(sc, DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS, 0);
15499         if (!fw) {
15500             BLOGE(sc, "MCP response failure, aborting\n");
15501             rc = -1;
15502             break;
15503         }
15504
15505         if (fw == FW_MSG_CODE_DRV_UNLOAD_COMMON) {
15506             rc = bxe_prev_unload_common(sc);
15507             break;
15508         }
15509
15510         /* non-common reply from MCP night require looping */
15511         rc = bxe_prev_unload_uncommon(sc);
15512         if (rc != BXE_PREV_WAIT_NEEDED) {
15513             break;
15514         }
15515
15516         DELAY(20000);
15517     } while (--time_counter);
15518
15519     if (!time_counter || rc) {
15520         BLOGE(sc, "Failed to unload previous driver!"
15521             " time_counter %d rc %d\n", time_counter, rc);
15522         rc = -1;
15523     }
15524
15525     return (rc);
15526 }
15527
15528 void
15529 bxe_dcbx_set_state(struct bxe_softc *sc,
15530                    uint8_t          dcb_on,
15531                    uint32_t         dcbx_enabled)
15532 {
15533     if (!CHIP_IS_E1x(sc)) {
15534         sc->dcb_state = dcb_on;
15535         sc->dcbx_enabled = dcbx_enabled;
15536     } else {
15537         sc->dcb_state = FALSE;
15538         sc->dcbx_enabled = BXE_DCBX_ENABLED_INVALID;
15539     }
15540     BLOGD(sc, DBG_LOAD,
15541           "DCB state [%s:%s]\n",
15542           dcb_on ? "ON" : "OFF",
15543           (dcbx_enabled == BXE_DCBX_ENABLED_OFF) ? "user-mode" :
15544           (dcbx_enabled == BXE_DCBX_ENABLED_ON_NEG_OFF) ? "on-chip static" :
15545           (dcbx_enabled == BXE_DCBX_ENABLED_ON_NEG_ON) ?
15546           "on-chip with negotiation" : "invalid");
15547 }
15548
15549 /* must be called after sriov-enable */
15550 static int
15551 bxe_set_qm_cid_count(struct bxe_softc *sc)
15552 {
15553     int cid_count = BXE_L2_MAX_CID(sc);
15554
15555     if (IS_SRIOV(sc)) {
15556         cid_count += BXE_VF_CIDS;
15557     }
15558
15559     if (CNIC_SUPPORT(sc)) {
15560         cid_count += CNIC_CID_MAX;
15561     }
15562
15563     return (roundup(cid_count, QM_CID_ROUND));
15564 }
15565
15566 static void
15567 bxe_init_multi_cos(struct bxe_softc *sc)
15568 {
15569     int pri, cos;
15570
15571     uint32_t pri_map = 0; /* XXX change to user config */
15572
15573     for (pri = 0; pri < BXE_MAX_PRIORITY; pri++) {
15574         cos = ((pri_map & (0xf << (pri * 4))) >> (pri * 4));
15575         if (cos < sc->max_cos) {
15576             sc->prio_to_cos[pri] = cos;
15577         } else {
15578             BLOGW(sc, "Invalid COS %d for priority %d "
15579                       "(max COS is %d), setting to 0\n",
15580                   cos, pri, (sc->max_cos - 1));
15581             sc->prio_to_cos[pri] = 0;
15582         }
15583     }
15584 }
15585
15586 static int
15587 bxe_sysctl_state(SYSCTL_HANDLER_ARGS)
15588 {
15589     struct bxe_softc *sc;
15590     int error, result;
15591
15592     result = 0;
15593     error = sysctl_handle_int(oidp, &result, 0, req);
15594
15595     if (error || !req->newptr) {
15596         return (error);
15597     }
15598
15599     if (result == 1) {
15600         uint32_t  temp;
15601         sc = (struct bxe_softc *)arg1;
15602
15603         BLOGI(sc, "... dumping driver state ...\n");
15604         temp = SHMEM2_RD(sc, temperature_in_half_celsius);
15605         BLOGI(sc, "\t Device Temperature = %d Celsius\n", (temp/2));
15606     }
15607
15608     return (error);
15609 }
15610
15611 static int
15612 bxe_sysctl_trigger_grcdump(SYSCTL_HANDLER_ARGS)
15613 {
15614     struct bxe_softc *sc;
15615     int error, result;
15616
15617     result = 0;
15618     error = sysctl_handle_int(oidp, &result, 0, req);
15619
15620     if (error || !req->newptr) {
15621         return (error);
15622     }
15623
15624     if (result == 1) {
15625         sc = (struct bxe_softc *)arg1;
15626
15627         BLOGI(sc, "... grcdump start ...\n");
15628         bxe_grc_dump(sc);
15629         BLOGI(sc, "... grcdump done ...\n");
15630     }
15631
15632     return (error);
15633 }
15634
15635 static int
15636 bxe_sysctl_eth_stat(SYSCTL_HANDLER_ARGS)
15637 {
15638     struct bxe_softc *sc = (struct bxe_softc *)arg1;
15639     uint32_t *eth_stats = (uint32_t *)&sc->eth_stats;
15640     uint32_t *offset;
15641     uint64_t value = 0;
15642     int index = (int)arg2;
15643
15644     if (index >= BXE_NUM_ETH_STATS) {
15645         BLOGE(sc, "bxe_eth_stats index out of range (%d)\n", index);
15646         return (-1);
15647     }
15648
15649     offset = (eth_stats + bxe_eth_stats_arr[index].offset);
15650
15651     switch (bxe_eth_stats_arr[index].size) {
15652     case 4:
15653         value = (uint64_t)*offset;
15654         break;
15655     case 8:
15656         value = HILO_U64(*offset, *(offset + 1));
15657         break;
15658     default:
15659         BLOGE(sc, "Invalid bxe_eth_stats size (index=%d size=%d)\n",
15660               index, bxe_eth_stats_arr[index].size);
15661         return (-1);
15662     }
15663
15664     return (sysctl_handle_64(oidp, &value, 0, req));
15665 }
15666
15667 static int
15668 bxe_sysctl_eth_q_stat(SYSCTL_HANDLER_ARGS)
15669 {
15670     struct bxe_softc *sc = (struct bxe_softc *)arg1;
15671     uint32_t *eth_stats;
15672     uint32_t *offset;
15673     uint64_t value = 0;
15674     uint32_t q_stat = (uint32_t)arg2;
15675     uint32_t fp_index = ((q_stat >> 16) & 0xffff);
15676     uint32_t index = (q_stat & 0xffff);
15677
15678     eth_stats = (uint32_t *)&sc->fp[fp_index].eth_q_stats;
15679
15680     if (index >= BXE_NUM_ETH_Q_STATS) {
15681         BLOGE(sc, "bxe_eth_q_stats index out of range (%d)\n", index);
15682         return (-1);
15683     }
15684
15685     offset = (eth_stats + bxe_eth_q_stats_arr[index].offset);
15686
15687     switch (bxe_eth_q_stats_arr[index].size) {
15688     case 4:
15689         value = (uint64_t)*offset;
15690         break;
15691     case 8:
15692         value = HILO_U64(*offset, *(offset + 1));
15693         break;
15694     default:
15695         BLOGE(sc, "Invalid bxe_eth_q_stats size (index=%d size=%d)\n",
15696               index, bxe_eth_q_stats_arr[index].size);
15697         return (-1);
15698     }
15699
15700     return (sysctl_handle_64(oidp, &value, 0, req));
15701 }
15702
15703 static void
15704 bxe_add_sysctls(struct bxe_softc *sc)
15705 {
15706     struct sysctl_ctx_list *ctx;
15707     struct sysctl_oid_list *children;
15708     struct sysctl_oid *queue_top, *queue;
15709     struct sysctl_oid_list *queue_top_children, *queue_children;
15710     char queue_num_buf[32];
15711     uint32_t q_stat;
15712     int i, j;
15713
15714     ctx = device_get_sysctl_ctx(sc->dev);
15715     children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
15716
15717     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "version",
15718                       CTLFLAG_RD, BXE_DRIVER_VERSION, 0,
15719                       "version");
15720
15721     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "bc_version",
15722                       CTLFLAG_RD, &sc->devinfo.bc_ver_str, 0,
15723                       "bootcode version");
15724
15725     snprintf(sc->fw_ver_str, sizeof(sc->fw_ver_str), "%d.%d.%d.%d",
15726              BCM_5710_FW_MAJOR_VERSION,
15727              BCM_5710_FW_MINOR_VERSION,
15728              BCM_5710_FW_REVISION_VERSION,
15729              BCM_5710_FW_ENGINEERING_VERSION);
15730     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "fw_version",
15731                       CTLFLAG_RD, &sc->fw_ver_str, 0,
15732                       "firmware version");
15733
15734     snprintf(sc->mf_mode_str, sizeof(sc->mf_mode_str), "%s",
15735         ((sc->devinfo.mf_info.mf_mode == SINGLE_FUNCTION)     ? "Single"  :
15736          (sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_SD)   ? "MF-SD"   :
15737          (sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_SI)   ? "MF-SI"   :
15738          (sc->devinfo.mf_info.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" :
15739                                                                 "Unknown"));
15740     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mf_mode",
15741                       CTLFLAG_RD, &sc->mf_mode_str, 0,
15742                       "multifunction mode");
15743
15744     SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "mf_vnics",
15745                     CTLFLAG_RD, &sc->devinfo.mf_info.vnics_per_port, 0,
15746                     "multifunction vnics per port");
15747
15748     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "mac_addr",
15749                       CTLFLAG_RD, &sc->mac_addr_str, 0,
15750                       "mac address");
15751
15752     snprintf(sc->pci_link_str, sizeof(sc->pci_link_str), "%s x%d",
15753         ((sc->devinfo.pcie_link_speed == 1) ? "2.5GT/s" :
15754          (sc->devinfo.pcie_link_speed == 2) ? "5.0GT/s" :
15755          (sc->devinfo.pcie_link_speed == 4) ? "8.0GT/s" :
15756                                               "???GT/s"),
15757         sc->devinfo.pcie_link_width);
15758     SYSCTL_ADD_STRING(ctx, children, OID_AUTO, "pci_link",
15759                       CTLFLAG_RD, &sc->pci_link_str, 0,
15760                       "pci link status");
15761
15762     sc->debug = bxe_debug;
15763     SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "debug",
15764                     CTLFLAG_RW, &sc->debug, 0,
15765                     "debug logging mode");
15766
15767     SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "trigger_grcdump",
15768                     CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
15769                     bxe_sysctl_trigger_grcdump, "IU",
15770                     "set by driver when a grcdump is needed");
15771
15772     sc->grcdump_done = 0;
15773     SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "grcdump_done",
15774                    CTLFLAG_RW, &sc->grcdump_done, 0,
15775                    "set by driver when grcdump is done");
15776
15777     sc->rx_budget = bxe_rx_budget;
15778     SYSCTL_ADD_UINT(ctx, children, OID_AUTO, "rx_budget",
15779                     CTLFLAG_RW, &sc->rx_budget, 0,
15780                     "rx processing budget");
15781
15782     SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "state",
15783                     CTLTYPE_UINT | CTLFLAG_RW, sc, 0,
15784                     bxe_sysctl_state, "IU", "dump driver state");
15785
15786     for (i = 0; i < BXE_NUM_ETH_STATS; i++) {
15787         SYSCTL_ADD_PROC(ctx, children, OID_AUTO,
15788                         bxe_eth_stats_arr[i].string,
15789                         CTLTYPE_U64 | CTLFLAG_RD, sc, i,
15790                         bxe_sysctl_eth_stat, "LU",
15791                         bxe_eth_stats_arr[i].string);
15792     }
15793
15794     /* add a new parent node for all queues "dev.bxe.#.queue" */
15795     queue_top = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "queue",
15796                                 CTLFLAG_RD, NULL, "queue");
15797     queue_top_children = SYSCTL_CHILDREN(queue_top);
15798
15799     for (i = 0; i < sc->num_queues; i++) {
15800         /* add a new parent node for a single queue "dev.bxe.#.queue.#" */
15801         snprintf(queue_num_buf, sizeof(queue_num_buf), "%d", i);
15802         queue = SYSCTL_ADD_NODE(ctx, queue_top_children, OID_AUTO,
15803                                 queue_num_buf, CTLFLAG_RD, NULL,
15804                                 "single queue");
15805         queue_children = SYSCTL_CHILDREN(queue);
15806
15807         for (j = 0; j < BXE_NUM_ETH_Q_STATS; j++) {
15808             q_stat = ((i << 16) | j);
15809             SYSCTL_ADD_PROC(ctx, queue_children, OID_AUTO,
15810                             bxe_eth_q_stats_arr[j].string,
15811                             CTLTYPE_U64 | CTLFLAG_RD, sc, q_stat,
15812                             bxe_sysctl_eth_q_stat, "LU",
15813                             bxe_eth_q_stats_arr[j].string);
15814         }
15815     }
15816 }
15817
15818 static int
15819 bxe_alloc_buf_rings(struct bxe_softc *sc)
15820 {
15821 #if __FreeBSD_version >= 800000
15822
15823     int i;
15824     struct bxe_fastpath *fp;
15825
15826     for (i = 0; i < sc->num_queues; i++) {
15827
15828         fp = &sc->fp[i];
15829
15830         fp->tx_br = buf_ring_alloc(BXE_BR_SIZE, M_DEVBUF,
15831                                    M_NOWAIT, &fp->tx_mtx);
15832         if (fp->tx_br == NULL)
15833             return (-1);
15834     }
15835 #endif
15836     return (0);
15837 }
15838
15839 static void
15840 bxe_free_buf_rings(struct bxe_softc *sc)
15841 {
15842 #if __FreeBSD_version >= 800000
15843
15844     int i;
15845     struct bxe_fastpath *fp;
15846
15847     for (i = 0; i < sc->num_queues; i++) {
15848
15849         fp = &sc->fp[i];
15850
15851         if (fp->tx_br) {
15852             buf_ring_free(fp->tx_br, M_DEVBUF);
15853             fp->tx_br = NULL;
15854         }
15855     }
15856
15857 #endif
15858 }
15859
15860 static void
15861 bxe_init_fp_mutexs(struct bxe_softc *sc)
15862 {
15863     int i;
15864     struct bxe_fastpath *fp;
15865
15866     for (i = 0; i < sc->num_queues; i++) {
15867
15868         fp = &sc->fp[i];
15869
15870         snprintf(fp->tx_mtx_name, sizeof(fp->tx_mtx_name),
15871             "bxe%d_fp%d_tx_lock", sc->unit, i);
15872         mtx_init(&fp->tx_mtx, fp->tx_mtx_name, NULL, MTX_DEF);
15873
15874         snprintf(fp->rx_mtx_name, sizeof(fp->rx_mtx_name),
15875             "bxe%d_fp%d_rx_lock", sc->unit, i);
15876         mtx_init(&fp->rx_mtx, fp->rx_mtx_name, NULL, MTX_DEF);
15877     }
15878 }
15879
15880 static void
15881 bxe_destroy_fp_mutexs(struct bxe_softc *sc)
15882 {
15883     int i;
15884     struct bxe_fastpath *fp;
15885
15886     for (i = 0; i < sc->num_queues; i++) {
15887
15888         fp = &sc->fp[i];
15889
15890         if (mtx_initialized(&fp->tx_mtx)) {
15891             mtx_destroy(&fp->tx_mtx);
15892         }
15893
15894         if (mtx_initialized(&fp->rx_mtx)) {
15895             mtx_destroy(&fp->rx_mtx);
15896         }
15897     }
15898 }
15899
15900
15901 /*
15902  * Device attach function.
15903  *
15904  * Allocates device resources, performs secondary chip identification, and
15905  * initializes driver instance variables. This function is called from driver
15906  * load after a successful probe.
15907  *
15908  * Returns:
15909  *   0 = Success, >0 = Failure
15910  */
15911 static int
15912 bxe_attach(device_t dev)
15913 {
15914     struct bxe_softc *sc;
15915
15916     sc = device_get_softc(dev);
15917
15918     BLOGD(sc, DBG_LOAD, "Starting attach...\n");
15919
15920     sc->state = BXE_STATE_CLOSED;
15921
15922     sc->dev  = dev;
15923     sc->unit = device_get_unit(dev);
15924
15925     BLOGD(sc, DBG_LOAD, "softc = %p\n", sc);
15926
15927     sc->pcie_bus    = pci_get_bus(dev);
15928     sc->pcie_device = pci_get_slot(dev);
15929     sc->pcie_func   = pci_get_function(dev);
15930
15931     /* enable bus master capability */
15932     pci_enable_busmaster(dev);
15933
15934     /* get the BARs */
15935     if (bxe_allocate_bars(sc) != 0) {
15936         return (ENXIO);
15937     }
15938
15939     /* initialize the mutexes */
15940     bxe_init_mutexes(sc);
15941
15942     /* prepare the periodic callout */
15943     callout_init(&sc->periodic_callout, 0);
15944
15945     /* prepare the chip taskqueue */
15946     sc->chip_tq_flags = CHIP_TQ_NONE;
15947     snprintf(sc->chip_tq_name, sizeof(sc->chip_tq_name),
15948              "bxe%d_chip_tq", sc->unit);
15949     TASK_INIT(&sc->chip_tq_task, 0, bxe_handle_chip_tq, sc);
15950     sc->chip_tq = taskqueue_create(sc->chip_tq_name, M_NOWAIT,
15951                                    taskqueue_thread_enqueue,
15952                                    &sc->chip_tq);
15953     taskqueue_start_threads(&sc->chip_tq, 1, PWAIT, /* lower priority */
15954                             "%s", sc->chip_tq_name);
15955
15956     /* get device info and set params */
15957     if (bxe_get_device_info(sc) != 0) {
15958         BLOGE(sc, "getting device info\n");
15959         bxe_deallocate_bars(sc);
15960         pci_disable_busmaster(dev);
15961         return (ENXIO);
15962     }
15963
15964     /* get final misc params */
15965     bxe_get_params(sc);
15966
15967     /* set the default MTU (changed via ifconfig) */
15968     sc->mtu = ETHERMTU;
15969
15970     bxe_set_modes_bitmap(sc);
15971
15972     /* XXX
15973      * If in AFEX mode and the function is configured for FCoE
15974      * then bail... no L2 allowed.
15975      */
15976
15977     /* get phy settings from shmem and 'and' against admin settings */
15978     bxe_get_phy_info(sc);
15979
15980     /* initialize the FreeBSD ifnet interface */
15981     if (bxe_init_ifnet(sc) != 0) {
15982         bxe_release_mutexes(sc);
15983         bxe_deallocate_bars(sc);
15984         pci_disable_busmaster(dev);
15985         return (ENXIO);
15986     }
15987
15988     if (bxe_add_cdev(sc) != 0) {
15989         if (sc->ifnet != NULL) {
15990             ether_ifdetach(sc->ifnet);
15991         }
15992         ifmedia_removeall(&sc->ifmedia);
15993         bxe_release_mutexes(sc);
15994         bxe_deallocate_bars(sc);
15995         pci_disable_busmaster(dev);
15996         return (ENXIO);
15997     }
15998
15999     /* allocate device interrupts */
16000     if (bxe_interrupt_alloc(sc) != 0) {
16001         bxe_del_cdev(sc);
16002         if (sc->ifnet != NULL) {
16003             ether_ifdetach(sc->ifnet);
16004         }
16005         ifmedia_removeall(&sc->ifmedia);
16006         bxe_release_mutexes(sc);
16007         bxe_deallocate_bars(sc);
16008         pci_disable_busmaster(dev);
16009         return (ENXIO);
16010     }
16011
16012     bxe_init_fp_mutexs(sc);
16013
16014     if (bxe_alloc_buf_rings(sc) != 0) {
16015         bxe_free_buf_rings(sc);
16016         bxe_interrupt_free(sc);
16017         bxe_del_cdev(sc);
16018         if (sc->ifnet != NULL) {
16019             ether_ifdetach(sc->ifnet);
16020         }
16021         ifmedia_removeall(&sc->ifmedia);
16022         bxe_release_mutexes(sc);
16023         bxe_deallocate_bars(sc);
16024         pci_disable_busmaster(dev);
16025         return (ENXIO);
16026     }
16027
16028     /* allocate ilt */
16029     if (bxe_alloc_ilt_mem(sc) != 0) {
16030         bxe_free_buf_rings(sc);
16031         bxe_interrupt_free(sc);
16032         bxe_del_cdev(sc);
16033         if (sc->ifnet != NULL) {
16034             ether_ifdetach(sc->ifnet);
16035         }
16036         ifmedia_removeall(&sc->ifmedia);
16037         bxe_release_mutexes(sc);
16038         bxe_deallocate_bars(sc);
16039         pci_disable_busmaster(dev);
16040         return (ENXIO);
16041     }
16042
16043     /* allocate the host hardware/software hsi structures */
16044     if (bxe_alloc_hsi_mem(sc) != 0) {
16045         bxe_free_ilt_mem(sc);
16046         bxe_free_buf_rings(sc);
16047         bxe_interrupt_free(sc);
16048         bxe_del_cdev(sc);
16049         if (sc->ifnet != NULL) {
16050             ether_ifdetach(sc->ifnet);
16051         }
16052         ifmedia_removeall(&sc->ifmedia);
16053         bxe_release_mutexes(sc);
16054         bxe_deallocate_bars(sc);
16055         pci_disable_busmaster(dev);
16056         return (ENXIO);
16057     }
16058
16059     /* need to reset chip if UNDI was active */
16060     if (IS_PF(sc) && !BXE_NOMCP(sc)) {
16061         /* init fw_seq */
16062         sc->fw_seq =
16063             (SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_mb_header) &
16064              DRV_MSG_SEQ_NUMBER_MASK);
16065         BLOGD(sc, DBG_LOAD, "prev unload fw_seq 0x%04x\n", sc->fw_seq);
16066         bxe_prev_unload(sc);
16067     }
16068
16069 #if 1
16070     /* XXX */
16071     bxe_dcbx_set_state(sc, FALSE, BXE_DCBX_ENABLED_OFF);
16072 #else
16073     if (SHMEM2_HAS(sc, dcbx_lldp_params_offset) &&
16074         SHMEM2_HAS(sc, dcbx_lldp_dcbx_stat_offset) &&
16075         SHMEM2_RD(sc, dcbx_lldp_params_offset) &&
16076         SHMEM2_RD(sc, dcbx_lldp_dcbx_stat_offset)) {
16077         bxe_dcbx_set_state(sc, TRUE, BXE_DCBX_ENABLED_ON_NEG_ON);
16078         bxe_dcbx_init_params(sc);
16079     } else {
16080         bxe_dcbx_set_state(sc, FALSE, BXE_DCBX_ENABLED_OFF);
16081     }
16082 #endif
16083
16084     /* calculate qm_cid_count */
16085     sc->qm_cid_count = bxe_set_qm_cid_count(sc);
16086     BLOGD(sc, DBG_LOAD, "qm_cid_count=%d\n", sc->qm_cid_count);
16087
16088     sc->max_cos = 1;
16089     bxe_init_multi_cos(sc);
16090
16091     bxe_add_sysctls(sc);
16092
16093     return (0);
16094 }
16095
16096 /*
16097  * Device detach function.
16098  *
16099  * Stops the controller, resets the controller, and releases resources.
16100  *
16101  * Returns:
16102  *   0 = Success, >0 = Failure
16103  */
16104 static int
16105 bxe_detach(device_t dev)
16106 {
16107     struct bxe_softc *sc;
16108     struct ifnet *ifp;
16109
16110     sc = device_get_softc(dev);
16111
16112     BLOGD(sc, DBG_LOAD, "Starting detach...\n");
16113
16114     ifp = sc->ifnet;
16115     if (ifp != NULL && ifp->if_vlantrunk != NULL) {
16116         BLOGE(sc, "Cannot detach while VLANs are in use.\n");
16117         return(EBUSY);
16118     }
16119
16120     bxe_del_cdev(sc);
16121
16122     /* stop the periodic callout */
16123     bxe_periodic_stop(sc);
16124
16125     /* stop the chip taskqueue */
16126     atomic_store_rel_long(&sc->chip_tq_flags, CHIP_TQ_NONE);
16127     if (sc->chip_tq) {
16128         taskqueue_drain(sc->chip_tq, &sc->chip_tq_task);
16129         taskqueue_free(sc->chip_tq);
16130         sc->chip_tq = NULL;
16131     }
16132
16133     /* stop and reset the controller if it was open */
16134     if (sc->state != BXE_STATE_CLOSED) {
16135         BXE_CORE_LOCK(sc);
16136         bxe_nic_unload(sc, UNLOAD_CLOSE, TRUE);
16137         BXE_CORE_UNLOCK(sc);
16138     }
16139
16140     /* release the network interface */
16141     if (ifp != NULL) {
16142         ether_ifdetach(ifp);
16143     }
16144     ifmedia_removeall(&sc->ifmedia);
16145
16146     /* XXX do the following based on driver state... */
16147
16148     /* free the host hardware/software hsi structures */
16149     bxe_free_hsi_mem(sc);
16150
16151     /* free ilt */
16152     bxe_free_ilt_mem(sc);
16153
16154     bxe_free_buf_rings(sc);
16155
16156     /* release the interrupts */
16157     bxe_interrupt_free(sc);
16158
16159     /* Release the mutexes*/
16160     bxe_destroy_fp_mutexs(sc);
16161     bxe_release_mutexes(sc);
16162
16163
16164     /* Release the PCIe BAR mapped memory */
16165     bxe_deallocate_bars(sc);
16166
16167     /* Release the FreeBSD interface. */
16168     if (sc->ifnet != NULL) {
16169         if_free(sc->ifnet);
16170     }
16171
16172     pci_disable_busmaster(dev);
16173
16174     return (0);
16175 }
16176
16177 /*
16178  * Device shutdown function.
16179  *
16180  * Stops and resets the controller.
16181  *
16182  * Returns:
16183  *   Nothing
16184  */
16185 static int
16186 bxe_shutdown(device_t dev)
16187 {
16188     struct bxe_softc *sc;
16189
16190     sc = device_get_softc(dev);
16191
16192     BLOGD(sc, DBG_LOAD, "Starting shutdown...\n");
16193
16194     /* stop the periodic callout */
16195     bxe_periodic_stop(sc);
16196
16197     BXE_CORE_LOCK(sc);
16198     bxe_nic_unload(sc, UNLOAD_NORMAL, FALSE);
16199     BXE_CORE_UNLOCK(sc);
16200
16201     return (0);
16202 }
16203
16204 void
16205 bxe_igu_ack_sb(struct bxe_softc *sc,
16206                uint8_t          igu_sb_id,
16207                uint8_t          segment,
16208                uint16_t         index,
16209                uint8_t          op,
16210                uint8_t          update)
16211 {
16212     uint32_t igu_addr = sc->igu_base_addr;
16213     igu_addr += (IGU_CMD_INT_ACK_BASE + igu_sb_id)*8;
16214     bxe_igu_ack_sb_gen(sc, igu_sb_id, segment, index, op, update, igu_addr);
16215 }
16216
16217 static void
16218 bxe_igu_clear_sb_gen(struct bxe_softc *sc,
16219                      uint8_t          func,
16220                      uint8_t          idu_sb_id,
16221                      uint8_t          is_pf)
16222 {
16223     uint32_t data, ctl, cnt = 100;
16224     uint32_t igu_addr_data = IGU_REG_COMMAND_REG_32LSB_DATA;
16225     uint32_t igu_addr_ctl = IGU_REG_COMMAND_REG_CTRL;
16226     uint32_t igu_addr_ack = IGU_REG_CSTORM_TYPE_0_SB_CLEANUP + (idu_sb_id/32)*4;
16227     uint32_t sb_bit =  1 << (idu_sb_id%32);
16228     uint32_t func_encode = func | (is_pf ? 1 : 0) << IGU_FID_ENCODE_IS_PF_SHIFT;
16229     uint32_t addr_encode = IGU_CMD_E2_PROD_UPD_BASE + idu_sb_id;
16230
16231     /* Not supported in BC mode */
16232     if (CHIP_INT_MODE_IS_BC(sc)) {
16233         return;
16234     }
16235
16236     data = ((IGU_USE_REGISTER_cstorm_type_0_sb_cleanup <<
16237              IGU_REGULAR_CLEANUP_TYPE_SHIFT) |
16238             IGU_REGULAR_CLEANUP_SET |
16239             IGU_REGULAR_BCLEANUP);
16240
16241     ctl = ((addr_encode << IGU_CTRL_REG_ADDRESS_SHIFT) |
16242            (func_encode << IGU_CTRL_REG_FID_SHIFT) |
16243            (IGU_CTRL_CMD_TYPE_WR << IGU_CTRL_REG_TYPE_SHIFT));
16244
16245     BLOGD(sc, DBG_LOAD, "write 0x%08x to IGU(via GRC) addr 0x%x\n",
16246             data, igu_addr_data);
16247     REG_WR(sc, igu_addr_data, data);
16248
16249     bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
16250                       BUS_SPACE_BARRIER_WRITE);
16251     mb();
16252
16253     BLOGD(sc, DBG_LOAD, "write 0x%08x to IGU(via GRC) addr 0x%x\n",
16254             ctl, igu_addr_ctl);
16255     REG_WR(sc, igu_addr_ctl, ctl);
16256
16257     bus_space_barrier(sc->bar[BAR0].tag, sc->bar[BAR0].handle, 0, 0,
16258                       BUS_SPACE_BARRIER_WRITE);
16259     mb();
16260
16261     /* wait for clean up to finish */
16262     while (!(REG_RD(sc, igu_addr_ack) & sb_bit) && --cnt) {
16263         DELAY(20000);
16264     }
16265
16266     if (!(REG_RD(sc, igu_addr_ack) & sb_bit)) {
16267         BLOGD(sc, DBG_LOAD,
16268               "Unable to finish IGU cleanup: "
16269               "idu_sb_id %d offset %d bit %d (cnt %d)\n",
16270               idu_sb_id, idu_sb_id/32, idu_sb_id%32, cnt);
16271     }
16272 }
16273
16274 static void
16275 bxe_igu_clear_sb(struct bxe_softc *sc,
16276                  uint8_t          idu_sb_id)
16277 {
16278     bxe_igu_clear_sb_gen(sc, SC_FUNC(sc), idu_sb_id, TRUE /*PF*/);
16279 }
16280
16281
16282
16283
16284
16285
16286
16287 /*******************/
16288 /* ECORE CALLBACKS */
16289 /*******************/
16290
16291 static void
16292 bxe_reset_common(struct bxe_softc *sc)
16293 {
16294     uint32_t val = 0x1400;
16295
16296     /* reset_common */
16297     REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR), 0xd3ffff7f);
16298
16299     if (CHIP_IS_E3(sc)) {
16300         val |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
16301         val |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
16302     }
16303
16304     REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR), val);
16305 }
16306
16307 static void
16308 bxe_common_init_phy(struct bxe_softc *sc)
16309 {
16310     uint32_t shmem_base[2];
16311     uint32_t shmem2_base[2];
16312
16313     /* Avoid common init in case MFW supports LFA */
16314     if (SHMEM2_RD(sc, size) >
16315         (uint32_t)offsetof(struct shmem2_region,
16316                            lfa_host_addr[SC_PORT(sc)])) {
16317         return;
16318     }
16319
16320     shmem_base[0]  = sc->devinfo.shmem_base;
16321     shmem2_base[0] = sc->devinfo.shmem2_base;
16322
16323     if (!CHIP_IS_E1x(sc)) {
16324         shmem_base[1]  = SHMEM2_RD(sc, other_shmem_base_addr);
16325         shmem2_base[1] = SHMEM2_RD(sc, other_shmem2_base_addr);
16326     }
16327
16328     bxe_acquire_phy_lock(sc);
16329     elink_common_init_phy(sc, shmem_base, shmem2_base,
16330                           sc->devinfo.chip_id, 0);
16331     bxe_release_phy_lock(sc);
16332 }
16333
16334 static void
16335 bxe_pf_disable(struct bxe_softc *sc)
16336 {
16337     uint32_t val = REG_RD(sc, IGU_REG_PF_CONFIGURATION);
16338
16339     val &= ~IGU_PF_CONF_FUNC_EN;
16340
16341     REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
16342     REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
16343     REG_WR(sc, CFC_REG_WEAK_ENABLE_PF, 0);
16344 }
16345
16346 static void
16347 bxe_init_pxp(struct bxe_softc *sc)
16348 {
16349     uint16_t devctl;
16350     int r_order, w_order;
16351
16352     devctl = bxe_pcie_capability_read(sc, PCIR_EXPRESS_DEVICE_CTL, 2);
16353
16354     BLOGD(sc, DBG_LOAD, "read 0x%08x from devctl\n", devctl);
16355
16356     w_order = ((devctl & PCIM_EXP_CTL_MAX_PAYLOAD) >> 5);
16357
16358     if (sc->mrrs == -1) {
16359         r_order = ((devctl & PCIM_EXP_CTL_MAX_READ_REQUEST) >> 12);
16360     } else {
16361         BLOGD(sc, DBG_LOAD, "forcing read order to %d\n", sc->mrrs);
16362         r_order = sc->mrrs;
16363     }
16364
16365     ecore_init_pxp_arb(sc, r_order, w_order);
16366 }
16367
16368 static uint32_t
16369 bxe_get_pretend_reg(struct bxe_softc *sc)
16370 {
16371     uint32_t base = PXP2_REG_PGL_PRETEND_FUNC_F0;
16372     uint32_t stride = (PXP2_REG_PGL_PRETEND_FUNC_F1 - base);
16373     return (base + (SC_ABS_FUNC(sc)) * stride);
16374 }
16375
16376 /*
16377  * Called only on E1H or E2.
16378  * When pretending to be PF, the pretend value is the function number 0..7.
16379  * When pretending to be VF, the pretend val is the PF-num:VF-valid:ABS-VFID
16380  * combination.
16381  */
16382 static int
16383 bxe_pretend_func(struct bxe_softc *sc,
16384                  uint16_t         pretend_func_val)
16385 {
16386     uint32_t pretend_reg;
16387
16388     if (CHIP_IS_E1H(sc) && (pretend_func_val > E1H_FUNC_MAX)) {
16389         return (-1);
16390     }
16391
16392     /* get my own pretend register */
16393     pretend_reg = bxe_get_pretend_reg(sc);
16394     REG_WR(sc, pretend_reg, pretend_func_val);
16395     REG_RD(sc, pretend_reg);
16396     return (0);
16397 }
16398
16399 static void
16400 bxe_iov_init_dmae(struct bxe_softc *sc)
16401 {
16402     return;
16403 }
16404
16405 static void
16406 bxe_iov_init_dq(struct bxe_softc *sc)
16407 {
16408     return;
16409 }
16410
16411 /* send a NIG loopback debug packet */
16412 static void
16413 bxe_lb_pckt(struct bxe_softc *sc)
16414 {
16415     uint32_t wb_write[3];
16416
16417     /* Ethernet source and destination addresses */
16418     wb_write[0] = 0x55555555;
16419     wb_write[1] = 0x55555555;
16420     wb_write[2] = 0x20;     /* SOP */
16421     REG_WR_DMAE(sc, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
16422
16423     /* NON-IP protocol */
16424     wb_write[0] = 0x09000000;
16425     wb_write[1] = 0x55555555;
16426     wb_write[2] = 0x10;     /* EOP, eop_bvalid = 0 */
16427     REG_WR_DMAE(sc, NIG_REG_DEBUG_PACKET_LB, wb_write, 3);
16428 }
16429
16430 /*
16431  * Some of the internal memories are not directly readable from the driver.
16432  * To test them we send debug packets.
16433  */
16434 static int
16435 bxe_int_mem_test(struct bxe_softc *sc)
16436 {
16437     int factor;
16438     int count, i;
16439     uint32_t val = 0;
16440
16441     if (CHIP_REV_IS_FPGA(sc)) {
16442         factor = 120;
16443     } else if (CHIP_REV_IS_EMUL(sc)) {
16444         factor = 200;
16445     } else {
16446         factor = 1;
16447     }
16448
16449     /* disable inputs of parser neighbor blocks */
16450     REG_WR(sc, TSDM_REG_ENABLE_IN1, 0x0);
16451     REG_WR(sc, TCM_REG_PRS_IFEN, 0x0);
16452     REG_WR(sc, CFC_REG_DEBUG0, 0x1);
16453     REG_WR(sc, NIG_REG_PRS_REQ_IN_EN, 0x0);
16454
16455     /*  write 0 to parser credits for CFC search request */
16456     REG_WR(sc, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
16457
16458     /* send Ethernet packet */
16459     bxe_lb_pckt(sc);
16460
16461     /* TODO do i reset NIG statistic? */
16462     /* Wait until NIG register shows 1 packet of size 0x10 */
16463     count = 1000 * factor;
16464     while (count) {
16465         bxe_read_dmae(sc, NIG_REG_STAT2_BRB_OCTET, 2);
16466         val = *BXE_SP(sc, wb_data[0]);
16467         if (val == 0x10) {
16468             break;
16469         }
16470
16471         DELAY(10000);
16472         count--;
16473     }
16474
16475     if (val != 0x10) {
16476         BLOGE(sc, "NIG timeout val=0x%x\n", val);
16477         return (-1);
16478     }
16479
16480     /* wait until PRS register shows 1 packet */
16481     count = (1000 * factor);
16482     while (count) {
16483         val = REG_RD(sc, PRS_REG_NUM_OF_PACKETS);
16484         if (val == 1) {
16485             break;
16486         }
16487
16488         DELAY(10000);
16489         count--;
16490     }
16491
16492     if (val != 0x1) {
16493         BLOGE(sc, "PRS timeout val=0x%x\n", val);
16494         return (-2);
16495     }
16496
16497     /* Reset and init BRB, PRS */
16498     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
16499     DELAY(50000);
16500     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
16501     DELAY(50000);
16502     ecore_init_block(sc, BLOCK_BRB1, PHASE_COMMON);
16503     ecore_init_block(sc, BLOCK_PRS, PHASE_COMMON);
16504
16505     /* Disable inputs of parser neighbor blocks */
16506     REG_WR(sc, TSDM_REG_ENABLE_IN1, 0x0);
16507     REG_WR(sc, TCM_REG_PRS_IFEN, 0x0);
16508     REG_WR(sc, CFC_REG_DEBUG0, 0x1);
16509     REG_WR(sc, NIG_REG_PRS_REQ_IN_EN, 0x0);
16510
16511     /* Write 0 to parser credits for CFC search request */
16512     REG_WR(sc, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x0);
16513
16514     /* send 10 Ethernet packets */
16515     for (i = 0; i < 10; i++) {
16516         bxe_lb_pckt(sc);
16517     }
16518
16519     /* Wait until NIG register shows 10+1 packets of size 11*0x10 = 0xb0 */
16520     count = (1000 * factor);
16521     while (count) {
16522         bxe_read_dmae(sc, NIG_REG_STAT2_BRB_OCTET, 2);
16523         val = *BXE_SP(sc, wb_data[0]);
16524         if (val == 0xb0) {
16525             break;
16526         }
16527
16528         DELAY(10000);
16529         count--;
16530     }
16531
16532     if (val != 0xb0) {
16533         BLOGE(sc, "NIG timeout val=0x%x\n", val);
16534         return (-3);
16535     }
16536
16537     /* Wait until PRS register shows 2 packets */
16538     val = REG_RD(sc, PRS_REG_NUM_OF_PACKETS);
16539     if (val != 2) {
16540         BLOGE(sc, "PRS timeout val=0x%x\n", val);
16541     }
16542
16543     /* Write 1 to parser credits for CFC search request */
16544     REG_WR(sc, PRS_REG_CFC_SEARCH_INITIAL_CREDIT, 0x1);
16545
16546     /* Wait until PRS register shows 3 packets */
16547     DELAY(10000 * factor);
16548
16549     /* Wait until NIG register shows 1 packet of size 0x10 */
16550     val = REG_RD(sc, PRS_REG_NUM_OF_PACKETS);
16551     if (val != 3) {
16552         BLOGE(sc, "PRS timeout val=0x%x\n", val);
16553     }
16554
16555     /* clear NIG EOP FIFO */
16556     for (i = 0; i < 11; i++) {
16557         REG_RD(sc, NIG_REG_INGRESS_EOP_LB_FIFO);
16558     }
16559
16560     val = REG_RD(sc, NIG_REG_INGRESS_EOP_LB_EMPTY);
16561     if (val != 1) {
16562         BLOGE(sc, "clear of NIG failed val=0x%x\n", val);
16563         return (-4);
16564     }
16565
16566     /* Reset and init BRB, PRS, NIG */
16567     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR, 0x03);
16568     DELAY(50000);
16569     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0x03);
16570     DELAY(50000);
16571     ecore_init_block(sc, BLOCK_BRB1, PHASE_COMMON);
16572     ecore_init_block(sc, BLOCK_PRS, PHASE_COMMON);
16573     if (!CNIC_SUPPORT(sc)) {
16574         /* set NIC mode */
16575         REG_WR(sc, PRS_REG_NIC_MODE, 1);
16576     }
16577
16578     /* Enable inputs of parser neighbor blocks */
16579     REG_WR(sc, TSDM_REG_ENABLE_IN1, 0x7fffffff);
16580     REG_WR(sc, TCM_REG_PRS_IFEN, 0x1);
16581     REG_WR(sc, CFC_REG_DEBUG0, 0x0);
16582     REG_WR(sc, NIG_REG_PRS_REQ_IN_EN, 0x1);
16583
16584     return (0);
16585 }
16586
16587 static void
16588 bxe_setup_fan_failure_detection(struct bxe_softc *sc)
16589 {
16590     int is_required;
16591     uint32_t val;
16592     int port;
16593
16594     is_required = 0;
16595     val = (SHMEM_RD(sc, dev_info.shared_hw_config.config2) &
16596            SHARED_HW_CFG_FAN_FAILURE_MASK);
16597
16598     if (val == SHARED_HW_CFG_FAN_FAILURE_ENABLED) {
16599         is_required = 1;
16600     }
16601     /*
16602      * The fan failure mechanism is usually related to the PHY type since
16603      * the power consumption of the board is affected by the PHY. Currently,
16604      * fan is required for most designs with SFX7101, BCM8727 and BCM8481.
16605      */
16606     else if (val == SHARED_HW_CFG_FAN_FAILURE_PHY_TYPE) {
16607         for (port = PORT_0; port < PORT_MAX; port++) {
16608             is_required |= elink_fan_failure_det_req(sc,
16609                                                      sc->devinfo.shmem_base,
16610                                                      sc->devinfo.shmem2_base,
16611                                                      port);
16612         }
16613     }
16614
16615     BLOGD(sc, DBG_LOAD, "fan detection setting: %d\n", is_required);
16616
16617     if (is_required == 0) {
16618         return;
16619     }
16620
16621     /* Fan failure is indicated by SPIO 5 */
16622     bxe_set_spio(sc, MISC_SPIO_SPIO5, MISC_SPIO_INPUT_HI_Z);
16623
16624     /* set to active low mode */
16625     val = REG_RD(sc, MISC_REG_SPIO_INT);
16626     val |= (MISC_SPIO_SPIO5 << MISC_SPIO_INT_OLD_SET_POS);
16627     REG_WR(sc, MISC_REG_SPIO_INT, val);
16628
16629     /* enable interrupt to signal the IGU */
16630     val = REG_RD(sc, MISC_REG_SPIO_EVENT_EN);
16631     val |= MISC_SPIO_SPIO5;
16632     REG_WR(sc, MISC_REG_SPIO_EVENT_EN, val);
16633 }
16634
16635 static void
16636 bxe_enable_blocks_attention(struct bxe_softc *sc)
16637 {
16638     uint32_t val;
16639
16640     REG_WR(sc, PXP_REG_PXP_INT_MASK_0, 0);
16641     if (!CHIP_IS_E1x(sc)) {
16642         REG_WR(sc, PXP_REG_PXP_INT_MASK_1, 0x40);
16643     } else {
16644         REG_WR(sc, PXP_REG_PXP_INT_MASK_1, 0);
16645     }
16646     REG_WR(sc, DORQ_REG_DORQ_INT_MASK, 0);
16647     REG_WR(sc, CFC_REG_CFC_INT_MASK, 0);
16648     /*
16649      * mask read length error interrupts in brb for parser
16650      * (parsing unit and 'checksum and crc' unit)
16651      * these errors are legal (PU reads fixed length and CAC can cause
16652      * read length error on truncated packets)
16653      */
16654     REG_WR(sc, BRB1_REG_BRB1_INT_MASK, 0xFC00);
16655     REG_WR(sc, QM_REG_QM_INT_MASK, 0);
16656     REG_WR(sc, TM_REG_TM_INT_MASK, 0);
16657     REG_WR(sc, XSDM_REG_XSDM_INT_MASK_0, 0);
16658     REG_WR(sc, XSDM_REG_XSDM_INT_MASK_1, 0);
16659     REG_WR(sc, XCM_REG_XCM_INT_MASK, 0);
16660 /*      REG_WR(sc, XSEM_REG_XSEM_INT_MASK_0, 0); */
16661 /*      REG_WR(sc, XSEM_REG_XSEM_INT_MASK_1, 0); */
16662     REG_WR(sc, USDM_REG_USDM_INT_MASK_0, 0);
16663     REG_WR(sc, USDM_REG_USDM_INT_MASK_1, 0);
16664     REG_WR(sc, UCM_REG_UCM_INT_MASK, 0);
16665 /*      REG_WR(sc, USEM_REG_USEM_INT_MASK_0, 0); */
16666 /*      REG_WR(sc, USEM_REG_USEM_INT_MASK_1, 0); */
16667     REG_WR(sc, GRCBASE_UPB + PB_REG_PB_INT_MASK, 0);
16668     REG_WR(sc, CSDM_REG_CSDM_INT_MASK_0, 0);
16669     REG_WR(sc, CSDM_REG_CSDM_INT_MASK_1, 0);
16670     REG_WR(sc, CCM_REG_CCM_INT_MASK, 0);
16671 /*      REG_WR(sc, CSEM_REG_CSEM_INT_MASK_0, 0); */
16672 /*      REG_WR(sc, CSEM_REG_CSEM_INT_MASK_1, 0); */
16673
16674     val = (PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_AFT |
16675            PXP2_PXP2_INT_MASK_0_REG_PGL_CPL_OF |
16676            PXP2_PXP2_INT_MASK_0_REG_PGL_PCIE_ATTN);
16677     if (!CHIP_IS_E1x(sc)) {
16678         val |= (PXP2_PXP2_INT_MASK_0_REG_PGL_READ_BLOCKED |
16679                 PXP2_PXP2_INT_MASK_0_REG_PGL_WRITE_BLOCKED);
16680     }
16681     REG_WR(sc, PXP2_REG_PXP2_INT_MASK_0, val);
16682
16683     REG_WR(sc, TSDM_REG_TSDM_INT_MASK_0, 0);
16684     REG_WR(sc, TSDM_REG_TSDM_INT_MASK_1, 0);
16685     REG_WR(sc, TCM_REG_TCM_INT_MASK, 0);
16686 /*      REG_WR(sc, TSEM_REG_TSEM_INT_MASK_0, 0); */
16687
16688     if (!CHIP_IS_E1x(sc)) {
16689         /* enable VFC attentions: bits 11 and 12, bits 31:13 reserved */
16690         REG_WR(sc, TSEM_REG_TSEM_INT_MASK_1, 0x07ff);
16691     }
16692
16693     REG_WR(sc, CDU_REG_CDU_INT_MASK, 0);
16694     REG_WR(sc, DMAE_REG_DMAE_INT_MASK, 0);
16695 /*      REG_WR(sc, MISC_REG_MISC_INT_MASK, 0); */
16696     REG_WR(sc, PBF_REG_PBF_INT_MASK, 0x18);     /* bit 3,4 masked */
16697 }
16698
16699 /**
16700  * bxe_init_hw_common - initialize the HW at the COMMON phase.
16701  *
16702  * @sc:     driver handle
16703  */
16704 static int
16705 bxe_init_hw_common(struct bxe_softc *sc)
16706 {
16707     uint8_t abs_func_id;
16708     uint32_t val;
16709
16710     BLOGD(sc, DBG_LOAD, "starting common init for func %d\n",
16711           SC_ABS_FUNC(sc));
16712
16713     /*
16714      * take the RESET lock to protect undi_unload flow from accessing
16715      * registers while we are resetting the chip
16716      */
16717     bxe_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
16718
16719     bxe_reset_common(sc);
16720
16721     REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET), 0xffffffff);
16722
16723     val = 0xfffc;
16724     if (CHIP_IS_E3(sc)) {
16725         val |= MISC_REGISTERS_RESET_REG_2_MSTAT0;
16726         val |= MISC_REGISTERS_RESET_REG_2_MSTAT1;
16727     }
16728
16729     REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET), val);
16730
16731     bxe_release_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
16732
16733     ecore_init_block(sc, BLOCK_MISC, PHASE_COMMON);
16734     BLOGD(sc, DBG_LOAD, "after misc block init\n");
16735
16736     if (!CHIP_IS_E1x(sc)) {
16737         /*
16738          * 4-port mode or 2-port mode we need to turn off master-enable for
16739          * everyone. After that we turn it back on for self. So, we disregard
16740          * multi-function, and always disable all functions on the given path,
16741          * this means 0,2,4,6 for path 0 and 1,3,5,7 for path 1
16742          */
16743         for (abs_func_id = SC_PATH(sc);
16744              abs_func_id < (E2_FUNC_MAX * 2);
16745              abs_func_id += 2) {
16746             if (abs_func_id == SC_ABS_FUNC(sc)) {
16747                 REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
16748                 continue;
16749             }
16750
16751             bxe_pretend_func(sc, abs_func_id);
16752
16753             /* clear pf enable */
16754             bxe_pf_disable(sc);
16755
16756             bxe_pretend_func(sc, SC_ABS_FUNC(sc));
16757         }
16758     }
16759
16760     BLOGD(sc, DBG_LOAD, "after pf disable\n");
16761
16762     ecore_init_block(sc, BLOCK_PXP, PHASE_COMMON);
16763
16764     if (CHIP_IS_E1(sc)) {
16765         /*
16766          * enable HW interrupt from PXP on USDM overflow
16767          * bit 16 on INT_MASK_0
16768          */
16769         REG_WR(sc, PXP_REG_PXP_INT_MASK_0, 0);
16770     }
16771
16772     ecore_init_block(sc, BLOCK_PXP2, PHASE_COMMON);
16773     bxe_init_pxp(sc);
16774
16775 #ifdef __BIG_ENDIAN
16776     REG_WR(sc, PXP2_REG_RQ_QM_ENDIAN_M, 1);
16777     REG_WR(sc, PXP2_REG_RQ_TM_ENDIAN_M, 1);
16778     REG_WR(sc, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
16779     REG_WR(sc, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
16780     REG_WR(sc, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
16781     /* make sure this value is 0 */
16782     REG_WR(sc, PXP2_REG_RQ_HC_ENDIAN_M, 0);
16783
16784     //REG_WR(sc, PXP2_REG_RD_PBF_SWAP_MODE, 1);
16785     REG_WR(sc, PXP2_REG_RD_QM_SWAP_MODE, 1);
16786     REG_WR(sc, PXP2_REG_RD_TM_SWAP_MODE, 1);
16787     REG_WR(sc, PXP2_REG_RD_SRC_SWAP_MODE, 1);
16788     REG_WR(sc, PXP2_REG_RD_CDURD_SWAP_MODE, 1);
16789 #endif
16790
16791     ecore_ilt_init_page_size(sc, INITOP_SET);
16792
16793     if (CHIP_REV_IS_FPGA(sc) && CHIP_IS_E1H(sc)) {
16794         REG_WR(sc, PXP2_REG_PGL_TAGS_LIMIT, 0x1);
16795     }
16796
16797     /* let the HW do it's magic... */
16798     DELAY(100000);
16799
16800     /* finish PXP init */
16801     val = REG_RD(sc, PXP2_REG_RQ_CFG_DONE);
16802     if (val != 1) {
16803         BLOGE(sc, "PXP2 CFG failed PXP2_REG_RQ_CFG_DONE val = 0x%x\n",
16804             val);
16805         return (-1);
16806     }
16807     val = REG_RD(sc, PXP2_REG_RD_INIT_DONE);
16808     if (val != 1) {
16809         BLOGE(sc, "PXP2 RD_INIT failed val = 0x%x\n", val);
16810         return (-1);
16811     }
16812
16813     BLOGD(sc, DBG_LOAD, "after pxp init\n");
16814
16815     /*
16816      * Timer bug workaround for E2 only. We need to set the entire ILT to have
16817      * entries with value "0" and valid bit on. This needs to be done by the
16818      * first PF that is loaded in a path (i.e. common phase)
16819      */
16820     if (!CHIP_IS_E1x(sc)) {
16821 /*
16822  * In E2 there is a bug in the timers block that can cause function 6 / 7
16823  * (i.e. vnic3) to start even if it is marked as "scan-off".
16824  * This occurs when a different function (func2,3) is being marked
16825  * as "scan-off". Real-life scenario for example: if a driver is being
16826  * load-unloaded while func6,7 are down. This will cause the timer to access
16827  * the ilt, translate to a logical address and send a request to read/write.
16828  * Since the ilt for the function that is down is not valid, this will cause
16829  * a translation error which is unrecoverable.
16830  * The Workaround is intended to make sure that when this happens nothing
16831  * fatal will occur. The workaround:
16832  *  1.  First PF driver which loads on a path will:
16833  *      a.  After taking the chip out of reset, by using pretend,
16834  *          it will write "0" to the following registers of
16835  *          the other vnics.
16836  *          REG_WR(pdev, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 0);
16837  *          REG_WR(pdev, CFC_REG_WEAK_ENABLE_PF,0);
16838  *          REG_WR(pdev, CFC_REG_STRONG_ENABLE_PF,0);
16839  *          And for itself it will write '1' to
16840  *          PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER to enable
16841  *          dmae-operations (writing to pram for example.)
16842  *          note: can be done for only function 6,7 but cleaner this
16843  *            way.
16844  *      b.  Write zero+valid to the entire ILT.
16845  *      c.  Init the first_timers_ilt_entry, last_timers_ilt_entry of
16846  *          VNIC3 (of that port). The range allocated will be the
16847  *          entire ILT. This is needed to prevent  ILT range error.
16848  *  2.  Any PF driver load flow:
16849  *      a.  ILT update with the physical addresses of the allocated
16850  *          logical pages.
16851  *      b.  Wait 20msec. - note that this timeout is needed to make
16852  *          sure there are no requests in one of the PXP internal
16853  *          queues with "old" ILT addresses.
16854  *      c.  PF enable in the PGLC.
16855  *      d.  Clear the was_error of the PF in the PGLC. (could have
16856  *          occurred while driver was down)
16857  *      e.  PF enable in the CFC (WEAK + STRONG)
16858  *      f.  Timers scan enable
16859  *  3.  PF driver unload flow:
16860  *      a.  Clear the Timers scan_en.
16861  *      b.  Polling for scan_on=0 for that PF.
16862  *      c.  Clear the PF enable bit in the PXP.
16863  *      d.  Clear the PF enable in the CFC (WEAK + STRONG)
16864  *      e.  Write zero+valid to all ILT entries (The valid bit must
16865  *          stay set)
16866  *      f.  If this is VNIC 3 of a port then also init
16867  *          first_timers_ilt_entry to zero and last_timers_ilt_entry
16868  *          to the last enrty in the ILT.
16869  *
16870  *      Notes:
16871  *      Currently the PF error in the PGLC is non recoverable.
16872  *      In the future the there will be a recovery routine for this error.
16873  *      Currently attention is masked.
16874  *      Having an MCP lock on the load/unload process does not guarantee that
16875  *      there is no Timer disable during Func6/7 enable. This is because the
16876  *      Timers scan is currently being cleared by the MCP on FLR.
16877  *      Step 2.d can be done only for PF6/7 and the driver can also check if
16878  *      there is error before clearing it. But the flow above is simpler and
16879  *      more general.
16880  *      All ILT entries are written by zero+valid and not just PF6/7
16881  *      ILT entries since in the future the ILT entries allocation for
16882  *      PF-s might be dynamic.
16883  */
16884         struct ilt_client_info ilt_cli;
16885         struct ecore_ilt ilt;
16886
16887         memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
16888         memset(&ilt, 0, sizeof(struct ecore_ilt));
16889
16890         /* initialize dummy TM client */
16891         ilt_cli.start      = 0;
16892         ilt_cli.end        = ILT_NUM_PAGE_ENTRIES - 1;
16893         ilt_cli.client_num = ILT_CLIENT_TM;
16894
16895         /*
16896          * Step 1: set zeroes to all ilt page entries with valid bit on
16897          * Step 2: set the timers first/last ilt entry to point
16898          * to the entire range to prevent ILT range error for 3rd/4th
16899          * vnic (this code assumes existence of the vnic)
16900          *
16901          * both steps performed by call to ecore_ilt_client_init_op()
16902          * with dummy TM client
16903          *
16904          * we must use pretend since PXP2_REG_RQ_##blk##_FIRST_ILT
16905          * and his brother are split registers
16906          */
16907
16908         bxe_pretend_func(sc, (SC_PATH(sc) + 6));
16909         ecore_ilt_client_init_op_ilt(sc, &ilt, &ilt_cli, INITOP_CLEAR);
16910         bxe_pretend_func(sc, SC_ABS_FUNC(sc));
16911
16912         REG_WR(sc, PXP2_REG_RQ_DRAM_ALIGN, BXE_PXP_DRAM_ALIGN);
16913         REG_WR(sc, PXP2_REG_RQ_DRAM_ALIGN_RD, BXE_PXP_DRAM_ALIGN);
16914         REG_WR(sc, PXP2_REG_RQ_DRAM_ALIGN_SEL, 1);
16915     }
16916
16917     REG_WR(sc, PXP2_REG_RQ_DISABLE_INPUTS, 0);
16918     REG_WR(sc, PXP2_REG_RD_DISABLE_INPUTS, 0);
16919
16920     if (!CHIP_IS_E1x(sc)) {
16921         int factor = CHIP_REV_IS_EMUL(sc) ? 1000 :
16922                      (CHIP_REV_IS_FPGA(sc) ? 400 : 0);
16923
16924         ecore_init_block(sc, BLOCK_PGLUE_B, PHASE_COMMON);
16925         ecore_init_block(sc, BLOCK_ATC, PHASE_COMMON);
16926
16927         /* let the HW do it's magic... */
16928         do {
16929             DELAY(200000);
16930             val = REG_RD(sc, ATC_REG_ATC_INIT_DONE);
16931         } while (factor-- && (val != 1));
16932
16933         if (val != 1) {
16934             BLOGE(sc, "ATC_INIT failed val = 0x%x\n", val);
16935             return (-1);
16936         }
16937     }
16938
16939     BLOGD(sc, DBG_LOAD, "after pglue and atc init\n");
16940
16941     ecore_init_block(sc, BLOCK_DMAE, PHASE_COMMON);
16942
16943     bxe_iov_init_dmae(sc);
16944
16945     /* clean the DMAE memory */
16946     sc->dmae_ready = 1;
16947     ecore_init_fill(sc, TSEM_REG_PRAM, 0, 8, 1);
16948
16949     ecore_init_block(sc, BLOCK_TCM, PHASE_COMMON);
16950
16951     ecore_init_block(sc, BLOCK_UCM, PHASE_COMMON);
16952
16953     ecore_init_block(sc, BLOCK_CCM, PHASE_COMMON);
16954
16955     ecore_init_block(sc, BLOCK_XCM, PHASE_COMMON);
16956
16957     bxe_read_dmae(sc, XSEM_REG_PASSIVE_BUFFER, 3);
16958     bxe_read_dmae(sc, CSEM_REG_PASSIVE_BUFFER, 3);
16959     bxe_read_dmae(sc, TSEM_REG_PASSIVE_BUFFER, 3);
16960     bxe_read_dmae(sc, USEM_REG_PASSIVE_BUFFER, 3);
16961
16962     ecore_init_block(sc, BLOCK_QM, PHASE_COMMON);
16963
16964     /* QM queues pointers table */
16965     ecore_qm_init_ptr_table(sc, sc->qm_cid_count, INITOP_SET);
16966
16967     /* soft reset pulse */
16968     REG_WR(sc, QM_REG_SOFT_RESET, 1);
16969     REG_WR(sc, QM_REG_SOFT_RESET, 0);
16970
16971     if (CNIC_SUPPORT(sc))
16972         ecore_init_block(sc, BLOCK_TM, PHASE_COMMON);
16973
16974     ecore_init_block(sc, BLOCK_DORQ, PHASE_COMMON);
16975     REG_WR(sc, DORQ_REG_DPM_CID_OFST, BXE_DB_SHIFT);
16976     if (!CHIP_REV_IS_SLOW(sc)) {
16977         /* enable hw interrupt from doorbell Q */
16978         REG_WR(sc, DORQ_REG_DORQ_INT_MASK, 0);
16979     }
16980
16981     ecore_init_block(sc, BLOCK_BRB1, PHASE_COMMON);
16982
16983     ecore_init_block(sc, BLOCK_PRS, PHASE_COMMON);
16984     REG_WR(sc, PRS_REG_A_PRSU_20, 0xf);
16985
16986     if (!CHIP_IS_E1(sc)) {
16987         REG_WR(sc, PRS_REG_E1HOV_MODE, sc->devinfo.mf_info.path_has_ovlan);
16988     }
16989
16990     if (!CHIP_IS_E1x(sc) && !CHIP_IS_E3B0(sc)) {
16991         if (IS_MF_AFEX(sc)) {
16992             /*
16993              * configure that AFEX and VLAN headers must be
16994              * received in AFEX mode
16995              */
16996             REG_WR(sc, PRS_REG_HDRS_AFTER_BASIC, 0xE);
16997             REG_WR(sc, PRS_REG_MUST_HAVE_HDRS, 0xA);
16998             REG_WR(sc, PRS_REG_HDRS_AFTER_TAG_0, 0x6);
16999             REG_WR(sc, PRS_REG_TAG_ETHERTYPE_0, 0x8926);
17000             REG_WR(sc, PRS_REG_TAG_LEN_0, 0x4);
17001         } else {
17002             /*
17003              * Bit-map indicating which L2 hdrs may appear
17004              * after the basic Ethernet header
17005              */
17006             REG_WR(sc, PRS_REG_HDRS_AFTER_BASIC,
17007                    sc->devinfo.mf_info.path_has_ovlan ? 7 : 6);
17008         }
17009     }
17010
17011     ecore_init_block(sc, BLOCK_TSDM, PHASE_COMMON);
17012     ecore_init_block(sc, BLOCK_CSDM, PHASE_COMMON);
17013     ecore_init_block(sc, BLOCK_USDM, PHASE_COMMON);
17014     ecore_init_block(sc, BLOCK_XSDM, PHASE_COMMON);
17015
17016     if (!CHIP_IS_E1x(sc)) {
17017         /* reset VFC memories */
17018         REG_WR(sc, TSEM_REG_FAST_MEMORY + VFC_REG_MEMORIES_RST,
17019                VFC_MEMORIES_RST_REG_CAM_RST |
17020                VFC_MEMORIES_RST_REG_RAM_RST);
17021         REG_WR(sc, XSEM_REG_FAST_MEMORY + VFC_REG_MEMORIES_RST,
17022                VFC_MEMORIES_RST_REG_CAM_RST |
17023                VFC_MEMORIES_RST_REG_RAM_RST);
17024
17025         DELAY(20000);
17026     }
17027
17028     ecore_init_block(sc, BLOCK_TSEM, PHASE_COMMON);
17029     ecore_init_block(sc, BLOCK_USEM, PHASE_COMMON);
17030     ecore_init_block(sc, BLOCK_CSEM, PHASE_COMMON);
17031     ecore_init_block(sc, BLOCK_XSEM, PHASE_COMMON);
17032
17033     /* sync semi rtc */
17034     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
17035            0x80000000);
17036     REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET,
17037            0x80000000);
17038
17039     ecore_init_block(sc, BLOCK_UPB, PHASE_COMMON);
17040     ecore_init_block(sc, BLOCK_XPB, PHASE_COMMON);
17041     ecore_init_block(sc, BLOCK_PBF, PHASE_COMMON);
17042
17043     if (!CHIP_IS_E1x(sc)) {
17044         if (IS_MF_AFEX(sc)) {
17045             /*
17046              * configure that AFEX and VLAN headers must be
17047              * sent in AFEX mode
17048              */
17049             REG_WR(sc, PBF_REG_HDRS_AFTER_BASIC, 0xE);
17050             REG_WR(sc, PBF_REG_MUST_HAVE_HDRS, 0xA);
17051             REG_WR(sc, PBF_REG_HDRS_AFTER_TAG_0, 0x6);
17052             REG_WR(sc, PBF_REG_TAG_ETHERTYPE_0, 0x8926);
17053             REG_WR(sc, PBF_REG_TAG_LEN_0, 0x4);
17054         } else {
17055             REG_WR(sc, PBF_REG_HDRS_AFTER_BASIC,
17056                    sc->devinfo.mf_info.path_has_ovlan ? 7 : 6);
17057         }
17058     }
17059
17060     REG_WR(sc, SRC_REG_SOFT_RST, 1);
17061
17062     ecore_init_block(sc, BLOCK_SRC, PHASE_COMMON);
17063
17064     if (CNIC_SUPPORT(sc)) {
17065         REG_WR(sc, SRC_REG_KEYSEARCH_0, 0x63285672);
17066         REG_WR(sc, SRC_REG_KEYSEARCH_1, 0x24b8f2cc);
17067         REG_WR(sc, SRC_REG_KEYSEARCH_2, 0x223aef9b);
17068         REG_WR(sc, SRC_REG_KEYSEARCH_3, 0x26001e3a);
17069         REG_WR(sc, SRC_REG_KEYSEARCH_4, 0x7ae91116);
17070         REG_WR(sc, SRC_REG_KEYSEARCH_5, 0x5ce5230b);
17071         REG_WR(sc, SRC_REG_KEYSEARCH_6, 0x298d8adf);
17072         REG_WR(sc, SRC_REG_KEYSEARCH_7, 0x6eb0ff09);
17073         REG_WR(sc, SRC_REG_KEYSEARCH_8, 0x1830f82f);
17074         REG_WR(sc, SRC_REG_KEYSEARCH_9, 0x01e46be7);
17075     }
17076     REG_WR(sc, SRC_REG_SOFT_RST, 0);
17077
17078     if (sizeof(union cdu_context) != 1024) {
17079         /* we currently assume that a context is 1024 bytes */
17080         BLOGE(sc, "please adjust the size of cdu_context(%ld)\n",
17081               (long)sizeof(union cdu_context));
17082     }
17083
17084     ecore_init_block(sc, BLOCK_CDU, PHASE_COMMON);
17085     val = (4 << 24) + (0 << 12) + 1024;
17086     REG_WR(sc, CDU_REG_CDU_GLOBAL_PARAMS, val);
17087
17088     ecore_init_block(sc, BLOCK_CFC, PHASE_COMMON);
17089
17090     REG_WR(sc, CFC_REG_INIT_REG, 0x7FF);
17091     /* enable context validation interrupt from CFC */
17092     REG_WR(sc, CFC_REG_CFC_INT_MASK, 0);
17093
17094     /* set the thresholds to prevent CFC/CDU race */
17095     REG_WR(sc, CFC_REG_DEBUG0, 0x20020000);
17096     ecore_init_block(sc, BLOCK_HC, PHASE_COMMON);
17097
17098     if (!CHIP_IS_E1x(sc) && BXE_NOMCP(sc)) {
17099         REG_WR(sc, IGU_REG_RESET_MEMORIES, 0x36);
17100     }
17101
17102     ecore_init_block(sc, BLOCK_IGU, PHASE_COMMON);
17103     ecore_init_block(sc, BLOCK_MISC_AEU, PHASE_COMMON);
17104
17105     /* Reset PCIE errors for debug */
17106     REG_WR(sc, 0x2814, 0xffffffff);
17107     REG_WR(sc, 0x3820, 0xffffffff);
17108
17109     if (!CHIP_IS_E1x(sc)) {
17110         REG_WR(sc, PCICFG_OFFSET + PXPCS_TL_CONTROL_5,
17111                (PXPCS_TL_CONTROL_5_ERR_UNSPPORT1 |
17112                 PXPCS_TL_CONTROL_5_ERR_UNSPPORT));
17113         REG_WR(sc, PCICFG_OFFSET + PXPCS_TL_FUNC345_STAT,
17114                (PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT4 |
17115                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT3 |
17116                 PXPCS_TL_FUNC345_STAT_ERR_UNSPPORT2));
17117         REG_WR(sc, PCICFG_OFFSET + PXPCS_TL_FUNC678_STAT,
17118                (PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT7 |
17119                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT6 |
17120                 PXPCS_TL_FUNC678_STAT_ERR_UNSPPORT5));
17121     }
17122
17123     ecore_init_block(sc, BLOCK_NIG, PHASE_COMMON);
17124
17125     if (!CHIP_IS_E1(sc)) {
17126         /* in E3 this done in per-port section */
17127         if (!CHIP_IS_E3(sc))
17128             REG_WR(sc, NIG_REG_LLH_MF_MODE, IS_MF(sc));
17129     }
17130
17131     if (CHIP_IS_E1H(sc)) {
17132         /* not applicable for E2 (and above ...) */
17133         REG_WR(sc, NIG_REG_LLH_E1HOV_MODE, IS_MF_SD(sc));
17134     }
17135
17136     if (CHIP_REV_IS_SLOW(sc)) {
17137         DELAY(200000);
17138     }
17139
17140     /* finish CFC init */
17141     val = reg_poll(sc, CFC_REG_LL_INIT_DONE, 1, 100, 10);
17142     if (val != 1) {
17143         BLOGE(sc, "CFC LL_INIT failed val=0x%x\n", val);
17144         return (-1);
17145     }
17146     val = reg_poll(sc, CFC_REG_AC_INIT_DONE, 1, 100, 10);
17147     if (val != 1) {
17148         BLOGE(sc, "CFC AC_INIT failed val=0x%x\n", val);
17149         return (-1);
17150     }
17151     val = reg_poll(sc, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
17152     if (val != 1) {
17153         BLOGE(sc, "CFC CAM_INIT failed val=0x%x\n", val);
17154         return (-1);
17155     }
17156     REG_WR(sc, CFC_REG_DEBUG0, 0);
17157
17158     if (CHIP_IS_E1(sc)) {
17159         /* read NIG statistic to see if this is our first up since powerup */
17160         bxe_read_dmae(sc, NIG_REG_STAT2_BRB_OCTET, 2);
17161         val = *BXE_SP(sc, wb_data[0]);
17162
17163         /* do internal memory self test */
17164         if ((val == 0) && bxe_int_mem_test(sc)) {
17165             BLOGE(sc, "internal mem self test failed val=0x%x\n", val);
17166             return (-1);
17167         }
17168     }
17169
17170     bxe_setup_fan_failure_detection(sc);
17171
17172     /* clear PXP2 attentions */
17173     REG_RD(sc, PXP2_REG_PXP2_INT_STS_CLR_0);
17174
17175     bxe_enable_blocks_attention(sc);
17176
17177     if (!CHIP_REV_IS_SLOW(sc)) {
17178         ecore_enable_blocks_parity(sc);
17179     }
17180
17181     if (!BXE_NOMCP(sc)) {
17182         if (CHIP_IS_E1x(sc)) {
17183             bxe_common_init_phy(sc);
17184         }
17185     }
17186
17187     return (0);
17188 }
17189
17190 /**
17191  * bxe_init_hw_common_chip - init HW at the COMMON_CHIP phase.
17192  *
17193  * @sc:     driver handle
17194  */
17195 static int
17196 bxe_init_hw_common_chip(struct bxe_softc *sc)
17197 {
17198     int rc = bxe_init_hw_common(sc);
17199
17200     if (rc) {
17201         BLOGE(sc, "bxe_init_hw_common failed rc=%d\n", rc);
17202         return (rc);
17203     }
17204
17205     /* In E2 2-PORT mode, same ext phy is used for the two paths */
17206     if (!BXE_NOMCP(sc)) {
17207         bxe_common_init_phy(sc);
17208     }
17209
17210     return (0);
17211 }
17212
17213 static int
17214 bxe_init_hw_port(struct bxe_softc *sc)
17215 {
17216     int port = SC_PORT(sc);
17217     int init_phase = port ? PHASE_PORT1 : PHASE_PORT0;
17218     uint32_t low, high;
17219     uint32_t val;
17220
17221     BLOGD(sc, DBG_LOAD, "starting port init for port %d\n", port);
17222
17223     REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
17224
17225     ecore_init_block(sc, BLOCK_MISC, init_phase);
17226     ecore_init_block(sc, BLOCK_PXP, init_phase);
17227     ecore_init_block(sc, BLOCK_PXP2, init_phase);
17228
17229     /*
17230      * Timers bug workaround: disables the pf_master bit in pglue at
17231      * common phase, we need to enable it here before any dmae access are
17232      * attempted. Therefore we manually added the enable-master to the
17233      * port phase (it also happens in the function phase)
17234      */
17235     if (!CHIP_IS_E1x(sc)) {
17236         REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
17237     }
17238
17239     ecore_init_block(sc, BLOCK_ATC, init_phase);
17240     ecore_init_block(sc, BLOCK_DMAE, init_phase);
17241     ecore_init_block(sc, BLOCK_PGLUE_B, init_phase);
17242     ecore_init_block(sc, BLOCK_QM, init_phase);
17243
17244     ecore_init_block(sc, BLOCK_TCM, init_phase);
17245     ecore_init_block(sc, BLOCK_UCM, init_phase);
17246     ecore_init_block(sc, BLOCK_CCM, init_phase);
17247     ecore_init_block(sc, BLOCK_XCM, init_phase);
17248
17249     /* QM cid (connection) count */
17250     ecore_qm_init_cid_count(sc, sc->qm_cid_count, INITOP_SET);
17251
17252     if (CNIC_SUPPORT(sc)) {
17253         ecore_init_block(sc, BLOCK_TM, init_phase);
17254         REG_WR(sc, TM_REG_LIN0_SCAN_TIME + port*4, 20);
17255         REG_WR(sc, TM_REG_LIN0_MAX_ACTIVE_CID + port*4, 31);
17256     }
17257
17258     ecore_init_block(sc, BLOCK_DORQ, init_phase);
17259
17260     ecore_init_block(sc, BLOCK_BRB1, init_phase);
17261
17262     if (CHIP_IS_E1(sc) || CHIP_IS_E1H(sc)) {
17263         if (IS_MF(sc)) {
17264             low = (BXE_ONE_PORT(sc) ? 160 : 246);
17265         } else if (sc->mtu > 4096) {
17266             if (BXE_ONE_PORT(sc)) {
17267                 low = 160;
17268             } else {
17269                 val = sc->mtu;
17270                 /* (24*1024 + val*4)/256 */
17271                 low = (96 + (val / 64) + ((val % 64) ? 1 : 0));
17272             }
17273         } else {
17274             low = (BXE_ONE_PORT(sc) ? 80 : 160);
17275         }
17276         high = (low + 56); /* 14*1024/256 */
17277         REG_WR(sc, BRB1_REG_PAUSE_LOW_THRESHOLD_0 + port*4, low);
17278         REG_WR(sc, BRB1_REG_PAUSE_HIGH_THRESHOLD_0 + port*4, high);
17279     }
17280
17281     if (CHIP_IS_MODE_4_PORT(sc)) {
17282         REG_WR(sc, SC_PORT(sc) ?
17283                BRB1_REG_MAC_GUARANTIED_1 :
17284                BRB1_REG_MAC_GUARANTIED_0, 40);
17285     }
17286
17287     ecore_init_block(sc, BLOCK_PRS, init_phase);
17288     if (CHIP_IS_E3B0(sc)) {
17289         if (IS_MF_AFEX(sc)) {
17290             /* configure headers for AFEX mode */
17291             REG_WR(sc, SC_PORT(sc) ?
17292                    PRS_REG_HDRS_AFTER_BASIC_PORT_1 :
17293                    PRS_REG_HDRS_AFTER_BASIC_PORT_0, 0xE);
17294             REG_WR(sc, SC_PORT(sc) ?
17295                    PRS_REG_HDRS_AFTER_TAG_0_PORT_1 :
17296                    PRS_REG_HDRS_AFTER_TAG_0_PORT_0, 0x6);
17297             REG_WR(sc, SC_PORT(sc) ?
17298                    PRS_REG_MUST_HAVE_HDRS_PORT_1 :
17299                    PRS_REG_MUST_HAVE_HDRS_PORT_0, 0xA);
17300         } else {
17301             /* Ovlan exists only if we are in multi-function +
17302              * switch-dependent mode, in switch-independent there
17303              * is no ovlan headers
17304              */
17305             REG_WR(sc, SC_PORT(sc) ?
17306                    PRS_REG_HDRS_AFTER_BASIC_PORT_1 :
17307                    PRS_REG_HDRS_AFTER_BASIC_PORT_0,
17308                    (sc->devinfo.mf_info.path_has_ovlan ? 7 : 6));
17309         }
17310     }
17311
17312     ecore_init_block(sc, BLOCK_TSDM, init_phase);
17313     ecore_init_block(sc, BLOCK_CSDM, init_phase);
17314     ecore_init_block(sc, BLOCK_USDM, init_phase);
17315     ecore_init_block(sc, BLOCK_XSDM, init_phase);
17316
17317     ecore_init_block(sc, BLOCK_TSEM, init_phase);
17318     ecore_init_block(sc, BLOCK_USEM, init_phase);
17319     ecore_init_block(sc, BLOCK_CSEM, init_phase);
17320     ecore_init_block(sc, BLOCK_XSEM, init_phase);
17321
17322     ecore_init_block(sc, BLOCK_UPB, init_phase);
17323     ecore_init_block(sc, BLOCK_XPB, init_phase);
17324
17325     ecore_init_block(sc, BLOCK_PBF, init_phase);
17326
17327     if (CHIP_IS_E1x(sc)) {
17328         /* configure PBF to work without PAUSE mtu 9000 */
17329         REG_WR(sc, PBF_REG_P0_PAUSE_ENABLE + port*4, 0);
17330
17331         /* update threshold */
17332         REG_WR(sc, PBF_REG_P0_ARB_THRSH + port*4, (9040/16));
17333         /* update init credit */
17334         REG_WR(sc, PBF_REG_P0_INIT_CRD + port*4, (9040/16) + 553 - 22);
17335
17336         /* probe changes */
17337         REG_WR(sc, PBF_REG_INIT_P0 + port*4, 1);
17338         DELAY(50);
17339         REG_WR(sc, PBF_REG_INIT_P0 + port*4, 0);
17340     }
17341
17342     if (CNIC_SUPPORT(sc)) {
17343         ecore_init_block(sc, BLOCK_SRC, init_phase);
17344     }
17345
17346     ecore_init_block(sc, BLOCK_CDU, init_phase);
17347     ecore_init_block(sc, BLOCK_CFC, init_phase);
17348
17349     if (CHIP_IS_E1(sc)) {
17350         REG_WR(sc, HC_REG_LEADING_EDGE_0 + port*8, 0);
17351         REG_WR(sc, HC_REG_TRAILING_EDGE_0 + port*8, 0);
17352     }
17353     ecore_init_block(sc, BLOCK_HC, init_phase);
17354
17355     ecore_init_block(sc, BLOCK_IGU, init_phase);
17356
17357     ecore_init_block(sc, BLOCK_MISC_AEU, init_phase);
17358     /* init aeu_mask_attn_func_0/1:
17359      *  - SF mode: bits 3-7 are masked. only bits 0-2 are in use
17360      *  - MF mode: bit 3 is masked. bits 0-2 are in use as in SF
17361      *             bits 4-7 are used for "per vn group attention" */
17362     val = IS_MF(sc) ? 0xF7 : 0x7;
17363     /* Enable DCBX attention for all but E1 */
17364     val |= CHIP_IS_E1(sc) ? 0 : 0x10;
17365     REG_WR(sc, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, val);
17366
17367     ecore_init_block(sc, BLOCK_NIG, init_phase);
17368
17369     if (!CHIP_IS_E1x(sc)) {
17370         /* Bit-map indicating which L2 hdrs may appear after the
17371          * basic Ethernet header
17372          */
17373         if (IS_MF_AFEX(sc)) {
17374             REG_WR(sc, SC_PORT(sc) ?
17375                    NIG_REG_P1_HDRS_AFTER_BASIC :
17376                    NIG_REG_P0_HDRS_AFTER_BASIC, 0xE);
17377         } else {
17378             REG_WR(sc, SC_PORT(sc) ?
17379                    NIG_REG_P1_HDRS_AFTER_BASIC :
17380                    NIG_REG_P0_HDRS_AFTER_BASIC,
17381                    IS_MF_SD(sc) ? 7 : 6);
17382         }
17383
17384         if (CHIP_IS_E3(sc)) {
17385             REG_WR(sc, SC_PORT(sc) ?
17386                    NIG_REG_LLH1_MF_MODE :
17387                    NIG_REG_LLH_MF_MODE, IS_MF(sc));
17388         }
17389     }
17390     if (!CHIP_IS_E3(sc)) {
17391         REG_WR(sc, NIG_REG_XGXS_SERDES0_MODE_SEL + port*4, 1);
17392     }
17393
17394     if (!CHIP_IS_E1(sc)) {
17395         /* 0x2 disable mf_ov, 0x1 enable */
17396         REG_WR(sc, NIG_REG_LLH0_BRB1_DRV_MASK_MF + port*4,
17397                (IS_MF_SD(sc) ? 0x1 : 0x2));
17398
17399         if (!CHIP_IS_E1x(sc)) {
17400             val = 0;
17401             switch (sc->devinfo.mf_info.mf_mode) {
17402             case MULTI_FUNCTION_SD:
17403                 val = 1;
17404                 break;
17405             case MULTI_FUNCTION_SI:
17406             case MULTI_FUNCTION_AFEX:
17407                 val = 2;
17408                 break;
17409             }
17410
17411             REG_WR(sc, (SC_PORT(sc) ? NIG_REG_LLH1_CLS_TYPE :
17412                         NIG_REG_LLH0_CLS_TYPE), val);
17413         }
17414         REG_WR(sc, NIG_REG_LLFC_ENABLE_0 + port*4, 0);
17415         REG_WR(sc, NIG_REG_LLFC_OUT_EN_0 + port*4, 0);
17416         REG_WR(sc, NIG_REG_PAUSE_ENABLE_0 + port*4, 1);
17417     }
17418
17419     /* If SPIO5 is set to generate interrupts, enable it for this port */
17420     val = REG_RD(sc, MISC_REG_SPIO_EVENT_EN);
17421     if (val & MISC_SPIO_SPIO5) {
17422         uint32_t reg_addr = (port ? MISC_REG_AEU_ENABLE1_FUNC_1_OUT_0 :
17423                                     MISC_REG_AEU_ENABLE1_FUNC_0_OUT_0);
17424         val = REG_RD(sc, reg_addr);
17425         val |= AEU_INPUTS_ATTN_BITS_SPIO5;
17426         REG_WR(sc, reg_addr, val);
17427     }
17428
17429     return (0);
17430 }
17431
17432 static uint32_t
17433 bxe_flr_clnup_reg_poll(struct bxe_softc *sc,
17434                        uint32_t         reg,
17435                        uint32_t         expected,
17436                        uint32_t         poll_count)
17437 {
17438     uint32_t cur_cnt = poll_count;
17439     uint32_t val;
17440
17441     while ((val = REG_RD(sc, reg)) != expected && cur_cnt--) {
17442         DELAY(FLR_WAIT_INTERVAL);
17443     }
17444
17445     return (val);
17446 }
17447
17448 static int
17449 bxe_flr_clnup_poll_hw_counter(struct bxe_softc *sc,
17450                               uint32_t         reg,
17451                               char             *msg,
17452                               uint32_t         poll_cnt)
17453 {
17454     uint32_t val = bxe_flr_clnup_reg_poll(sc, reg, 0, poll_cnt);
17455
17456     if (val != 0) {
17457         BLOGE(sc, "%s usage count=%d\n", msg, val);
17458         return (1);
17459     }
17460
17461     return (0);
17462 }
17463
17464 /* Common routines with VF FLR cleanup */
17465 static uint32_t
17466 bxe_flr_clnup_poll_count(struct bxe_softc *sc)
17467 {
17468     /* adjust polling timeout */
17469     if (CHIP_REV_IS_EMUL(sc)) {
17470         return (FLR_POLL_CNT * 2000);
17471     }
17472
17473     if (CHIP_REV_IS_FPGA(sc)) {
17474         return (FLR_POLL_CNT * 120);
17475     }
17476
17477     return (FLR_POLL_CNT);
17478 }
17479
17480 static int
17481 bxe_poll_hw_usage_counters(struct bxe_softc *sc,
17482                            uint32_t         poll_cnt)
17483 {
17484     /* wait for CFC PF usage-counter to zero (includes all the VFs) */
17485     if (bxe_flr_clnup_poll_hw_counter(sc,
17486                                       CFC_REG_NUM_LCIDS_INSIDE_PF,
17487                                       "CFC PF usage counter timed out",
17488                                       poll_cnt)) {
17489         return (1);
17490     }
17491
17492     /* Wait for DQ PF usage-counter to zero (until DQ cleanup) */
17493     if (bxe_flr_clnup_poll_hw_counter(sc,
17494                                       DORQ_REG_PF_USAGE_CNT,
17495                                       "DQ PF usage counter timed out",
17496                                       poll_cnt)) {
17497         return (1);
17498     }
17499
17500     /* Wait for QM PF usage-counter to zero (until DQ cleanup) */
17501     if (bxe_flr_clnup_poll_hw_counter(sc,
17502                                       QM_REG_PF_USG_CNT_0 + 4*SC_FUNC(sc),
17503                                       "QM PF usage counter timed out",
17504                                       poll_cnt)) {
17505         return (1);
17506     }
17507
17508     /* Wait for Timer PF usage-counters to zero (until DQ cleanup) */
17509     if (bxe_flr_clnup_poll_hw_counter(sc,
17510                                       TM_REG_LIN0_VNIC_UC + 4*SC_PORT(sc),
17511                                       "Timers VNIC usage counter timed out",
17512                                       poll_cnt)) {
17513         return (1);
17514     }
17515
17516     if (bxe_flr_clnup_poll_hw_counter(sc,
17517                                       TM_REG_LIN0_NUM_SCANS + 4*SC_PORT(sc),
17518                                       "Timers NUM_SCANS usage counter timed out",
17519                                       poll_cnt)) {
17520         return (1);
17521     }
17522
17523     /* Wait DMAE PF usage counter to zero */
17524     if (bxe_flr_clnup_poll_hw_counter(sc,
17525                                       dmae_reg_go_c[INIT_DMAE_C(sc)],
17526                                       "DMAE dommand register timed out",
17527                                       poll_cnt)) {
17528         return (1);
17529     }
17530
17531     return (0);
17532 }
17533
17534 #define OP_GEN_PARAM(param)                                            \
17535     (((param) << SDM_OP_GEN_COMP_PARAM_SHIFT) & SDM_OP_GEN_COMP_PARAM)
17536 #define OP_GEN_TYPE(type)                                           \
17537     (((type) << SDM_OP_GEN_COMP_TYPE_SHIFT) & SDM_OP_GEN_COMP_TYPE)
17538 #define OP_GEN_AGG_VECT(index)                                             \
17539     (((index) << SDM_OP_GEN_AGG_VECT_IDX_SHIFT) & SDM_OP_GEN_AGG_VECT_IDX)
17540
17541 static int
17542 bxe_send_final_clnup(struct bxe_softc *sc,
17543                      uint8_t          clnup_func,
17544                      uint32_t         poll_cnt)
17545 {
17546     uint32_t op_gen_command = 0;
17547     uint32_t comp_addr = (BAR_CSTRORM_INTMEM +
17548                           CSTORM_FINAL_CLEANUP_COMPLETE_OFFSET(clnup_func));
17549     int ret = 0;
17550
17551     if (REG_RD(sc, comp_addr)) {
17552         BLOGE(sc, "Cleanup complete was not 0 before sending\n");
17553         return (1);
17554     }
17555
17556     op_gen_command |= OP_GEN_PARAM(XSTORM_AGG_INT_FINAL_CLEANUP_INDEX);
17557     op_gen_command |= OP_GEN_TYPE(XSTORM_AGG_INT_FINAL_CLEANUP_COMP_TYPE);
17558     op_gen_command |= OP_GEN_AGG_VECT(clnup_func);
17559     op_gen_command |= 1 << SDM_OP_GEN_AGG_VECT_IDX_VALID_SHIFT;
17560
17561     BLOGD(sc, DBG_LOAD, "sending FW Final cleanup\n");
17562     REG_WR(sc, XSDM_REG_OPERATION_GEN, op_gen_command);
17563
17564     if (bxe_flr_clnup_reg_poll(sc, comp_addr, 1, poll_cnt) != 1) {
17565         BLOGE(sc, "FW final cleanup did not succeed\n");
17566         BLOGD(sc, DBG_LOAD, "At timeout completion address contained %x\n",
17567               (REG_RD(sc, comp_addr)));
17568         bxe_panic(sc, ("FLR cleanup failed\n"));
17569         return (1);
17570     }
17571
17572     /* Zero completion for nxt FLR */
17573     REG_WR(sc, comp_addr, 0);
17574
17575     return (ret);
17576 }
17577
17578 static void
17579 bxe_pbf_pN_buf_flushed(struct bxe_softc       *sc,
17580                        struct pbf_pN_buf_regs *regs,
17581                        uint32_t               poll_count)
17582 {
17583     uint32_t init_crd, crd, crd_start, crd_freed, crd_freed_start;
17584     uint32_t cur_cnt = poll_count;
17585
17586     crd_freed = crd_freed_start = REG_RD(sc, regs->crd_freed);
17587     crd = crd_start = REG_RD(sc, regs->crd);
17588     init_crd = REG_RD(sc, regs->init_crd);
17589
17590     BLOGD(sc, DBG_LOAD, "INIT CREDIT[%d] : %x\n", regs->pN, init_crd);
17591     BLOGD(sc, DBG_LOAD, "CREDIT[%d]      : s:%x\n", regs->pN, crd);
17592     BLOGD(sc, DBG_LOAD, "CREDIT_FREED[%d]: s:%x\n", regs->pN, crd_freed);
17593
17594     while ((crd != init_crd) &&
17595            ((uint32_t)((int32_t)crd_freed - (int32_t)crd_freed_start) <
17596             (init_crd - crd_start))) {
17597         if (cur_cnt--) {
17598             DELAY(FLR_WAIT_INTERVAL);
17599             crd = REG_RD(sc, regs->crd);
17600             crd_freed = REG_RD(sc, regs->crd_freed);
17601         } else {
17602             BLOGD(sc, DBG_LOAD, "PBF tx buffer[%d] timed out\n", regs->pN);
17603             BLOGD(sc, DBG_LOAD, "CREDIT[%d]      : c:%x\n", regs->pN, crd);
17604             BLOGD(sc, DBG_LOAD, "CREDIT_FREED[%d]: c:%x\n", regs->pN, crd_freed);
17605             break;
17606         }
17607     }
17608
17609     BLOGD(sc, DBG_LOAD, "Waited %d*%d usec for PBF tx buffer[%d]\n",
17610           poll_count-cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
17611 }
17612
17613 static void
17614 bxe_pbf_pN_cmd_flushed(struct bxe_softc       *sc,
17615                        struct pbf_pN_cmd_regs *regs,
17616                        uint32_t               poll_count)
17617 {
17618     uint32_t occup, to_free, freed, freed_start;
17619     uint32_t cur_cnt = poll_count;
17620
17621     occup = to_free = REG_RD(sc, regs->lines_occup);
17622     freed = freed_start = REG_RD(sc, regs->lines_freed);
17623
17624     BLOGD(sc, DBG_LOAD, "OCCUPANCY[%d]   : s:%x\n", regs->pN, occup);
17625     BLOGD(sc, DBG_LOAD, "LINES_FREED[%d] : s:%x\n", regs->pN, freed);
17626
17627     while (occup &&
17628            ((uint32_t)((int32_t)freed - (int32_t)freed_start) < to_free)) {
17629         if (cur_cnt--) {
17630             DELAY(FLR_WAIT_INTERVAL);
17631             occup = REG_RD(sc, regs->lines_occup);
17632             freed = REG_RD(sc, regs->lines_freed);
17633         } else {
17634             BLOGD(sc, DBG_LOAD, "PBF cmd queue[%d] timed out\n", regs->pN);
17635             BLOGD(sc, DBG_LOAD, "OCCUPANCY[%d]   : s:%x\n", regs->pN, occup);
17636             BLOGD(sc, DBG_LOAD, "LINES_FREED[%d] : s:%x\n", regs->pN, freed);
17637             break;
17638         }
17639     }
17640
17641     BLOGD(sc, DBG_LOAD, "Waited %d*%d usec for PBF cmd queue[%d]\n",
17642           poll_count - cur_cnt, FLR_WAIT_INTERVAL, regs->pN);
17643 }
17644
17645 static void
17646 bxe_tx_hw_flushed(struct bxe_softc *sc, uint32_t poll_count)
17647 {
17648     struct pbf_pN_cmd_regs cmd_regs[] = {
17649         {0, (CHIP_IS_E3B0(sc)) ?
17650             PBF_REG_TQ_OCCUPANCY_Q0 :
17651             PBF_REG_P0_TQ_OCCUPANCY,
17652             (CHIP_IS_E3B0(sc)) ?
17653             PBF_REG_TQ_LINES_FREED_CNT_Q0 :
17654             PBF_REG_P0_TQ_LINES_FREED_CNT},
17655         {1, (CHIP_IS_E3B0(sc)) ?
17656             PBF_REG_TQ_OCCUPANCY_Q1 :
17657             PBF_REG_P1_TQ_OCCUPANCY,
17658             (CHIP_IS_E3B0(sc)) ?
17659             PBF_REG_TQ_LINES_FREED_CNT_Q1 :
17660             PBF_REG_P1_TQ_LINES_FREED_CNT},
17661         {4, (CHIP_IS_E3B0(sc)) ?
17662             PBF_REG_TQ_OCCUPANCY_LB_Q :
17663             PBF_REG_P4_TQ_OCCUPANCY,
17664             (CHIP_IS_E3B0(sc)) ?
17665             PBF_REG_TQ_LINES_FREED_CNT_LB_Q :
17666             PBF_REG_P4_TQ_LINES_FREED_CNT}
17667     };
17668
17669     struct pbf_pN_buf_regs buf_regs[] = {
17670         {0, (CHIP_IS_E3B0(sc)) ?
17671             PBF_REG_INIT_CRD_Q0 :
17672             PBF_REG_P0_INIT_CRD ,
17673             (CHIP_IS_E3B0(sc)) ?
17674             PBF_REG_CREDIT_Q0 :
17675             PBF_REG_P0_CREDIT,
17676             (CHIP_IS_E3B0(sc)) ?
17677             PBF_REG_INTERNAL_CRD_FREED_CNT_Q0 :
17678             PBF_REG_P0_INTERNAL_CRD_FREED_CNT},
17679         {1, (CHIP_IS_E3B0(sc)) ?
17680             PBF_REG_INIT_CRD_Q1 :
17681             PBF_REG_P1_INIT_CRD,
17682             (CHIP_IS_E3B0(sc)) ?
17683             PBF_REG_CREDIT_Q1 :
17684             PBF_REG_P1_CREDIT,
17685             (CHIP_IS_E3B0(sc)) ?
17686             PBF_REG_INTERNAL_CRD_FREED_CNT_Q1 :
17687             PBF_REG_P1_INTERNAL_CRD_FREED_CNT},
17688         {4, (CHIP_IS_E3B0(sc)) ?
17689             PBF_REG_INIT_CRD_LB_Q :
17690             PBF_REG_P4_INIT_CRD,
17691             (CHIP_IS_E3B0(sc)) ?
17692             PBF_REG_CREDIT_LB_Q :
17693             PBF_REG_P4_CREDIT,
17694             (CHIP_IS_E3B0(sc)) ?
17695             PBF_REG_INTERNAL_CRD_FREED_CNT_LB_Q :
17696             PBF_REG_P4_INTERNAL_CRD_FREED_CNT},
17697     };
17698
17699     int i;
17700
17701     /* Verify the command queues are flushed P0, P1, P4 */
17702     for (i = 0; i < ARRAY_SIZE(cmd_regs); i++) {
17703         bxe_pbf_pN_cmd_flushed(sc, &cmd_regs[i], poll_count);
17704     }
17705
17706     /* Verify the transmission buffers are flushed P0, P1, P4 */
17707     for (i = 0; i < ARRAY_SIZE(buf_regs); i++) {
17708         bxe_pbf_pN_buf_flushed(sc, &buf_regs[i], poll_count);
17709     }
17710 }
17711
17712 static void
17713 bxe_hw_enable_status(struct bxe_softc *sc)
17714 {
17715     uint32_t val;
17716
17717     val = REG_RD(sc, CFC_REG_WEAK_ENABLE_PF);
17718     BLOGD(sc, DBG_LOAD, "CFC_REG_WEAK_ENABLE_PF is 0x%x\n", val);
17719
17720     val = REG_RD(sc, PBF_REG_DISABLE_PF);
17721     BLOGD(sc, DBG_LOAD, "PBF_REG_DISABLE_PF is 0x%x\n", val);
17722
17723     val = REG_RD(sc, IGU_REG_PCI_PF_MSI_EN);
17724     BLOGD(sc, DBG_LOAD, "IGU_REG_PCI_PF_MSI_EN is 0x%x\n", val);
17725
17726     val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_EN);
17727     BLOGD(sc, DBG_LOAD, "IGU_REG_PCI_PF_MSIX_EN is 0x%x\n", val);
17728
17729     val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
17730     BLOGD(sc, DBG_LOAD, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x\n", val);
17731
17732     val = REG_RD(sc, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
17733     BLOGD(sc, DBG_LOAD, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x\n", val);
17734
17735     val = REG_RD(sc, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
17736     BLOGD(sc, DBG_LOAD, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x\n", val);
17737
17738     val = REG_RD(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
17739     BLOGD(sc, DBG_LOAD, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x\n", val);
17740 }
17741
17742 static int
17743 bxe_pf_flr_clnup(struct bxe_softc *sc)
17744 {
17745     uint32_t poll_cnt = bxe_flr_clnup_poll_count(sc);
17746
17747     BLOGD(sc, DBG_LOAD, "Cleanup after FLR PF[%d]\n", SC_ABS_FUNC(sc));
17748
17749     /* Re-enable PF target read access */
17750     REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_TARGET_READ, 1);
17751
17752     /* Poll HW usage counters */
17753     BLOGD(sc, DBG_LOAD, "Polling usage counters\n");
17754     if (bxe_poll_hw_usage_counters(sc, poll_cnt)) {
17755         return (-1);
17756     }
17757
17758     /* Zero the igu 'trailing edge' and 'leading edge' */
17759
17760     /* Send the FW cleanup command */
17761     if (bxe_send_final_clnup(sc, (uint8_t)SC_FUNC(sc), poll_cnt)) {
17762         return (-1);
17763     }
17764
17765     /* ATC cleanup */
17766
17767     /* Verify TX hw is flushed */
17768     bxe_tx_hw_flushed(sc, poll_cnt);
17769
17770     /* Wait 100ms (not adjusted according to platform) */
17771     DELAY(100000);
17772
17773     /* Verify no pending pci transactions */
17774     if (bxe_is_pcie_pending(sc)) {
17775         BLOGE(sc, "PCIE Transactions still pending\n");
17776     }
17777
17778     /* Debug */
17779     bxe_hw_enable_status(sc);
17780
17781     /*
17782      * Master enable - Due to WB DMAE writes performed before this
17783      * register is re-initialized as part of the regular function init
17784      */
17785     REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
17786
17787     return (0);
17788 }
17789
17790 static int
17791 bxe_init_hw_func(struct bxe_softc *sc)
17792 {
17793     int port = SC_PORT(sc);
17794     int func = SC_FUNC(sc);
17795     int init_phase = PHASE_PF0 + func;
17796     struct ecore_ilt *ilt = sc->ilt;
17797     uint16_t cdu_ilt_start;
17798     uint32_t addr, val;
17799     uint32_t main_mem_base, main_mem_size, main_mem_prty_clr;
17800     int i, main_mem_width, rc;
17801
17802     BLOGD(sc, DBG_LOAD, "starting func init for func %d\n", func);
17803
17804     /* FLR cleanup */
17805     if (!CHIP_IS_E1x(sc)) {
17806         rc = bxe_pf_flr_clnup(sc);
17807         if (rc) {
17808             BLOGE(sc, "FLR cleanup failed!\n");
17809             // XXX bxe_fw_dump(sc);
17810             // XXX bxe_idle_chk(sc);
17811             return (rc);
17812         }
17813     }
17814
17815     /* set MSI reconfigure capability */
17816     if (sc->devinfo.int_block == INT_BLOCK_HC) {
17817         addr = (port ? HC_REG_CONFIG_1 : HC_REG_CONFIG_0);
17818         val = REG_RD(sc, addr);
17819         val |= HC_CONFIG_0_REG_MSI_ATTN_EN_0;
17820         REG_WR(sc, addr, val);
17821     }
17822
17823     ecore_init_block(sc, BLOCK_PXP, init_phase);
17824     ecore_init_block(sc, BLOCK_PXP2, init_phase);
17825
17826     ilt = sc->ilt;
17827     cdu_ilt_start = ilt->clients[ILT_CLIENT_CDU].start;
17828
17829     for (i = 0; i < L2_ILT_LINES(sc); i++) {
17830         ilt->lines[cdu_ilt_start + i].page = sc->context[i].vcxt;
17831         ilt->lines[cdu_ilt_start + i].page_mapping =
17832             sc->context[i].vcxt_dma.paddr;
17833         ilt->lines[cdu_ilt_start + i].size = sc->context[i].size;
17834     }
17835     ecore_ilt_init_op(sc, INITOP_SET);
17836
17837     /* Set NIC mode */
17838     REG_WR(sc, PRS_REG_NIC_MODE, 1);
17839     BLOGD(sc, DBG_LOAD, "NIC MODE configured\n");
17840
17841     if (!CHIP_IS_E1x(sc)) {
17842         uint32_t pf_conf = IGU_PF_CONF_FUNC_EN;
17843
17844         /* Turn on a single ISR mode in IGU if driver is going to use
17845          * INT#x or MSI
17846          */
17847         if (sc->interrupt_mode != INTR_MODE_MSIX) {
17848             pf_conf |= IGU_PF_CONF_SINGLE_ISR_EN;
17849         }
17850
17851         /*
17852          * Timers workaround bug: function init part.
17853          * Need to wait 20msec after initializing ILT,
17854          * needed to make sure there are no requests in
17855          * one of the PXP internal queues with "old" ILT addresses
17856          */
17857         DELAY(20000);
17858
17859         /*
17860          * Master enable - Due to WB DMAE writes performed before this
17861          * register is re-initialized as part of the regular function
17862          * init
17863          */
17864         REG_WR(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER, 1);
17865         /* Enable the function in IGU */
17866         REG_WR(sc, IGU_REG_PF_CONFIGURATION, pf_conf);
17867     }
17868
17869     sc->dmae_ready = 1;
17870
17871     ecore_init_block(sc, BLOCK_PGLUE_B, init_phase);
17872
17873     if (!CHIP_IS_E1x(sc))
17874         REG_WR(sc, PGLUE_B_REG_WAS_ERROR_PF_7_0_CLR, func);
17875
17876     ecore_init_block(sc, BLOCK_ATC, init_phase);
17877     ecore_init_block(sc, BLOCK_DMAE, init_phase);
17878     ecore_init_block(sc, BLOCK_NIG, init_phase);
17879     ecore_init_block(sc, BLOCK_SRC, init_phase);
17880     ecore_init_block(sc, BLOCK_MISC, init_phase);
17881     ecore_init_block(sc, BLOCK_TCM, init_phase);
17882     ecore_init_block(sc, BLOCK_UCM, init_phase);
17883     ecore_init_block(sc, BLOCK_CCM, init_phase);
17884     ecore_init_block(sc, BLOCK_XCM, init_phase);
17885     ecore_init_block(sc, BLOCK_TSEM, init_phase);
17886     ecore_init_block(sc, BLOCK_USEM, init_phase);
17887     ecore_init_block(sc, BLOCK_CSEM, init_phase);
17888     ecore_init_block(sc, BLOCK_XSEM, init_phase);
17889
17890     if (!CHIP_IS_E1x(sc))
17891         REG_WR(sc, QM_REG_PF_EN, 1);
17892
17893     if (!CHIP_IS_E1x(sc)) {
17894         REG_WR(sc, TSEM_REG_VFPF_ERR_NUM, BXE_MAX_NUM_OF_VFS + func);
17895         REG_WR(sc, USEM_REG_VFPF_ERR_NUM, BXE_MAX_NUM_OF_VFS + func);
17896         REG_WR(sc, CSEM_REG_VFPF_ERR_NUM, BXE_MAX_NUM_OF_VFS + func);
17897         REG_WR(sc, XSEM_REG_VFPF_ERR_NUM, BXE_MAX_NUM_OF_VFS + func);
17898     }
17899     ecore_init_block(sc, BLOCK_QM, init_phase);
17900
17901     ecore_init_block(sc, BLOCK_TM, init_phase);
17902     ecore_init_block(sc, BLOCK_DORQ, init_phase);
17903
17904     bxe_iov_init_dq(sc);
17905
17906     ecore_init_block(sc, BLOCK_BRB1, init_phase);
17907     ecore_init_block(sc, BLOCK_PRS, init_phase);
17908     ecore_init_block(sc, BLOCK_TSDM, init_phase);
17909     ecore_init_block(sc, BLOCK_CSDM, init_phase);
17910     ecore_init_block(sc, BLOCK_USDM, init_phase);
17911     ecore_init_block(sc, BLOCK_XSDM, init_phase);
17912     ecore_init_block(sc, BLOCK_UPB, init_phase);
17913     ecore_init_block(sc, BLOCK_XPB, init_phase);
17914     ecore_init_block(sc, BLOCK_PBF, init_phase);
17915     if (!CHIP_IS_E1x(sc))
17916         REG_WR(sc, PBF_REG_DISABLE_PF, 0);
17917
17918     ecore_init_block(sc, BLOCK_CDU, init_phase);
17919
17920     ecore_init_block(sc, BLOCK_CFC, init_phase);
17921
17922     if (!CHIP_IS_E1x(sc))
17923         REG_WR(sc, CFC_REG_WEAK_ENABLE_PF, 1);
17924
17925     if (IS_MF(sc)) {
17926         REG_WR(sc, NIG_REG_LLH0_FUNC_EN + port*8, 1);
17927         REG_WR(sc, NIG_REG_LLH0_FUNC_VLAN_ID + port*8, OVLAN(sc));
17928     }
17929
17930     ecore_init_block(sc, BLOCK_MISC_AEU, init_phase);
17931
17932     /* HC init per function */
17933     if (sc->devinfo.int_block == INT_BLOCK_HC) {
17934         if (CHIP_IS_E1H(sc)) {
17935             REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
17936
17937             REG_WR(sc, HC_REG_LEADING_EDGE_0 + port*8, 0);
17938             REG_WR(sc, HC_REG_TRAILING_EDGE_0 + port*8, 0);
17939         }
17940         ecore_init_block(sc, BLOCK_HC, init_phase);
17941
17942     } else {
17943         int num_segs, sb_idx, prod_offset;
17944
17945         REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_12 + func*4, 0);
17946
17947         if (!CHIP_IS_E1x(sc)) {
17948             REG_WR(sc, IGU_REG_LEADING_EDGE_LATCH, 0);
17949             REG_WR(sc, IGU_REG_TRAILING_EDGE_LATCH, 0);
17950         }
17951
17952         ecore_init_block(sc, BLOCK_IGU, init_phase);
17953
17954         if (!CHIP_IS_E1x(sc)) {
17955             int dsb_idx = 0;
17956             /**
17957              * Producer memory:
17958              * E2 mode: address 0-135 match to the mapping memory;
17959              * 136 - PF0 default prod; 137 - PF1 default prod;
17960              * 138 - PF2 default prod; 139 - PF3 default prod;
17961              * 140 - PF0 attn prod;    141 - PF1 attn prod;
17962              * 142 - PF2 attn prod;    143 - PF3 attn prod;
17963              * 144-147 reserved.
17964              *
17965              * E1.5 mode - In backward compatible mode;
17966              * for non default SB; each even line in the memory
17967              * holds the U producer and each odd line hold
17968              * the C producer. The first 128 producers are for
17969              * NDSB (PF0 - 0-31; PF1 - 32-63 and so on). The last 20
17970              * producers are for the DSB for each PF.
17971              * Each PF has five segments: (the order inside each
17972              * segment is PF0; PF1; PF2; PF3) - 128-131 U prods;
17973              * 132-135 C prods; 136-139 X prods; 140-143 T prods;
17974              * 144-147 attn prods;
17975              */
17976             /* non-default-status-blocks */
17977             num_segs = CHIP_INT_MODE_IS_BC(sc) ?
17978                 IGU_BC_NDSB_NUM_SEGS : IGU_NORM_NDSB_NUM_SEGS;
17979             for (sb_idx = 0; sb_idx < sc->igu_sb_cnt; sb_idx++) {
17980                 prod_offset = (sc->igu_base_sb + sb_idx) *
17981                     num_segs;
17982
17983                 for (i = 0; i < num_segs; i++) {
17984                     addr = IGU_REG_PROD_CONS_MEMORY +
17985                             (prod_offset + i) * 4;
17986                     REG_WR(sc, addr, 0);
17987                 }
17988                 /* send consumer update with value 0 */
17989                 bxe_ack_sb(sc, sc->igu_base_sb + sb_idx,
17990                            USTORM_ID, 0, IGU_INT_NOP, 1);
17991                 bxe_igu_clear_sb(sc, sc->igu_base_sb + sb_idx);
17992             }
17993
17994             /* default-status-blocks */
17995             num_segs = CHIP_INT_MODE_IS_BC(sc) ?
17996                 IGU_BC_DSB_NUM_SEGS : IGU_NORM_DSB_NUM_SEGS;
17997
17998             if (CHIP_IS_MODE_4_PORT(sc))
17999                 dsb_idx = SC_FUNC(sc);
18000             else
18001                 dsb_idx = SC_VN(sc);
18002
18003             prod_offset = (CHIP_INT_MODE_IS_BC(sc) ?
18004                        IGU_BC_BASE_DSB_PROD + dsb_idx :
18005                        IGU_NORM_BASE_DSB_PROD + dsb_idx);
18006
18007             /*
18008              * igu prods come in chunks of E1HVN_MAX (4) -
18009              * does not matters what is the current chip mode
18010              */
18011             for (i = 0; i < (num_segs * E1HVN_MAX);
18012                  i += E1HVN_MAX) {
18013                 addr = IGU_REG_PROD_CONS_MEMORY +
18014                             (prod_offset + i)*4;
18015                 REG_WR(sc, addr, 0);
18016             }
18017             /* send consumer update with 0 */
18018             if (CHIP_INT_MODE_IS_BC(sc)) {
18019                 bxe_ack_sb(sc, sc->igu_dsb_id,
18020                            USTORM_ID, 0, IGU_INT_NOP, 1);
18021                 bxe_ack_sb(sc, sc->igu_dsb_id,
18022                            CSTORM_ID, 0, IGU_INT_NOP, 1);
18023                 bxe_ack_sb(sc, sc->igu_dsb_id,
18024                            XSTORM_ID, 0, IGU_INT_NOP, 1);
18025                 bxe_ack_sb(sc, sc->igu_dsb_id,
18026                            TSTORM_ID, 0, IGU_INT_NOP, 1);
18027                 bxe_ack_sb(sc, sc->igu_dsb_id,
18028                            ATTENTION_ID, 0, IGU_INT_NOP, 1);
18029             } else {
18030                 bxe_ack_sb(sc, sc->igu_dsb_id,
18031                            USTORM_ID, 0, IGU_INT_NOP, 1);
18032                 bxe_ack_sb(sc, sc->igu_dsb_id,
18033                            ATTENTION_ID, 0, IGU_INT_NOP, 1);
18034             }
18035             bxe_igu_clear_sb(sc, sc->igu_dsb_id);
18036
18037             /* !!! these should become driver const once
18038                rf-tool supports split-68 const */
18039             REG_WR(sc, IGU_REG_SB_INT_BEFORE_MASK_LSB, 0);
18040             REG_WR(sc, IGU_REG_SB_INT_BEFORE_MASK_MSB, 0);
18041             REG_WR(sc, IGU_REG_SB_MASK_LSB, 0);
18042             REG_WR(sc, IGU_REG_SB_MASK_MSB, 0);
18043             REG_WR(sc, IGU_REG_PBA_STATUS_LSB, 0);
18044             REG_WR(sc, IGU_REG_PBA_STATUS_MSB, 0);
18045         }
18046     }
18047
18048     /* Reset PCIE errors for debug */
18049     REG_WR(sc, 0x2114, 0xffffffff);
18050     REG_WR(sc, 0x2120, 0xffffffff);
18051
18052     if (CHIP_IS_E1x(sc)) {
18053         main_mem_size = HC_REG_MAIN_MEMORY_SIZE / 2; /*dwords*/
18054         main_mem_base = HC_REG_MAIN_MEMORY +
18055                 SC_PORT(sc) * (main_mem_size * 4);
18056         main_mem_prty_clr = HC_REG_HC_PRTY_STS_CLR;
18057         main_mem_width = 8;
18058
18059         val = REG_RD(sc, main_mem_prty_clr);
18060         if (val) {
18061             BLOGD(sc, DBG_LOAD,
18062                   "Parity errors in HC block during function init (0x%x)!\n",
18063                   val);
18064         }
18065
18066         /* Clear "false" parity errors in MSI-X table */
18067         for (i = main_mem_base;
18068              i < main_mem_base + main_mem_size * 4;
18069              i += main_mem_width) {
18070             bxe_read_dmae(sc, i, main_mem_width / 4);
18071             bxe_write_dmae(sc, BXE_SP_MAPPING(sc, wb_data),
18072                            i, main_mem_width / 4);
18073         }
18074         /* Clear HC parity attention */
18075         REG_RD(sc, main_mem_prty_clr);
18076     }
18077
18078 #if 1
18079     /* Enable STORMs SP logging */
18080     REG_WR8(sc, BAR_USTRORM_INTMEM +
18081            USTORM_RECORD_SLOW_PATH_OFFSET(SC_FUNC(sc)), 1);
18082     REG_WR8(sc, BAR_TSTRORM_INTMEM +
18083            TSTORM_RECORD_SLOW_PATH_OFFSET(SC_FUNC(sc)), 1);
18084     REG_WR8(sc, BAR_CSTRORM_INTMEM +
18085            CSTORM_RECORD_SLOW_PATH_OFFSET(SC_FUNC(sc)), 1);
18086     REG_WR8(sc, BAR_XSTRORM_INTMEM +
18087            XSTORM_RECORD_SLOW_PATH_OFFSET(SC_FUNC(sc)), 1);
18088 #endif
18089
18090     elink_phy_probe(&sc->link_params);
18091
18092     return (0);
18093 }
18094
18095 static void
18096 bxe_link_reset(struct bxe_softc *sc)
18097 {
18098     if (!BXE_NOMCP(sc)) {
18099         bxe_acquire_phy_lock(sc);
18100         elink_lfa_reset(&sc->link_params, &sc->link_vars);
18101         bxe_release_phy_lock(sc);
18102     } else {
18103         if (!CHIP_REV_IS_SLOW(sc)) {
18104             BLOGW(sc, "Bootcode is missing - cannot reset link\n");
18105         }
18106     }
18107 }
18108
18109 static void
18110 bxe_reset_port(struct bxe_softc *sc)
18111 {
18112     int port = SC_PORT(sc);
18113     uint32_t val;
18114
18115     /* reset physical Link */
18116     bxe_link_reset(sc);
18117
18118     REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port*4, 0);
18119
18120     /* Do not rcv packets to BRB */
18121     REG_WR(sc, NIG_REG_LLH0_BRB1_DRV_MASK + port*4, 0x0);
18122     /* Do not direct rcv packets that are not for MCP to the BRB */
18123     REG_WR(sc, (port ? NIG_REG_LLH1_BRB1_NOT_MCP :
18124                NIG_REG_LLH0_BRB1_NOT_MCP), 0x0);
18125
18126     /* Configure AEU */
18127     REG_WR(sc, MISC_REG_AEU_MASK_ATTN_FUNC_0 + port*4, 0);
18128
18129     DELAY(100000);
18130
18131     /* Check for BRB port occupancy */
18132     val = REG_RD(sc, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port*4);
18133     if (val) {
18134         BLOGD(sc, DBG_LOAD,
18135               "BRB1 is not empty, %d blocks are occupied\n", val);
18136     }
18137
18138     /* TODO: Close Doorbell port? */
18139 }
18140
18141 static void
18142 bxe_ilt_wr(struct bxe_softc *sc,
18143            uint32_t         index,
18144            bus_addr_t       addr)
18145 {
18146     int reg;
18147     uint32_t wb_write[2];
18148
18149     if (CHIP_IS_E1(sc)) {
18150         reg = PXP2_REG_RQ_ONCHIP_AT + index*8;
18151     } else {
18152         reg = PXP2_REG_RQ_ONCHIP_AT_B0 + index*8;
18153     }
18154
18155     wb_write[0] = ONCHIP_ADDR1(addr);
18156     wb_write[1] = ONCHIP_ADDR2(addr);
18157     REG_WR_DMAE(sc, reg, wb_write, 2);
18158 }
18159
18160 static void
18161 bxe_clear_func_ilt(struct bxe_softc *sc,
18162                    uint32_t         func)
18163 {
18164     uint32_t i, base = FUNC_ILT_BASE(func);
18165     for (i = base; i < base + ILT_PER_FUNC; i++) {
18166         bxe_ilt_wr(sc, i, 0);
18167     }
18168 }
18169
18170 static void
18171 bxe_reset_func(struct bxe_softc *sc)
18172 {
18173     struct bxe_fastpath *fp;
18174     int port = SC_PORT(sc);
18175     int func = SC_FUNC(sc);
18176     int i;
18177
18178     /* Disable the function in the FW */
18179     REG_WR8(sc, BAR_XSTRORM_INTMEM + XSTORM_FUNC_EN_OFFSET(func), 0);
18180     REG_WR8(sc, BAR_CSTRORM_INTMEM + CSTORM_FUNC_EN_OFFSET(func), 0);
18181     REG_WR8(sc, BAR_TSTRORM_INTMEM + TSTORM_FUNC_EN_OFFSET(func), 0);
18182     REG_WR8(sc, BAR_USTRORM_INTMEM + USTORM_FUNC_EN_OFFSET(func), 0);
18183
18184     /* FP SBs */
18185     FOR_EACH_ETH_QUEUE(sc, i) {
18186         fp = &sc->fp[i];
18187         REG_WR8(sc, BAR_CSTRORM_INTMEM +
18188                 CSTORM_STATUS_BLOCK_DATA_STATE_OFFSET(fp->fw_sb_id),
18189                 SB_DISABLED);
18190     }
18191
18192     /* SP SB */
18193     REG_WR8(sc, BAR_CSTRORM_INTMEM +
18194             CSTORM_SP_STATUS_BLOCK_DATA_STATE_OFFSET(func),
18195             SB_DISABLED);
18196
18197     for (i = 0; i < XSTORM_SPQ_DATA_SIZE / 4; i++) {
18198         REG_WR(sc, BAR_XSTRORM_INTMEM + XSTORM_SPQ_DATA_OFFSET(func), 0);
18199     }
18200
18201     /* Configure IGU */
18202     if (sc->devinfo.int_block == INT_BLOCK_HC) {
18203         REG_WR(sc, HC_REG_LEADING_EDGE_0 + port*8, 0);
18204         REG_WR(sc, HC_REG_TRAILING_EDGE_0 + port*8, 0);
18205     } else {
18206         REG_WR(sc, IGU_REG_LEADING_EDGE_LATCH, 0);
18207         REG_WR(sc, IGU_REG_TRAILING_EDGE_LATCH, 0);
18208     }
18209
18210     if (CNIC_LOADED(sc)) {
18211         /* Disable Timer scan */
18212         REG_WR(sc, TM_REG_EN_LINEAR0_TIMER + port*4, 0);
18213         /*
18214          * Wait for at least 10ms and up to 2 second for the timers
18215          * scan to complete
18216          */
18217         for (i = 0; i < 200; i++) {
18218             DELAY(10000);
18219             if (!REG_RD(sc, TM_REG_LIN0_SCAN_ON + port*4))
18220                 break;
18221         }
18222     }
18223
18224     /* Clear ILT */
18225     bxe_clear_func_ilt(sc, func);
18226
18227     /*
18228      * Timers workaround bug for E2: if this is vnic-3,
18229      * we need to set the entire ilt range for this timers.
18230      */
18231     if (!CHIP_IS_E1x(sc) && SC_VN(sc) == 3) {
18232         struct ilt_client_info ilt_cli;
18233         /* use dummy TM client */
18234         memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
18235         ilt_cli.start = 0;
18236         ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
18237         ilt_cli.client_num = ILT_CLIENT_TM;
18238
18239         ecore_ilt_boundry_init_op(sc, &ilt_cli, 0, INITOP_CLEAR);
18240     }
18241
18242     /* this assumes that reset_port() called before reset_func()*/
18243     if (!CHIP_IS_E1x(sc)) {
18244         bxe_pf_disable(sc);
18245     }
18246
18247     sc->dmae_ready = 0;
18248 }
18249
18250 static int
18251 bxe_gunzip_init(struct bxe_softc *sc)
18252 {
18253     return (0);
18254 }
18255
18256 static void
18257 bxe_gunzip_end(struct bxe_softc *sc)
18258 {
18259     return;
18260 }
18261
18262 static int
18263 bxe_init_firmware(struct bxe_softc *sc)
18264 {
18265     if (CHIP_IS_E1(sc)) {
18266         ecore_init_e1_firmware(sc);
18267         sc->iro_array = e1_iro_arr;
18268     } else if (CHIP_IS_E1H(sc)) {
18269         ecore_init_e1h_firmware(sc);
18270         sc->iro_array = e1h_iro_arr;
18271     } else if (!CHIP_IS_E1x(sc)) {
18272         ecore_init_e2_firmware(sc);
18273         sc->iro_array = e2_iro_arr;
18274     } else {
18275         BLOGE(sc, "Unsupported chip revision\n");
18276         return (-1);
18277     }
18278
18279     return (0);
18280 }
18281
18282 static void
18283 bxe_release_firmware(struct bxe_softc *sc)
18284 {
18285     /* Do nothing */
18286     return;
18287 }
18288
18289 static int
18290 ecore_gunzip(struct bxe_softc *sc,
18291              const uint8_t    *zbuf,
18292              int              len)
18293 {
18294     /* XXX : Implement... */
18295     BLOGD(sc, DBG_LOAD, "ECORE_GUNZIP NOT IMPLEMENTED\n");
18296     return (FALSE);
18297 }
18298
18299 static void
18300 ecore_reg_wr_ind(struct bxe_softc *sc,
18301                  uint32_t         addr,
18302                  uint32_t         val)
18303 {
18304     bxe_reg_wr_ind(sc, addr, val);
18305 }
18306
18307 static void
18308 ecore_write_dmae_phys_len(struct bxe_softc *sc,
18309                           bus_addr_t       phys_addr,
18310                           uint32_t         addr,
18311                           uint32_t         len)
18312 {
18313     bxe_write_dmae_phys_len(sc, phys_addr, addr, len);
18314 }
18315
18316 void
18317 ecore_storm_memset_struct(struct bxe_softc *sc,
18318                           uint32_t         addr,
18319                           size_t           size,
18320                           uint32_t         *data)
18321 {
18322     uint8_t i;
18323     for (i = 0; i < size/4; i++) {
18324         REG_WR(sc, addr + (i * 4), data[i]);
18325     }
18326 }
18327
18328
18329 /*
18330  * character device - ioctl interface definitions
18331  */
18332
18333
18334 #include "bxe_dump.h"
18335 #include "bxe_ioctl.h"
18336 #include <sys/conf.h>
18337
18338 static int bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
18339                 struct thread *td);
18340
18341 static struct cdevsw bxe_cdevsw = {
18342     .d_version = D_VERSION,
18343     .d_ioctl = bxe_eioctl,
18344     .d_name = "bxecnic",
18345 };
18346
18347 #define BXE_PATH(sc)    (CHIP_IS_E1x(sc) ? 0 : (sc->pcie_func & 1))
18348
18349
18350 #define DUMP_ALL_PRESETS        0x1FFF
18351 #define DUMP_MAX_PRESETS        13
18352 #define IS_E1_REG(chips)        ((chips & DUMP_CHIP_E1) == DUMP_CHIP_E1)
18353 #define IS_E1H_REG(chips)       ((chips & DUMP_CHIP_E1H) == DUMP_CHIP_E1H)
18354 #define IS_E2_REG(chips)        ((chips & DUMP_CHIP_E2) == DUMP_CHIP_E2)
18355 #define IS_E3A0_REG(chips)      ((chips & DUMP_CHIP_E3A0) == DUMP_CHIP_E3A0)
18356 #define IS_E3B0_REG(chips)      ((chips & DUMP_CHIP_E3B0) == DUMP_CHIP_E3B0)
18357
18358 #define IS_REG_IN_PRESET(presets, idx)  \
18359                 ((presets & (1 << (idx-1))) == (1 << (idx-1)))
18360
18361
18362 static int
18363 bxe_get_preset_regs_len(struct bxe_softc *sc, uint32_t preset)
18364 {
18365     if (CHIP_IS_E1(sc))
18366         return dump_num_registers[0][preset-1];
18367     else if (CHIP_IS_E1H(sc))
18368         return dump_num_registers[1][preset-1];
18369     else if (CHIP_IS_E2(sc))
18370         return dump_num_registers[2][preset-1];
18371     else if (CHIP_IS_E3A0(sc))
18372         return dump_num_registers[3][preset-1];
18373     else if (CHIP_IS_E3B0(sc))
18374         return dump_num_registers[4][preset-1];
18375     else
18376         return 0;
18377 }
18378
18379 static int
18380 bxe_get_total_regs_len32(struct bxe_softc *sc)
18381 {
18382     uint32_t preset_idx;
18383     int regdump_len32 = 0;
18384
18385
18386     /* Calculate the total preset regs length */
18387     for (preset_idx = 1; preset_idx <= DUMP_MAX_PRESETS; preset_idx++) {
18388         regdump_len32 += bxe_get_preset_regs_len(sc, preset_idx);
18389     }
18390
18391     return regdump_len32;
18392 }
18393
18394 static const uint32_t *
18395 __bxe_get_page_addr_ar(struct bxe_softc *sc)
18396 {
18397     if (CHIP_IS_E2(sc))
18398         return page_vals_e2;
18399     else if (CHIP_IS_E3(sc))
18400         return page_vals_e3;
18401     else
18402         return NULL;
18403 }
18404
18405 static uint32_t
18406 __bxe_get_page_reg_num(struct bxe_softc *sc)
18407 {
18408     if (CHIP_IS_E2(sc))
18409         return PAGE_MODE_VALUES_E2;
18410     else if (CHIP_IS_E3(sc))
18411         return PAGE_MODE_VALUES_E3;
18412     else
18413         return 0;
18414 }
18415
18416 static const uint32_t *
18417 __bxe_get_page_write_ar(struct bxe_softc *sc)
18418 {
18419     if (CHIP_IS_E2(sc))
18420         return page_write_regs_e2;
18421     else if (CHIP_IS_E3(sc))
18422         return page_write_regs_e3;
18423     else
18424         return NULL;
18425 }
18426
18427 static uint32_t
18428 __bxe_get_page_write_num(struct bxe_softc *sc)
18429 {
18430     if (CHIP_IS_E2(sc))
18431         return PAGE_WRITE_REGS_E2;
18432     else if (CHIP_IS_E3(sc))
18433         return PAGE_WRITE_REGS_E3;
18434     else
18435         return 0;
18436 }
18437
18438 static const struct reg_addr *
18439 __bxe_get_page_read_ar(struct bxe_softc *sc)
18440 {
18441     if (CHIP_IS_E2(sc))
18442         return page_read_regs_e2;
18443     else if (CHIP_IS_E3(sc))
18444         return page_read_regs_e3;
18445     else
18446         return NULL;
18447 }
18448
18449 static uint32_t
18450 __bxe_get_page_read_num(struct bxe_softc *sc)
18451 {
18452     if (CHIP_IS_E2(sc))
18453         return PAGE_READ_REGS_E2;
18454     else if (CHIP_IS_E3(sc))
18455         return PAGE_READ_REGS_E3;
18456     else
18457         return 0;
18458 }
18459
18460 static bool
18461 bxe_is_reg_in_chip(struct bxe_softc *sc, const struct reg_addr *reg_info)
18462 {
18463     if (CHIP_IS_E1(sc))
18464         return IS_E1_REG(reg_info->chips);
18465     else if (CHIP_IS_E1H(sc))
18466         return IS_E1H_REG(reg_info->chips);
18467     else if (CHIP_IS_E2(sc))
18468         return IS_E2_REG(reg_info->chips);
18469     else if (CHIP_IS_E3A0(sc))
18470         return IS_E3A0_REG(reg_info->chips);
18471     else if (CHIP_IS_E3B0(sc))
18472         return IS_E3B0_REG(reg_info->chips);
18473     else
18474         return 0;
18475 }
18476
18477 static bool
18478 bxe_is_wreg_in_chip(struct bxe_softc *sc, const struct wreg_addr *wreg_info)
18479 {
18480     if (CHIP_IS_E1(sc))
18481         return IS_E1_REG(wreg_info->chips);
18482     else if (CHIP_IS_E1H(sc))
18483         return IS_E1H_REG(wreg_info->chips);
18484     else if (CHIP_IS_E2(sc))
18485         return IS_E2_REG(wreg_info->chips);
18486     else if (CHIP_IS_E3A0(sc))
18487         return IS_E3A0_REG(wreg_info->chips);
18488     else if (CHIP_IS_E3B0(sc))
18489         return IS_E3B0_REG(wreg_info->chips);
18490     else
18491         return 0;
18492 }
18493
18494 /**
18495  * bxe_read_pages_regs - read "paged" registers
18496  *
18497  * @bp          device handle
18498  * @p           output buffer
18499  *
18500  * Reads "paged" memories: memories that may only be read by first writing to a
18501  * specific address ("write address") and then reading from a specific address
18502  * ("read address"). There may be more than one write address per "page" and
18503  * more than one read address per write address.
18504  */
18505 static void
18506 bxe_read_pages_regs(struct bxe_softc *sc, uint32_t *p, uint32_t preset)
18507 {
18508     uint32_t i, j, k, n;
18509
18510     /* addresses of the paged registers */
18511     const uint32_t *page_addr = __bxe_get_page_addr_ar(sc);
18512     /* number of paged registers */
18513     int num_pages = __bxe_get_page_reg_num(sc);
18514     /* write addresses */
18515     const uint32_t *write_addr = __bxe_get_page_write_ar(sc);
18516     /* number of write addresses */
18517     int write_num = __bxe_get_page_write_num(sc);
18518     /* read addresses info */
18519     const struct reg_addr *read_addr = __bxe_get_page_read_ar(sc);
18520     /* number of read addresses */
18521     int read_num = __bxe_get_page_read_num(sc);
18522     uint32_t addr, size;
18523
18524     for (i = 0; i < num_pages; i++) {
18525         for (j = 0; j < write_num; j++) {
18526             REG_WR(sc, write_addr[j], page_addr[i]);
18527
18528             for (k = 0; k < read_num; k++) {
18529                 if (IS_REG_IN_PRESET(read_addr[k].presets, preset)) {
18530                     size = read_addr[k].size;
18531                     for (n = 0; n < size; n++) {
18532                         addr = read_addr[k].addr + n*4;
18533                         *p++ = REG_RD(sc, addr);
18534                     }
18535                 }
18536             }
18537         }
18538     }
18539     return;
18540 }
18541
18542
18543 static int
18544 bxe_get_preset_regs(struct bxe_softc *sc, uint32_t *p, uint32_t preset)
18545 {
18546     uint32_t i, j, addr;
18547     const struct wreg_addr *wreg_addr_p = NULL;
18548
18549     if (CHIP_IS_E1(sc))
18550         wreg_addr_p = &wreg_addr_e1;
18551     else if (CHIP_IS_E1H(sc))
18552         wreg_addr_p = &wreg_addr_e1h;
18553     else if (CHIP_IS_E2(sc))
18554         wreg_addr_p = &wreg_addr_e2;
18555     else if (CHIP_IS_E3A0(sc))
18556         wreg_addr_p = &wreg_addr_e3;
18557     else if (CHIP_IS_E3B0(sc))
18558         wreg_addr_p = &wreg_addr_e3b0;
18559     else
18560         return (-1);
18561
18562     /* Read the idle_chk registers */
18563     for (i = 0; i < IDLE_REGS_COUNT; i++) {
18564         if (bxe_is_reg_in_chip(sc, &idle_reg_addrs[i]) &&
18565             IS_REG_IN_PRESET(idle_reg_addrs[i].presets, preset)) {
18566             for (j = 0; j < idle_reg_addrs[i].size; j++)
18567                 *p++ = REG_RD(sc, idle_reg_addrs[i].addr + j*4);
18568         }
18569     }
18570
18571     /* Read the regular registers */
18572     for (i = 0; i < REGS_COUNT; i++) {
18573         if (bxe_is_reg_in_chip(sc, &reg_addrs[i]) &&
18574             IS_REG_IN_PRESET(reg_addrs[i].presets, preset)) {
18575             for (j = 0; j < reg_addrs[i].size; j++)
18576                 *p++ = REG_RD(sc, reg_addrs[i].addr + j*4);
18577         }
18578     }
18579
18580     /* Read the CAM registers */
18581     if (bxe_is_wreg_in_chip(sc, wreg_addr_p) &&
18582         IS_REG_IN_PRESET(wreg_addr_p->presets, preset)) {
18583         for (i = 0; i < wreg_addr_p->size; i++) {
18584             *p++ = REG_RD(sc, wreg_addr_p->addr + i*4);
18585
18586             /* In case of wreg_addr register, read additional
18587                registers from read_regs array
18588              */
18589             for (j = 0; j < wreg_addr_p->read_regs_count; j++) {
18590                 addr = *(wreg_addr_p->read_regs);
18591                 *p++ = REG_RD(sc, addr + j*4);
18592             }
18593         }
18594     }
18595
18596     /* Paged registers are supported in E2 & E3 only */
18597     if (CHIP_IS_E2(sc) || CHIP_IS_E3(sc)) {
18598         /* Read "paged" registers */
18599         bxe_read_pages_regs(sc, p, preset);
18600     }
18601
18602     return 0;
18603 }
18604
18605 static int
18606 bxe_grc_dump(struct bxe_softc *sc)
18607 {
18608     int rval = 0;
18609     uint32_t preset_idx;
18610     uint8_t *buf;
18611     uint32_t size;
18612     struct  dump_header *d_hdr;
18613
18614     if (sc->grcdump_done)
18615         return (rval);
18616
18617     ecore_disable_blocks_parity(sc);
18618
18619     buf = sc->grc_dump;
18620     d_hdr = sc->grc_dump;
18621
18622     d_hdr->header_size = (sizeof(struct  dump_header) >> 2) - 1;
18623     d_hdr->version = BNX2X_DUMP_VERSION;
18624     d_hdr->preset = DUMP_ALL_PRESETS;
18625
18626     if (CHIP_IS_E1(sc)) {
18627         d_hdr->dump_meta_data = DUMP_CHIP_E1;
18628     } else if (CHIP_IS_E1H(sc)) {
18629         d_hdr->dump_meta_data = DUMP_CHIP_E1H;
18630     } else if (CHIP_IS_E2(sc)) {
18631         d_hdr->dump_meta_data = DUMP_CHIP_E2 |
18632                 (BXE_PATH(sc) ? DUMP_PATH_1 : DUMP_PATH_0);
18633     } else if (CHIP_IS_E3A0(sc)) {
18634         d_hdr->dump_meta_data = DUMP_CHIP_E3A0 |
18635                 (BXE_PATH(sc) ? DUMP_PATH_1 : DUMP_PATH_0);
18636     } else if (CHIP_IS_E3B0(sc)) {
18637         d_hdr->dump_meta_data = DUMP_CHIP_E3B0 |
18638                 (BXE_PATH(sc) ? DUMP_PATH_1 : DUMP_PATH_0);
18639     }
18640
18641     buf += sizeof(struct  dump_header);
18642
18643     for (preset_idx = 1; preset_idx <= DUMP_MAX_PRESETS; preset_idx++) {
18644
18645         /* Skip presets with IOR */
18646         if ((preset_idx == 2) || (preset_idx == 5) || (preset_idx == 8) ||
18647             (preset_idx == 11))
18648             continue;
18649
18650         rval = bxe_get_preset_regs(sc, sc->grc_dump, preset_idx);
18651
18652         if (rval)
18653             break;
18654
18655         size = bxe_get_preset_regs_len(sc, preset_idx) * (sizeof (uint32_t));
18656
18657         buf += size;
18658     }
18659
18660     ecore_clear_blocks_parity(sc);
18661     ecore_enable_blocks_parity(sc);
18662
18663     sc->grcdump_done = 1;
18664     return(rval);
18665 }
18666
18667 static int
18668 bxe_add_cdev(struct bxe_softc *sc)
18669 {
18670     int grc_dump_size;
18671
18672     grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) +
18673                                 sizeof(struct  dump_header);
18674
18675     sc->grc_dump = malloc(grc_dump_size, M_DEVBUF, M_NOWAIT);
18676
18677     if (sc->grc_dump == NULL)
18678         return (-1);
18679
18680     sc->ioctl_dev = make_dev(&bxe_cdevsw,
18681                             sc->ifnet->if_dunit,
18682                             UID_ROOT,
18683                             GID_WHEEL,
18684                             0600,
18685                             "%s",
18686                             if_name(sc->ifnet));
18687
18688     if (sc->ioctl_dev == NULL) {
18689
18690         free(sc->grc_dump, M_DEVBUF);
18691
18692         return (-1);
18693     }
18694
18695     sc->ioctl_dev->si_drv1 = sc;
18696
18697     return (0);
18698 }
18699
18700 static void
18701 bxe_del_cdev(struct bxe_softc *sc)
18702 {
18703     if (sc->ioctl_dev != NULL)
18704         destroy_dev(sc->ioctl_dev);
18705
18706     if (sc->grc_dump == NULL)
18707         free(sc->grc_dump, M_DEVBUF);
18708
18709     return;
18710 }
18711
18712 static int
18713 bxe_eioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag,
18714         struct thread *td)
18715 {
18716     struct bxe_softc    *sc;
18717     int                 rval = 0;
18718     device_t            pci_dev;
18719     bxe_grcdump_t       *dump = NULL;
18720     int grc_dump_size;
18721
18722     if ((sc = (struct bxe_softc *)dev->si_drv1) == NULL)
18723         return ENXIO;
18724
18725     pci_dev= sc->dev;
18726
18727     dump = (bxe_grcdump_t *)data;
18728
18729     switch(cmd) {
18730
18731         case BXE_GRC_DUMP_SIZE:
18732             dump->pci_func = sc->pcie_func;
18733             dump->grcdump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) +
18734                                         sizeof(struct  dump_header);
18735             break;
18736
18737         case BXE_GRC_DUMP:
18738
18739             grc_dump_size = (bxe_get_total_regs_len32(sc) * sizeof(uint32_t)) +
18740                                 sizeof(struct  dump_header);
18741
18742             if ((sc->grc_dump == NULL) || (dump->grcdump == NULL) ||
18743                 (dump->grcdump_size < grc_dump_size) || (!sc->grcdump_done)) {
18744                 rval = EINVAL;
18745                 break;
18746             }
18747             dump->grcdump_dwords = grc_dump_size >> 2;
18748             rval = copyout(sc->grc_dump, dump->grcdump, grc_dump_size);
18749             sc->grcdump_done = 0;
18750
18751             break;
18752
18753         default:
18754             break;
18755     }
18756
18757     return (rval);
18758 }