broadcom netxtreme-c/e driver

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

broadcom netxtreme-c/e driver

Jonathan Matthew-4
This started out as a port of freebsd's bnxt driver, but along the way I
had to rewrite the interesting bits.

NetXtreme-C/E (BCM573xx and BCM574xx) is a different line of chips to
NetXtreme II 10G (BCM577xx, which mje was working on), and luckily for me it's
much easier to talk to.  The reason these ones are interesting to me is that
they're the only 10G mezzanine option for Dell's Epyc based servers.

I've got it to the point where I could commit to cvs over it, so I'd like to
get it into the tree.  Lots of stuff is still missing - media types, multicast,
jumbos, any of the vast array of offloads, and it's not particularly fast yet,
only slightly over a gigabit in iperf/tcpbench type tests.  Lots of work to do
still.

The current code is below, only I'm not including bnxtreg.h as it's fairly
large (>30k lines) and it came unmodified from freebsd:
https://svnweb.freebsd.org/base/head/sys/dev/bnxt/hsi_struct_def.h?revision=323233&view=markup

ok?


/* $OpenBSD$ */
/*-
 * Broadcom NetXtreme-C/E network driver.
 *
 * Copyright (c) 2016 Broadcom, All Rights Reserved.
 * The term Broadcom refers to Broadcom Limited and/or its subsidiaries
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Copyright (c) 2018 Jonathan Matthew <[hidden email]>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */


#include "bpfilter.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/stdint.h>
#include <sys/sockio.h>
#include <sys/atomic.h>

#include <machine/bus.h>

#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcidevs.h>

#define __FBSDID(x)
#include <dev/pci/bnxtreg.h>

#include <net/if.h>
#include <net/if_media.h>

#if NBPFILTER > 0
#include <net/bpf.h>
#endif

#include <netinet/in.h>
#include <netinet/if_ether.h>

#define BNXT_HWRM_BAR 0x10
#define BNXT_DOORBELL_BAR 0x18

#define BNXT_RX_RING_ID 0
#define BNXT_AG_RING_ID 1
#define BNXT_TX_RING_ID 3

#define BNXT_MAX_QUEUE 8
#define BNXT_MAX_MTU 9000

#define BNXT_MAX_TX_SEGS 32 /* a bit much? */

#define BNXT_HWRM_SHORT_REQ_LEN sizeof(struct hwrm_short_input)

#define BNXT_HWRM_LOCK_INIT(_sc, _name) \
        mtx_init_flags(&sc->sc_lock, IPL_NET, _name, 0)
#define BNXT_HWRM_LOCK(_sc) mtx_enter(&_sc->sc_lock)
#define BNXT_HWRM_UNLOCK(_sc) mtx_leave(&_sc->sc_lock)
#define BNXT_HWRM_LOCK_DESTROY(_sc) /* nothing */
#define BNXT_HWRM_LOCK_ASSERT(_sc) MUTEX_ASSERT_LOCKED(&_sc->sc_lock)

#define BNXT_FLAG_VF            0x0001
#define BNXT_FLAG_NPAR          0x0002
#define BNXT_FLAG_WOL_CAP       0x0004
#define BNXT_FLAG_SHORT_CMD     0x0008

#define NEXT_CP_CONS_V(_ring, _cons, _v_bit) \
do { \
        if (++(_cons) == (_ring)->ring_size) \
                ((_cons) = 0, (_v_bit) = !_v_bit); \
} while (0);

struct bnxt_cos_queue {
        uint8_t id;
        uint8_t profile;
};

struct bnxt_ring {
        uint64_t paddr;
        uint64_t doorbell;
        caddr_t vaddr;
        uint32_t ring_size;
        uint16_t id;
        uint16_t phys_id;
        struct bnxt_full_tpa_start *tpa_start;
};

struct bnxt_cp_ring {
        struct bnxt_ring ring;
        void *irq;
        struct bnxt_softc *softc;
        uint32_t cons;
        int v_bit;
        struct ctx_hw_stats *stats;
        uint32_t stats_ctx_id;
        uint32_t last_idx;
};

struct bnxt_grp_info {
        uint32_t grp_id;
        uint16_t stats_ctx;
        uint16_t rx_ring_id;
        uint16_t cp_ring_id;
        uint16_t ag_ring_id;
};

struct bnxt_vnic_info {
        uint16_t id;
        uint16_t def_ring_grp;
        uint16_t cos_rule;
        uint16_t lb_rule;
        uint16_t mru;

        uint32_t rx_mask;
        /* multicast things */

        uint32_t flags;
#define BNXT_VNIC_FLAG_DEFAULT 0x01
#define BNXT_VNIC_FLAG_BD_STALL 0x02
#define BNXT_VNIC_FLAG_VLAN_STRIP 0x04

        uint64_t filter_id;
        uint32_t flow_id;

        uint16_t rss_id;
        /* rss things */

        /* vlan things */
};

struct bnxt_slot {
        bus_dmamap_t bs_map;
        struct mbuf *bs_m;
};

struct bnxt_dmamem {
        bus_dmamap_t bdm_map;
        bus_dma_segment_t bdm_seg;
        size_t bdm_size;
        caddr_t bdm_kva;
};
#define BNXT_DMA_MAP(_bdm) ((_bdm)->bdm_map)
#define BNXT_DMA_LEN(_bdm) ((_bdm)->bdm_size)
#define BNXT_DMA_DVA(_bdm) ((u_int64_t)(_bdm)->bdm_map->dm_segs[0].ds_addr)
#define BNXT_DMA_KVA(_bdm) ((void *)(_bdm)->bdm_kva)

struct bnxt_softc {
        struct device sc_dev;
        struct arpcom sc_ac;
        struct ifmedia sc_media;

        struct mutex sc_lock;

        pci_chipset_tag_t sc_pc;
        pcitag_t sc_tag;
        bus_dma_tag_t sc_dmat;

        bus_space_tag_t sc_hwrm_t;
        bus_space_handle_t sc_hwrm_h;
        bus_size_t sc_hwrm_s;

        struct bnxt_dmamem *sc_cmd_resp;
        uint16_t sc_cmd_seq;
        uint16_t sc_max_req_len;
        uint32_t sc_cmd_timeo;
        uint32_t sc_flags;

        bus_space_tag_t sc_db_t;
        bus_space_handle_t sc_db_h;
        bus_size_t sc_db_s;

        void *sc_ih;

        int sc_max_tc;
        struct bnxt_cos_queue sc_q_info[BNXT_MAX_QUEUE];

        struct bnxt_vnic_info sc_vnic;
        struct bnxt_dmamem *sc_stats_ctx_mem;

        struct bnxt_cp_ring sc_cp_ring;
        struct bnxt_dmamem *sc_cp_ring_mem;

        /* rx */
        struct bnxt_dmamem *sc_rx_ring_mem; /* rx and ag */
        struct bnxt_ring sc_rx_ring;
        /* struct bnxt_ring sc_rx_ag_ring; */
        struct bnxt_grp_info sc_ring_group;
        struct if_rxring sc_rxr;
        struct bnxt_slot *sc_rx_slots;
        int sc_rx_prod;
        int sc_rx_cons;
        struct timeout sc_rx_refill;

        /* tx */
        struct bnxt_dmamem *sc_tx_ring_mem;
        struct bnxt_ring sc_tx_ring;
        struct bnxt_slot *sc_tx_slots;
        int sc_tx_prod;
        int sc_tx_cons;
        int sc_tx_ring_prod;
        int sc_tx_ring_cons;
};
#define DEVNAME(_sc) ((_sc)->sc_dev.dv_xname)

const struct pci_matchid bnxt_devices[] = {
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57301 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57302 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57304 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57311 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57312 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57314 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57402 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57404 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57406 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57407 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57412 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57414 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57416 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57416_SFP },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57417 },
        { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57417_SFP }
};

int bnxt_match(struct device *, void *, void *);
void bnxt_attach(struct device *, struct device *, void *);

void bnxt_up(struct bnxt_softc *);
void bnxt_down(struct bnxt_softc *);
void bnxt_iff(struct bnxt_softc *);
int bnxt_ioctl(struct ifnet *, u_long, caddr_t);
int bnxt_rxrinfo(struct bnxt_softc *, struct if_rxrinfo *);
void bnxt_start(struct ifqueue *);
int bnxt_intr(void *);
void bnxt_watchdog(struct ifnet *);
void bnxt_media_status(struct ifnet *, struct ifmediareq *);
int bnxt_media_change(struct ifnet *);

void bnxt_mark_cpr_invalid(struct bnxt_cp_ring *);
void bnxt_write_cp_doorbell(struct bnxt_softc *, struct bnxt_ring *,
                    int);
void bnxt_write_cp_doorbell_index(struct bnxt_softc *,
                    struct bnxt_ring *, uint32_t, int);
void bnxt_write_rx_doorbell(struct bnxt_softc *, struct bnxt_ring *,
                    int);
void bnxt_write_tx_doorbell(struct bnxt_softc *, struct bnxt_ring *,
                    int);

int bnxt_rx_fill(struct bnxt_softc *);
u_int bnxt_rx_fill_slots(struct bnxt_softc *, u_int);
void bnxt_refill(void *);
void bnxt_rx(struct bnxt_softc *, struct mbuf_list *, int *,
                    struct cmpl_base *, struct cmpl_base *);

int bnxt_txeof(struct bnxt_softc *, struct cmpl_base *);


/* HWRM Function Prototypes */
int bnxt_hwrm_ring_alloc(struct bnxt_softc *, uint8_t,
                    struct bnxt_ring *, uint16_t, uint32_t, int);
int bnxt_hwrm_ring_free(struct bnxt_softc *, uint8_t,
                    struct bnxt_ring *);
int bnxt_hwrm_ver_get(struct bnxt_softc *);
int bnxt_hwrm_queue_qportcfg(struct bnxt_softc *);
int bnxt_hwrm_func_drv_rgtr(struct bnxt_softc *);
int bnxt_hwrm_func_qcaps(struct bnxt_softc *);
int bnxt_hwrm_func_qcfg(struct bnxt_softc *);
int bnxt_hwrm_func_reset(struct bnxt_softc *);
int bnxt_hwrm_vnic_ctx_alloc(struct bnxt_softc *, uint16_t *);
int bnxt_hwrm_vnic_ctx_free(struct bnxt_softc *, uint16_t *);
int bnxt_hwrm_vnic_cfg(struct bnxt_softc *,
                    struct bnxt_vnic_info *);
int bnxt_hwrm_stat_ctx_alloc(struct bnxt_softc *,
                    struct bnxt_cp_ring *, uint64_t);
int bnxt_hwrm_stat_ctx_free(struct bnxt_softc *,
                    struct bnxt_cp_ring *);
int bnxt_hwrm_ring_grp_alloc(struct bnxt_softc *,
                    struct bnxt_grp_info *);
int bnxt_hwrm_ring_grp_free(struct bnxt_softc *,
                    struct bnxt_grp_info *);
int bnxt_hwrm_vnic_alloc(struct bnxt_softc *,
                    struct bnxt_vnic_info *);
int bnxt_hwrm_vnic_free(struct bnxt_softc *,
                    struct bnxt_vnic_info *);
int bnxt_hwrm_cfa_l2_set_rx_mask(struct bnxt_softc *,
                    struct bnxt_vnic_info *vnic);
int bnxt_hwrm_set_filter(struct bnxt_softc *,
                    struct bnxt_vnic_info *);
int bnxt_hwrm_free_filter(struct bnxt_softc *,
                    struct bnxt_vnic_info *);
int bnxt_cfg_async_cr(struct bnxt_softc *);
int bnxt_hwrm_nvm_get_dev_info(struct bnxt_softc *, uint16_t *,
                    uint16_t *, uint32_t *, uint32_t *, uint32_t *, uint32_t *);
int bnxt_hwrm_port_phy_qcfg(struct bnxt_softc *,
                    struct ifmediareq *);
int bnxt_hwrm_func_rgtr_async_events(struct bnxt_softc *);

/* not used yet: */
#if 0
int bnxt_hwrm_func_drv_unrgtr(struct bnxt_softc *softc, bool shutdown);

int bnxt_hwrm_set_link_setting(struct bnxt_softc *softc, bool set_pause,
    bool set_eee, bool set_link);
int bnxt_hwrm_set_pause(struct bnxt_softc *softc);

int bnxt_hwrm_port_qstats(struct bnxt_softc *softc);

int bnxt_hwrm_rss_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic,
    uint32_t hash_type);

int bnxt_hwrm_vnic_tpa_cfg(struct bnxt_softc *softc);
void bnxt_validate_hw_lro_settings(struct bnxt_softc *softc);
int bnxt_hwrm_nvm_find_dir_entry(struct bnxt_softc *softc, uint16_t type,
    uint16_t *ordinal, uint16_t ext, uint16_t *index, bool use_index,
    uint8_t search_opt, uint32_t *data_length, uint32_t *item_length,
    uint32_t *fw_ver);
int bnxt_hwrm_nvm_read(struct bnxt_softc *softc, uint16_t index,
    uint32_t offset, uint32_t length, struct iflib_dma_info *data);
int bnxt_hwrm_nvm_modify(struct bnxt_softc *softc, uint16_t index,
    uint32_t offset, void *data, bool cpyin, uint32_t length);
int bnxt_hwrm_fw_reset(struct bnxt_softc *softc, uint8_t processor,
    uint8_t *selfreset);
int bnxt_hwrm_fw_qstatus(struct bnxt_softc *softc, uint8_t type,
    uint8_t *selfreset);
int bnxt_hwrm_nvm_write(struct bnxt_softc *softc, void *data, bool cpyin,
    uint16_t type, uint16_t ordinal, uint16_t ext, uint16_t attr,
    uint16_t option, uint32_t data_length, bool keep, uint32_t *item_length,
    uint16_t *index);
int bnxt_hwrm_nvm_erase_dir_entry(struct bnxt_softc *softc, uint16_t index);
int bnxt_hwrm_nvm_get_dir_info(struct bnxt_softc *softc, uint32_t *entries,
    uint32_t *entry_length);
int bnxt_hwrm_nvm_get_dir_entries(struct bnxt_softc *softc,
    uint32_t *entries, uint32_t *entry_length, struct iflib_dma_info *dma_data);

int bnxt_hwrm_nvm_install_update(struct bnxt_softc *softc,
    uint32_t install_type, uint64_t *installed_items, uint8_t *result,
    uint8_t *problem_item, uint8_t *reset_required);
int bnxt_hwrm_nvm_verify_update(struct bnxt_softc *softc, uint16_t type,
    uint16_t ordinal, uint16_t ext);
int bnxt_hwrm_fw_get_time(struct bnxt_softc *softc, uint16_t *year,
    uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *minute,
    uint8_t *second, uint16_t *millisecond, uint16_t *zone);
int bnxt_hwrm_fw_set_time(struct bnxt_softc *softc, uint16_t year,
    uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
    uint16_t millisecond, uint16_t zone);

uint16_t bnxt_hwrm_get_wol_fltrs(struct bnxt_softc *softc, uint16_t handle);
int bnxt_hwrm_alloc_wol_fltr(struct bnxt_softc *softc);
int bnxt_hwrm_free_wol_fltr(struct bnxt_softc *softc);
int bnxt_hwrm_set_coal(struct bnxt_softc *softc);

#endif


struct cfattach bnxt_ca = {
        sizeof(struct bnxt_softc), bnxt_match, bnxt_attach
};

struct cfdriver bnxt_cd = {
        NULL, "bnxt", DV_IFNET
};

struct bnxt_dmamem *
bnxt_dmamem_alloc(struct bnxt_softc *sc, size_t size)
{
        struct bnxt_dmamem *m;
        int nsegs;

        m = malloc(sizeof(*m), M_DEVBUF, M_NOWAIT | M_ZERO);
        if (m == NULL)
                return (NULL);

        m->bdm_size = size;

        if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
            BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &m->bdm_map) != 0)
                goto bdmfree;

        if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &m->bdm_seg, 1,
            &nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO) != 0)
                goto destroy;

        if (bus_dmamem_map(sc->sc_dmat, &m->bdm_seg, nsegs, size, &m->bdm_kva,
            BUS_DMA_NOWAIT) != 0)
                goto free;

        if (bus_dmamap_load(sc->sc_dmat, m->bdm_map, m->bdm_kva, size, NULL,
            BUS_DMA_NOWAIT) != 0)
                goto unmap;

        return (m);

unmap:
        bus_dmamem_unmap(sc->sc_dmat, m->bdm_kva, m->bdm_size);
free:
        bus_dmamem_free(sc->sc_dmat, &m->bdm_seg, 1);
destroy:
        bus_dmamap_destroy(sc->sc_dmat, m->bdm_map);
bdmfree:
        free(m, M_DEVBUF, sizeof *m);

        return (NULL);
}

void
bnxt_dmamem_free(struct bnxt_softc *sc, struct bnxt_dmamem *m)
{
        bus_dmamem_unmap(sc->sc_dmat, m->bdm_kva, m->bdm_size);
        bus_dmamem_free(sc->sc_dmat, &m->bdm_seg, 1);
        bus_dmamap_destroy(sc->sc_dmat, m->bdm_map);
        free(m, M_DEVBUF, sizeof *m);
}

int
bnxt_match(struct device *parent, void *match, void *aux)
{
        return (pci_matchbyid(aux, bnxt_devices, nitems(bnxt_devices)));
}

void
bnxt_attach(struct device *parent, struct device *self, void *aux)
{
        struct bnxt_softc *sc = (struct bnxt_softc *)self;
        struct ifnet *ifp = &sc->sc_ac.ac_if;
        struct pci_attach_args *pa = aux;
        pci_intr_handle_t ih;
        const char *intrstr;
        u_int memtype;

        /* enable busmaster? */

        sc->sc_pc = pa->pa_pc;
        sc->sc_tag = pa->pa_tag;
        sc->sc_dmat = pa->pa_dmat;

        memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, BNXT_HWRM_BAR);
        if (pci_mapreg_map(pa, BNXT_HWRM_BAR, memtype, 0, &sc->sc_hwrm_t,
            &sc->sc_hwrm_h, NULL, &sc->sc_hwrm_s, 0)) {
                printf(": failed to map hwrm\n");
                return;
        }

        memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, BNXT_DOORBELL_BAR);
        if (pci_mapreg_map(pa, BNXT_DOORBELL_BAR, memtype, 0, &sc->sc_db_t,
            &sc->sc_db_h, NULL, &sc->sc_db_s, 0)) {
                printf(": failed to map doorbell\n");
                goto unmap_1;
        }

        BNXT_HWRM_LOCK_INIT(sc, DEVNAME(sc));
        sc->sc_cmd_resp = bnxt_dmamem_alloc(sc, PAGE_SIZE);
        if (sc->sc_cmd_resp == NULL) {
                printf(": failed to allocate command response buffer\n");
                goto unmap_2;
        }

        if (bnxt_hwrm_ver_get(sc) != 0) {
                printf(": failed to query version info\n");
                goto free_resp;
        }

        if (bnxt_hwrm_nvm_get_dev_info(sc, NULL, NULL, NULL, NULL, NULL, NULL)
            != 0) {
                printf(": failed to get nvram info\n");
                goto free_resp;
        }

        if (bnxt_hwrm_func_drv_rgtr(sc) != 0) {
                printf(": failed to register driver with firmware\n");
                goto free_resp;
        }

        if (bnxt_hwrm_func_rgtr_async_events(sc) != 0) {
                printf(": failed to register async events\n");
                goto free_resp;
        }

        if (bnxt_hwrm_func_qcaps(sc) != 0) {
                printf(": failed to get queue capabilities\n");
                goto free_resp;
        }

        /*
         * devices advertise msi support, but there's no way to tell a
         * completion queue to use msi mode, only legacy or msi-x.
         */
        if (/*pci_intr_map_msi(pa, &ih) != 0 && */ pci_intr_map(pa, &ih) != 0) {
                printf(": unable to map interrupt\n");
                goto free_resp;
        }
        intrstr = pci_intr_string(sc->sc_pc, ih);
        sc->sc_ih = pci_intr_establish(sc->sc_pc, ih, IPL_NET | IPL_MPSAFE,
            bnxt_intr, sc, DEVNAME(sc));
        if (sc->sc_ih == NULL) {
                printf(": unable to establish interrupt");
                if (intrstr != NULL)
                        printf(" at %s", intrstr);
                printf("\n");
                goto deintr;
        }
        printf("%s, address %s\n", intrstr, ether_sprintf(sc->sc_ac.ac_enaddr));

        if (bnxt_hwrm_func_qcfg(sc) != 0) {
                printf("%s: failed to query function config\n", DEVNAME(sc));
                goto deintr;
        }

        if (bnxt_hwrm_queue_qportcfg(sc) != 0) {
                printf("%s: failed to query port config\n", DEVNAME(sc));
                goto deintr;
        }

        if (bnxt_hwrm_func_reset(sc) != 0) {
                printf("%s: reset failed\n", DEVNAME(sc));
                goto deintr;
        }

        sc->sc_cp_ring.stats_ctx_id = HWRM_NA_SIGNATURE;
        sc->sc_cp_ring.ring.phys_id = HWRM_NA_SIGNATURE;
        sc->sc_cp_ring.softc = sc;
        sc->sc_cp_ring.ring.id = 0;
        sc->sc_cp_ring.ring.doorbell = sc->sc_cp_ring.ring.id * 0x80;
        sc->sc_cp_ring.ring.ring_size = PAGE_SIZE / sizeof(struct cmpl_base);
        sc->sc_cp_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE);
        if (sc->sc_cp_ring_mem == NULL) {
                printf("%s: failed to allocate completion queue memory\n",
                    DEVNAME(sc));
                goto deintr;
        }
        sc->sc_cp_ring.ring.vaddr = BNXT_DMA_KVA(sc->sc_cp_ring_mem);
        sc->sc_cp_ring.ring.paddr = BNXT_DMA_DVA(sc->sc_cp_ring_mem);
        sc->sc_cp_ring.cons = UINT32_MAX;
        sc->sc_cp_ring.v_bit = 1;
        bnxt_mark_cpr_invalid(&sc->sc_cp_ring);
        if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_L2_CMPL,
            &sc->sc_cp_ring.ring, (uint16_t)HWRM_NA_SIGNATURE,
            HWRM_NA_SIGNATURE, 1) != 0) {
                printf("%s: failed to allocate completion queue\n",
                    DEVNAME(sc));
                goto free_cp_mem;
        }
        if (bnxt_cfg_async_cr(sc) != 0) {
                printf("%s: failed to set async completion ring\n",
                    DEVNAME(sc));
                goto free_cp_mem;
        }
        bnxt_write_cp_doorbell(sc, &sc->sc_cp_ring.ring, 1);

        strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
        ifp->if_softc = sc;
        ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX;
        ifp->if_xflags = IFXF_MPSAFE;
        ifp->if_ioctl = bnxt_ioctl;
        ifp->if_qstart = bnxt_start;
        ifp->if_watchdog = bnxt_watchdog;
        ifp->if_hardmtu = BNXT_MAX_MTU;
        ifp->if_capabilities = IFCAP_VLAN_MTU; /* ? */
        /* checksum flags, hwtagging? */
        IFQ_SET_MAXLEN(&ifp->if_snd, 1024); /* ? */

        ifmedia_init(&sc->sc_media, IFM_IMASK, bnxt_media_change,
            bnxt_media_status);
        ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_AUTO, 0, NULL);
        ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_AUTO);

        if_attach(ifp);
        ether_ifattach(ifp);

        timeout_set(&sc->sc_rx_refill, bnxt_refill, sc);

        bnxt_hwrm_port_phy_qcfg(sc, NULL);
        return;

free_cp_mem:
        bnxt_dmamem_free(sc, sc->sc_cp_ring_mem);
deintr:
        pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
        sc->sc_ih = NULL;
free_resp:
        bnxt_dmamem_free(sc, sc->sc_cmd_resp);
unmap_2:
        bus_space_unmap(sc->sc_hwrm_t, sc->sc_hwrm_h, sc->sc_hwrm_s);
        sc->sc_hwrm_s = 0;
unmap_1:
        bus_space_unmap(sc->sc_db_t, sc->sc_db_h, sc->sc_db_s);
        sc->sc_db_s = 0;
}

void
bnxt_free_slots(struct bnxt_softc *sc, struct bnxt_slot *slots, int allocated,
    int total)
{
        struct bnxt_slot *bs;

        int i = allocated;
        while (i-- > 0) {
                bs = &slots[i];
                bus_dmamap_destroy(sc->sc_dmat, bs->bs_map);
        }
        free(slots, M_DEVBUF, total * sizeof(*bs));
}

void
bnxt_up(struct bnxt_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ac.ac_if;
        struct bnxt_slot *bs;
        int i;

        sc->sc_stats_ctx_mem = bnxt_dmamem_alloc(sc,
            sizeof(struct ctx_hw_stats));
        if (sc->sc_stats_ctx_mem == NULL) {
                printf("%s: failed to allocate stats contexts\n", DEVNAME(sc));
                return;
        }

        sc->sc_tx_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE);
        if (sc->sc_tx_ring_mem == NULL) {
                printf("%s: failed to allocate tx ring\n", DEVNAME(sc));
                goto free_stats;
        }

        sc->sc_rx_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE * 2);
        if (sc->sc_rx_ring_mem == NULL) {
                printf("%s: failed to allocate rx ring\n", DEVNAME(sc));
                goto free_tx;
        }

        if (bnxt_hwrm_stat_ctx_alloc(sc, &sc->sc_cp_ring,
            BNXT_DMA_DVA(sc->sc_stats_ctx_mem)) != 0) {
                printf("%s: failed to set up stats context\n", DEVNAME(sc));
                goto free_rx;
        }

        sc->sc_tx_ring.phys_id = HWRM_NA_SIGNATURE;
        sc->sc_tx_ring.id = BNXT_TX_RING_ID;
        sc->sc_tx_ring.doorbell = sc->sc_tx_ring.id * 0x80;
        sc->sc_tx_ring.ring_size = PAGE_SIZE / sizeof(struct tx_bd_short);
        sc->sc_tx_ring.vaddr = BNXT_DMA_KVA(sc->sc_tx_ring_mem);
        sc->sc_tx_ring.paddr = BNXT_DMA_DVA(sc->sc_tx_ring_mem);
        if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
            &sc->sc_tx_ring, sc->sc_cp_ring.ring.phys_id,
            HWRM_NA_SIGNATURE, 1) != 0) {
                printf("%s: failed to set up tx ring\n",
                    DEVNAME(sc));
                goto dealloc_stats;
        }
        bnxt_write_tx_doorbell(sc, &sc->sc_tx_ring, 0);

        sc->sc_rx_ring.phys_id = HWRM_NA_SIGNATURE;
        sc->sc_rx_ring.id = BNXT_RX_RING_ID;
        sc->sc_rx_ring.doorbell = sc->sc_rx_ring.id * 0x80;
        sc->sc_rx_ring.ring_size = PAGE_SIZE / sizeof(struct rx_prod_pkt_bd);
        sc->sc_rx_ring.vaddr = BNXT_DMA_KVA(sc->sc_rx_ring_mem);
        sc->sc_rx_ring.paddr = BNXT_DMA_DVA(sc->sc_rx_ring_mem);
        if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
            &sc->sc_rx_ring, sc->sc_cp_ring.ring.phys_id,
            HWRM_NA_SIGNATURE, 1) != 0) {
                printf("%s: failed to set up rx ring\n",
                    DEVNAME(sc));
                goto dealloc_tx;
        }
        bnxt_write_rx_doorbell(sc, &sc->sc_rx_ring, 0);

#if 0
        sc->sc_rx_ag_ring.phys_id = HWRM_NA_SIGNATURE;
        sc->sc_rx_ag_ring.id = BNXT_AG_RING_ID;
        sc->sc_rx_ag_ring.doorbell = sc->sc_rx_ring.id * 0x80;
        sc->sc_rx_ag_ring.ring_size = PAGE_SIZE / sizeof(struct rx_prod_pkt_bd);
        sc->sc_rx_ag_ring.vaddr = BNXT_DMA_KVA(sc->sc_rx_ring_mem) + PAGE_SIZE;
        sc->sc_rx_ag_ring.paddr = BNXT_DMA_DVA(sc->sc_rx_ring_mem) + PAGE_SIZE;
        if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
            &sc->sc_rx_ag_ring, sc->sc_cp_ring.ring.phys_id,
            HWRM_NA_SIGNATURE, 1) != 0) {
                printf("%s: failed to set up rx ag ring\n",
                    DEVNAME(sc));
                goto dealloc_rx;
        }
#endif

        sc->sc_ring_group.grp_id = HWRM_NA_SIGNATURE;
        sc->sc_ring_group.stats_ctx = sc->sc_cp_ring.stats_ctx_id;
        sc->sc_ring_group.rx_ring_id = sc->sc_rx_ring.phys_id;
        sc->sc_ring_group.ag_ring_id = HWRM_NA_SIGNATURE;
        sc->sc_ring_group.cp_ring_id = sc->sc_cp_ring.ring.phys_id;
        if (bnxt_hwrm_ring_grp_alloc(sc, &sc->sc_ring_group) != 0) {
                printf("%s: failed to allocate ring group\n",
                    DEVNAME(sc));
                goto dealloc_rx;
        }

        sc->sc_vnic.rss_id = HWRM_NA_SIGNATURE;
        if (bnxt_hwrm_vnic_ctx_alloc(sc, &sc->sc_vnic.rss_id) != 0) {
                printf("%s: failed to allocate vnic rss context\n",
                    DEVNAME(sc));
                goto dealloc_ring_group;
        }

        sc->sc_vnic.id = HWRM_NA_SIGNATURE;
        sc->sc_vnic.def_ring_grp = sc->sc_ring_group.grp_id;
        sc->sc_vnic.mru = MCLBYTES;
        sc->sc_vnic.cos_rule = (uint16_t)HWRM_NA_SIGNATURE;
        sc->sc_vnic.lb_rule = (uint16_t)HWRM_NA_SIGNATURE;
        sc->sc_vnic.rx_mask = HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_BCAST;
        /* sc->sc_vnic.mc_list_count = 0; */
        sc->sc_vnic.flags = BNXT_VNIC_FLAG_DEFAULT;
        if (bnxt_hwrm_vnic_alloc(sc, &sc->sc_vnic) != 0) {
                printf("%s: failed to allocate vnic\n", DEVNAME(sc));
                goto dealloc_vnic_ctx;
        }

        if (bnxt_hwrm_vnic_cfg(sc, &sc->sc_vnic) != 0) {
                printf("%s: failed to configure vnic\n", DEVNAME(sc));
                goto dealloc_vnic;
        }

        sc->sc_vnic.filter_id = -1;
        if (bnxt_hwrm_set_filter(sc, &sc->sc_vnic) != 0) {
                printf("%s: failed to set vnic filter\n", DEVNAME(sc));
                goto dealloc_vnic;
        }

        /* don't configure rss or tpa yet */

        sc->sc_rx_slots = mallocarray(sizeof(*bs), sc->sc_rx_ring.ring_size,
            M_DEVBUF, M_WAITOK | M_ZERO);
        if (sc->sc_rx_slots == NULL) {
                printf("%s: failed to allocate rx slots\n", DEVNAME(sc));
                goto dealloc_filter;
        }

        for (i = 0; i < sc->sc_rx_ring.ring_size; i++) {
                bs = &sc->sc_rx_slots[i];
                if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES, 0,
                    BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW, &bs->bs_map) != 0) {
                        printf("%s: failed to allocate rx dma maps\n",
                            DEVNAME(sc));
                        goto destroy_rx_slots;
                }
        }

        sc->sc_tx_slots = mallocarray(sizeof(*bs), sc->sc_tx_ring.ring_size,
            M_DEVBUF, M_WAITOK | M_ZERO);
        if (sc->sc_tx_slots == NULL) {
                printf("%s: failed to allocate tx slots\n", DEVNAME(sc));
                goto destroy_rx_slots;
        }

        for (i = 0; i < sc->sc_tx_ring.ring_size; i++) {
                bs = &sc->sc_tx_slots[i];
                if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, BNXT_MAX_TX_SEGS,
                    MCLBYTES, 0, BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW,
                    &bs->bs_map) != 0) {
                        printf("%s: failed to allocate tx dma maps\n",
                            DEVNAME(sc));
                        goto destroy_tx_slots;
                }
        }

        bnxt_iff(sc);

        /*
         * initially, the rx ring must be filled at least some distance beyond
         * the current consumer index, as it looks like the firmware assumes the
         * ring is full on creation, but doesn't prefetch the whole thing.
         * once the whole ring has been used once, we should be able to back off
         * to 2 or so slots, but we currently don't have a way of doing that.
         */
        if_rxr_init(&sc->sc_rxr, 32, sc->sc_rx_ring.ring_size - 1);
        sc->sc_rx_prod = 0;
        sc->sc_rx_cons = 0;
        bnxt_rx_fill(sc);

        SET(ifp->if_flags, IFF_RUNNING);

        sc->sc_tx_cons = 0;
        sc->sc_tx_prod = 0;
        sc->sc_tx_ring_cons = 0;
        sc->sc_tx_ring_prod = 0;
        ifq_clr_oactive(&ifp->if_snd);
        ifq_restart(&ifp->if_snd);

        return;

destroy_tx_slots:
        bnxt_free_slots(sc, sc->sc_tx_slots, i, sc->sc_tx_ring.ring_size);
        sc->sc_tx_slots = NULL;

        i = sc->sc_rx_ring.ring_size;
destroy_rx_slots:
        bnxt_free_slots(sc, sc->sc_rx_slots, i, sc->sc_rx_ring.ring_size);
        sc->sc_rx_slots = NULL;
dealloc_filter:
        bnxt_hwrm_free_filter(sc, &sc->sc_vnic);
dealloc_vnic:
        bnxt_hwrm_vnic_free(sc, &sc->sc_vnic);
dealloc_vnic_ctx:
        bnxt_hwrm_vnic_ctx_free(sc, &sc->sc_vnic.rss_id);
dealloc_ring_group:
        bnxt_hwrm_ring_grp_free(sc, &sc->sc_ring_group);
/* dealloc_ag: */
dealloc_tx:
        bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
            &sc->sc_tx_ring);
dealloc_rx:
        bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
            &sc->sc_rx_ring);
dealloc_stats:
        bnxt_hwrm_stat_ctx_free(sc, &sc->sc_cp_ring);
free_rx:
        bnxt_dmamem_free(sc, sc->sc_rx_ring_mem);
        sc->sc_rx_ring_mem = NULL;
free_tx:
        bnxt_dmamem_free(sc, sc->sc_tx_ring_mem);
        sc->sc_tx_ring_mem = NULL;
free_stats:
        bnxt_dmamem_free(sc, sc->sc_stats_ctx_mem);
        sc->sc_stats_ctx_mem = NULL;
}

void
bnxt_down(struct bnxt_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ac.ac_if;
       
        CLR(ifp->if_flags, IFF_RUNNING);

        ifq_clr_oactive(&ifp->if_snd);
        ifq_barrier(&ifp->if_snd);

        timeout_del(&sc->sc_rx_refill);

        /* empty rx ring first i guess */

        bnxt_free_slots(sc, sc->sc_tx_slots, sc->sc_tx_ring.ring_size,
            sc->sc_tx_ring.ring_size);
        sc->sc_tx_slots = NULL;

        bnxt_free_slots(sc, sc->sc_rx_slots, sc->sc_rx_ring.ring_size,
            sc->sc_rx_ring.ring_size);
        sc->sc_rx_slots = NULL;

        bnxt_hwrm_free_filter(sc, &sc->sc_vnic);
        bnxt_hwrm_vnic_free(sc, &sc->sc_vnic);
        bnxt_hwrm_vnic_ctx_free(sc, &sc->sc_vnic.rss_id);
        bnxt_hwrm_ring_grp_free(sc, &sc->sc_ring_group);
        bnxt_hwrm_stat_ctx_free(sc, &sc->sc_cp_ring);

        /* may need to wait for 500ms here before we can free the rings */

        bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
            &sc->sc_tx_ring);
        bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
            &sc->sc_rx_ring);

        bnxt_dmamem_free(sc, sc->sc_rx_ring_mem);
        sc->sc_rx_ring_mem = NULL;

        bnxt_dmamem_free(sc, sc->sc_tx_ring_mem);
        sc->sc_tx_ring_mem = NULL;

        bnxt_dmamem_free(sc, sc->sc_stats_ctx_mem);
        sc->sc_stats_ctx_mem = NULL;
}

void
bnxt_iff(struct bnxt_softc *sc)
{
        struct ifnet *ifp = &sc->sc_ac.ac_if;

        if (ifp->if_flags & IFF_ALLMULTI)
                sc->sc_vnic.rx_mask |=
                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
        else
                sc->sc_vnic.rx_mask &=
                    ~HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;

        if (ifp->if_flags & IFF_PROMISC)
                sc->sc_vnic.rx_mask |=
                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN;
        else
                sc->sc_vnic.rx_mask &=
                    ~(HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN);

        bnxt_hwrm_cfa_l2_set_rx_mask(sc, &sc->sc_vnic);
}

int
bnxt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
{
        struct bnxt_softc *sc = (struct bnxt_softc *)ifp->if_softc;
        struct ifreq *ifr = (struct ifreq *)data;
        int s, error = 0;

        s = splnet();
        switch (cmd) {
        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP;
                /* FALLTHROUGH */

        case SIOCSIFFLAGS:
                if (ISSET(ifp->if_flags, IFF_UP)) {
                        if (ISSET(ifp->if_flags, IFF_RUNNING))
                                error = ENETRESET;
                        else
                                bnxt_up(sc);
                } else {
                        if (ISSET(ifp->if_flags, IFF_RUNNING))
                                bnxt_down(sc);
                }
                break;

        case SIOCGIFMEDIA:
        case SIOCSIFMEDIA:
                error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
                break;

        case SIOCGIFRXR:
                error = bnxt_rxrinfo(sc, (struct if_rxrinfo *)ifr->ifr_data);
                break;

        default:
                error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
        }

        if (error == ENETRESET) {
                if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
                    (IFF_UP | IFF_RUNNING))
                        bnxt_iff(sc);
                error = 0;
        }

        splx(s);

        return (error);
}

int
bnxt_rxrinfo(struct bnxt_softc *sc, struct if_rxrinfo *ifri)
{
        struct if_rxring_info ifr;

        memset(&ifr, 0, sizeof(ifr));
        ifr.ifr_size = MCLBYTES;
        ifr.ifr_info = sc->sc_rxr;

        return (if_rxr_info_ioctl(ifri, 1, &ifr));
}

int
bnxt_load_mbuf(struct bnxt_softc *sc, struct bnxt_slot *bs, struct mbuf *m)
{
        switch (bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
            BUS_DMA_STREAMING | BUS_DMA_NOWAIT)) {
        case 0:
                break;

        case EFBIG:
                if (m_defrag(m, M_DONTWAIT) == 0 &&
                    bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
                    BUS_DMA_STREAMING | BUS_DMA_NOWAIT) == 0)
                        break;

        default:
                return (1);
        }

        bs->bs_m = m;
        return (0);
}

void
bnxt_start(struct ifqueue *ifq)
{
        struct ifnet *ifp = ifq->ifq_if;
        struct tx_bd_short *txring;
        struct bnxt_softc *sc = ifp->if_softc;
        struct bnxt_slot *bs;
        bus_dmamap_t map;
        struct mbuf *m;
        u_int idx, free, used;
        uint16_t txflags;
        int i;

        txring = (struct tx_bd_short *)BNXT_DMA_KVA(sc->sc_tx_ring_mem);

        idx = sc->sc_tx_ring_prod;
        free = sc->sc_tx_ring_cons;
        if (free <= idx)
                free += sc->sc_tx_ring.ring_size;
        free -= idx;

        used = 0;

        for (;;) {
                if (used + BNXT_MAX_TX_SEGS > free) {
                        ifq_set_oactive(ifq);
                        break;
                }

                m = ifq_dequeue(ifq);
                if (m == NULL)
                        break;

                bs = &sc->sc_tx_slots[sc->sc_tx_prod];
                if (bnxt_load_mbuf(sc, bs, m) != 0) {
                        m_freem(m);
                        ifp->if_oerrors++;
                        continue;
                }

#if NBPFILTER > 0
                if (ifp->if_bpf)
                        bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
#endif
                map = bs->bs_map;
                bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
                    BUS_DMASYNC_PREWRITE);
                used += map->dm_nsegs;

                if (map->dm_mapsize < 512)
                        txflags = TX_BD_SHORT_FLAGS_LHINT_LT512;
                else if (map->dm_mapsize < 1024)
                        txflags = TX_BD_SHORT_FLAGS_LHINT_LT1K;
                else if (map->dm_mapsize < 2048)
                        txflags = TX_BD_SHORT_FLAGS_LHINT_LT2K;
                else
                        txflags = TX_BD_SHORT_FLAGS_LHINT_GTE2K;

                txflags |= TX_BD_SHORT_TYPE_TX_BD_SHORT |
                    (map->dm_nsegs << TX_BD_SHORT_FLAGS_BD_CNT_SFT);

                for (i = 0; i < map->dm_nsegs; i++) {
                        txring[idx].flags_type = htole16(txflags);
                        if (i == map->dm_nsegs - 1)
                                txring[idx].flags_type |=
                                    TX_BD_SHORT_FLAGS_PACKET_END;
                        txflags = TX_BD_SHORT_TYPE_TX_BD_SHORT;

                        txring[idx].len =
                            htole16(bs->bs_map->dm_segs[i].ds_len);
                        txring[idx].opaque = sc->sc_tx_prod;
                        txring[idx].addr =
                            htole64(bs->bs_map->dm_segs[i].ds_addr);

                        idx++;
                        if (idx == sc->sc_tx_ring.ring_size)
                                idx = 0;
                }

                if (++sc->sc_tx_prod >= sc->sc_tx_ring.ring_size)
                        sc->sc_tx_prod = 0;
        }

        bnxt_write_tx_doorbell(sc, &sc->sc_tx_ring, idx);
        sc->sc_tx_ring_prod = idx;
}

void
bnxt_handle_async_event(struct bnxt_softc *sc, struct cmpl_base *cmpl)
{
        struct hwrm_async_event_cmpl *ae = (struct hwrm_async_event_cmpl *)cmpl;
        uint16_t type = le16toh(ae->event_id);

        switch (type) {
        case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE:
        case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CHANGE:
        case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE:
                bnxt_hwrm_port_phy_qcfg(sc, NULL);
                break;

        default:
                printf("%s: unexpected async event %x\n", DEVNAME(sc), type);
                break;
        }
}

int
bnxt_intr(void *xsc)
{
        struct bnxt_softc *sc = (struct bnxt_softc *)xsc;
        struct ifnet *ifp = &sc->sc_ac.ac_if;
        struct bnxt_cp_ring *cpr = &sc->sc_cp_ring;
        struct cmpl_base *cmpl, *cmpl2;
        struct mbuf_list ml = MBUF_LIST_INITIALIZER();
        uint32_t cons, last_cons;
        int v_bit, last_v_bit;
        uint16_t type;
        int rxfree, txfree;

        cons = cpr->cons;
        v_bit = cpr->v_bit;

        bnxt_write_cp_doorbell(sc, &cpr->ring, 0);
        rxfree = 0;
        txfree = 0;
        for (;;) {
                last_cons = cons;
                last_v_bit = v_bit;
                NEXT_CP_CONS_V(&cpr->ring, cons, v_bit);
                cmpl = &((struct cmpl_base *)cpr->ring.vaddr)[cons];

                if ((!!(cmpl->info3_v & htole32(CMPL_BASE_V))) != (!!v_bit))
                        break;

                type = le16toh(cmpl->type) & CMPL_BASE_TYPE_MASK;
                switch (type) {
                case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
                        bnxt_handle_async_event(sc, cmpl);
                        break;
                case CMPL_BASE_TYPE_RX_L2:
                        /* rx takes two slots */
                        last_cons = cons;
                        last_v_bit = v_bit;
                        NEXT_CP_CONS_V(&cpr->ring, cons, v_bit);
                        cmpl2 = &((struct cmpl_base *)cpr->ring.vaddr)[cons];
                        bnxt_rx(sc, &ml, &rxfree, cmpl, cmpl2);
                        break;
                case CMPL_BASE_TYPE_TX_L2:
                        txfree += bnxt_txeof(sc, cmpl);
                        break;
                default:
                        printf("%s: unexpected completion type %u\n",
                            DEVNAME(sc), type);
                }
        }

        cpr->cons = last_cons;
        cpr->v_bit = last_v_bit;

        /*
         * comments in bnxtreg.h suggest we should be writing cpr->cons here,
         * but writing cpr->cons + 1 makes it stop interrupting.
         */
        bnxt_write_cp_doorbell_index(sc, &cpr->ring,
            (cpr->cons+1) % cpr->ring.ring_size, 1);

        if (rxfree != 0) {
                sc->sc_rx_cons += rxfree;
                if (sc->sc_rx_cons >= sc->sc_rx_ring.ring_size)
                        sc->sc_rx_cons -= sc->sc_rx_ring.ring_size;

                if_rxr_put(&sc->sc_rxr, rxfree);

                bnxt_rx_fill(sc);
                if (sc->sc_rx_cons == sc->sc_rx_prod)
                        timeout_add(&sc->sc_rx_refill, 0);

                if_input(&sc->sc_ac.ac_if, &ml);
        }
        if (txfree != 0) {
                if (ifq_is_oactive(&ifp->if_snd))
                        ifq_restart(&ifp->if_snd);
        }
        return (1);
}

void
bnxt_watchdog(struct ifnet *ifp)
{
}

void
bnxt_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
{
        struct bnxt_softc *sc = (struct bnxt_softc *)ifp->if_softc;
        bnxt_hwrm_port_phy_qcfg(sc, ifmr);
}

int
bnxt_media_change(struct ifnet *ifp)
{
        return 0;
}

void
bnxt_mark_cpr_invalid(struct bnxt_cp_ring *cpr)
{
        struct cmpl_base *cmp = (void *)cpr->ring.vaddr;
        int i;

        for (i = 0; i < cpr->ring.ring_size; i++)
                cmp[i].info3_v = !cpr->v_bit;
}

void
bnxt_write_cp_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring,
    int enable)
{
        uint32_t val = CMPL_DOORBELL_KEY_CMPL;
        if (enable == 0)
                val |= CMPL_DOORBELL_MASK;

        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, 0, sc->sc_db_s,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));
}

void
bnxt_write_cp_doorbell_index(struct bnxt_softc *sc, struct bnxt_ring *ring,
    uint32_t index, int enable)
{
        uint32_t val = CMPL_DOORBELL_KEY_CMPL | CMPL_DOORBELL_IDX_VALID |
            (index & CMPL_DOORBELL_IDX_MASK);
        if (enable == 0)
                val |= CMPL_DOORBELL_MASK;
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, 0, sc->sc_db_s,
            BUS_SPACE_BARRIER_WRITE);
}

void
bnxt_write_rx_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring, int index)
{
        uint32_t val = RX_DOORBELL_KEY_RX | index;
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));

        /* second write isn't necessary on all hardware */
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));
}

void
bnxt_write_tx_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring, int index)
{
        uint32_t val = TX_DOORBELL_KEY_TX | index;
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));

        /* second write isn't necessary on all hardware */
        bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
            BUS_SPACE_BARRIER_WRITE);
        bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
            htole32(val));
}

u_int
bnxt_rx_fill_slots(struct bnxt_softc *sc, u_int slots)
{
        struct rx_prod_pkt_bd *rxring;
        struct bnxt_slot *bs;
        struct mbuf *m;
        uint p, fills;
        uint16_t type;

        type = RX_PROD_PKT_BD_TYPE_RX_PROD_PKT;

        rxring = (struct rx_prod_pkt_bd *)BNXT_DMA_KVA(sc->sc_rx_ring_mem);
        p = sc->sc_rx_prod;
        for (fills = 0; fills < slots; fills++) {
                bs = &sc->sc_rx_slots[p];
                m = MCLGETI(NULL, M_DONTWAIT, NULL, MCLBYTES);
                if (m == NULL)
                        break;

                m->m_len = m->m_pkthdr.len = MCLBYTES;
                if (bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
                    BUS_DMA_NOWAIT) != 0) {
                        m_freem(m);
                        break;
                }
                bs->bs_m = m;

                rxring[p].flags_type = htole16(type);
                rxring[p].len = htole16(MCLBYTES);
                rxring[p].opaque = p;
                rxring[p].addr = htole64(bs->bs_map->dm_segs[0].ds_addr);

                if (++p >= sc->sc_rx_ring.ring_size)
                        p = 0;
        }

        if (fills != 0)
                bnxt_write_rx_doorbell(sc, &sc->sc_rx_ring, p);
        sc->sc_rx_prod = p;

        return (slots - fills);
}

int
bnxt_rx_fill(struct bnxt_softc *sc)
{
        u_int slots;

        slots = if_rxr_get(&sc->sc_rxr, sc->sc_rx_ring.ring_size);
        if (slots == 0)
                return (1);

        slots = bnxt_rx_fill_slots(sc, slots);
        if_rxr_put(&sc->sc_rxr, slots);

        return (0);
}

void
bnxt_refill(void *xsc)
{
        struct bnxt_softc *sc = xsc;

        bnxt_rx_fill(sc);

        if (sc->sc_rx_cons == sc->sc_rx_prod)
                timeout_add(&sc->sc_rx_refill, 1);
}

void
bnxt_rx(struct bnxt_softc *sc, struct mbuf_list *ml, int *slots,
    struct cmpl_base *cmpl, struct cmpl_base *cmpl2)
{
        struct mbuf *m;
        struct bnxt_slot *bs;
        struct rx_pkt_cmpl *rx = (struct rx_pkt_cmpl *)cmpl;
        /* struct rx_pkt_cmpl_hi *rxhi = (struct rx_pkt_cmpl_hi *)cmpl2; */

        if (rx->opaque != sc->sc_rx_cons)
                printf("%s: expected rx %d, got %d\n", DEVNAME(sc), sc->sc_rx_cons, rx->opaque);
        bs = &sc->sc_rx_slots[rx->opaque];

        bus_dmamap_sync(sc->sc_dmat, bs->bs_map, 0, bs->bs_map->dm_mapsize,
            BUS_DMASYNC_POSTREAD);
        bus_dmamap_unload(sc->sc_dmat, bs->bs_map);

        m = bs->bs_m;
        bs->bs_m = NULL;
        m->m_pkthdr.len = m->m_len = letoh16(rx->len);
        ml_enqueue(ml, m);
        (*slots)++;
}

int
bnxt_txeof(struct bnxt_softc *sc, struct cmpl_base *cmpl)
{
        struct tx_cmpl *txcmpl = (struct tx_cmpl *)cmpl;
        struct bnxt_slot *bs;
        bus_dmamap_t map;
        u_int idx, freed;

        if (txcmpl->opaque != sc->sc_tx_cons)
                printf("%s: txeof for %d, expected %d?\n",
                    DEVNAME(sc), txcmpl->opaque, sc->sc_tx_cons);
        idx = sc->sc_tx_ring_cons;

        bs = &sc->sc_tx_slots[sc->sc_tx_cons];
        map = bs->bs_map;

        freed = map->dm_nsegs;
        bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
            BUS_DMASYNC_POSTWRITE);
        bus_dmamap_unload(sc->sc_dmat, map);
        m_freem(bs->bs_m);
        bs->bs_m = NULL;

        idx += freed;
        if (idx >= sc->sc_tx_ring.ring_size)
                idx -= sc->sc_tx_ring.ring_size;
        sc->sc_tx_ring_cons = idx;

        if (++sc->sc_tx_cons >= sc->sc_tx_ring.ring_size)
                sc->sc_tx_cons = 0;

        return (freed);
}

/* bnxt_hwrm.c */

static int bnxt_hwrm_err_map(uint16_t err);
#if 0
static void bnxt_hwrm_set_link_common(struct bnxt_softc *softc,
                    struct hwrm_port_phy_cfg_input *req);
static void bnxt_hwrm_set_pause_common(struct bnxt_softc *softc,
                    struct hwrm_port_phy_cfg_input *req);
static void bnxt_hwrm_set_eee(struct bnxt_softc *softc,
                    struct hwrm_port_phy_cfg_input *req);
#endif

static int _hwrm_send_message(struct bnxt_softc *, void *, uint32_t);
static int hwrm_send_message(struct bnxt_softc *, void *, uint32_t);
static void bnxt_hwrm_cmd_hdr_init(struct bnxt_softc *, void *, uint16_t);

/* NVRam stuff has a five minute timeout */
#define BNXT_NVM_TIMEO (5 * 60 * 1000)

static int
bnxt_hwrm_err_map(uint16_t err)
{
        int rc;

        switch (err) {
        case HWRM_ERR_CODE_SUCCESS:
                return 0;
        case HWRM_ERR_CODE_INVALID_PARAMS:
        case HWRM_ERR_CODE_INVALID_FLAGS:
        case HWRM_ERR_CODE_INVALID_ENABLES:
                return EINVAL;
        case HWRM_ERR_CODE_RESOURCE_ACCESS_DENIED:
                return EACCES;
        case HWRM_ERR_CODE_RESOURCE_ALLOC_ERROR:
                return ENOMEM;
        case HWRM_ERR_CODE_CMD_NOT_SUPPORTED:
                return ENOSYS;
        case HWRM_ERR_CODE_FAIL:
                return EIO;
        case HWRM_ERR_CODE_HWRM_ERROR:
        case HWRM_ERR_CODE_UNKNOWN_ERR:
        default:
                return EIO;
        }

        return rc;
}

static void
bnxt_hwrm_cmd_hdr_init(struct bnxt_softc *softc, void *request,
    uint16_t req_type)
{
        struct input *req = request;

        req->req_type = htole16(req_type);
        req->cmpl_ring = 0xffff;
        req->target_id = 0xffff;
        req->resp_addr = htole64(BNXT_DMA_DVA(softc->sc_cmd_resp));
}

static int
_hwrm_send_message(struct bnxt_softc *softc, void *msg, uint32_t msg_len)
{
        struct input *req = msg;
        struct hwrm_err_output *resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
        uint32_t *data = msg;
        int i;
        uint16_t cp_ring_id;
        uint8_t *valid;
        uint16_t err;
        uint16_t max_req_len = HWRM_MAX_REQ_LEN;
        struct hwrm_short_input short_input = {0};

        /* TODO: DMASYNC in here. */
        req->seq_id = htole16(softc->sc_cmd_seq++);
        memset(resp, 0, PAGE_SIZE);
        cp_ring_id = le16toh(req->cmpl_ring);

        if (softc->sc_flags & BNXT_FLAG_SHORT_CMD) {
                void *short_cmd_req = BNXT_DMA_KVA(softc->sc_cmd_resp);

                memcpy(short_cmd_req, req, msg_len);
                memset((uint8_t *) short_cmd_req + msg_len, 0,
                    softc->sc_max_req_len - msg_len);

                short_input.req_type = req->req_type;
                short_input.signature =
                    htole16(HWRM_SHORT_INPUT_SIGNATURE_SHORT_CMD);
                short_input.size = htole16(msg_len);
                short_input.req_addr =
                    htole64(BNXT_DMA_DVA(softc->sc_cmd_resp));

                data = (uint32_t *)&short_input;
                msg_len = sizeof(short_input);

                /* Sync memory write before updating doorbell */
                membar_sync();

                max_req_len = BNXT_HWRM_SHORT_REQ_LEN;
        }

        /* Write request msg to hwrm channel */
        for (i = 0; i < msg_len; i += 4) {
                bus_space_write_4(softc->sc_hwrm_t,
                                  softc->sc_hwrm_h,
                                  i, *data);
                data++;
        }

        /* Clear to the end of the request buffer */
        for (i = msg_len; i < max_req_len; i += 4)
                bus_space_write_4(softc->sc_hwrm_t, softc->sc_hwrm_h,
                    i, 0);

        /* Ring channel doorbell */
        bus_space_write_4(softc->sc_hwrm_t, softc->sc_hwrm_h, 0x100,
            htole32(1));

        /* Check if response len is updated */
        for (i = 0; i < softc->sc_cmd_timeo; i++) {
                if (resp->resp_len && resp->resp_len <= 4096)
                        break;
                DELAY(1000);
        }
        if (i >= softc->sc_cmd_timeo) {
                printf("%s: timeout sending %s: (timeout: %u) seq: %d\n",
                    DEVNAME(softc), GET_HWRM_REQ_TYPE(req->req_type),
                    softc->sc_cmd_timeo,
                    le16toh(req->seq_id));
                return ETIMEDOUT;
        }
        /* Last byte of resp contains the valid key */
        valid = (uint8_t *)resp + resp->resp_len - 1;
        for (i = 0; i < softc->sc_cmd_timeo; i++) {
                if (*valid == HWRM_RESP_VALID_KEY)
                        break;
                DELAY(1000);
        }
        if (i >= softc->sc_cmd_timeo) {
                printf("%s: timeout sending %s: "
                    "(timeout: %u) msg {0x%x 0x%x} len:%d v: %d\n",
                    DEVNAME(softc), GET_HWRM_REQ_TYPE(req->req_type),
                    softc->sc_cmd_timeo, le16toh(req->req_type),
                    le16toh(req->seq_id), msg_len,
                    *valid);
                return ETIMEDOUT;
        }

        err = le16toh(resp->error_code);
        if (err) {
                /* HWRM_ERR_CODE_FAIL is a "normal" error, don't log */
                if (err != HWRM_ERR_CODE_FAIL) {
                        printf("%s: %s command returned %s error.\n",
                            DEVNAME(softc),
                            GET_HWRM_REQ_TYPE(req->req_type),
                            GET_HWRM_ERROR_CODE(err));
                }
                return bnxt_hwrm_err_map(err);
        }

        return 0;
}


static int
hwrm_send_message(struct bnxt_softc *softc, void *msg, uint32_t msg_len)
{
        int rc;

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, msg, msg_len);
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}


int
bnxt_hwrm_queue_qportcfg(struct bnxt_softc *softc)
{
        struct hwrm_queue_qportcfg_input req = {0};
        struct hwrm_queue_qportcfg_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);

        int rc = 0;
        uint8_t *qptr;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_QUEUE_QPORTCFG);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto qportcfg_exit;

        if (!resp->max_configurable_queues) {
                rc = -EINVAL;
                goto qportcfg_exit;
        }
        softc->sc_max_tc = resp->max_configurable_queues;
        if (softc->sc_max_tc > BNXT_MAX_QUEUE)
                softc->sc_max_tc = BNXT_MAX_QUEUE;

        qptr = &resp->queue_id0;
        for (int i = 0; i < softc->sc_max_tc; i++) {
                softc->sc_q_info[i].id = *qptr++;
                softc->sc_q_info[i].profile = *qptr++;
        }

qportcfg_exit:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_ver_get(struct bnxt_softc *softc)
{
        struct hwrm_ver_get_input req = {0};
        struct hwrm_ver_get_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        int rc;
#if 0
        const char nastr[] = "<not installed>";
        const char naver[] = "<N/A>";
#endif
        uint32_t dev_caps_cfg;

        softc->sc_max_req_len = HWRM_MAX_REQ_LEN;
        softc->sc_cmd_timeo = 1000;
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VER_GET);

        req.hwrm_intf_maj = HWRM_VERSION_MAJOR;
        req.hwrm_intf_min = HWRM_VERSION_MINOR;
        req.hwrm_intf_upd = HWRM_VERSION_UPDATE;

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        printf(": fw ver %d.%d.%d, ", resp->hwrm_fw_maj, resp->hwrm_fw_min,
            resp->hwrm_fw_bld);
#if 0
        snprintf(softc->ver_info->hwrm_if_ver, BNXT_VERSTR_SIZE, "%d.%d.%d",
            resp->hwrm_intf_maj, resp->hwrm_intf_min, resp->hwrm_intf_upd);
        softc->ver_info->hwrm_if_major = resp->hwrm_intf_maj;
        softc->ver_info->hwrm_if_minor = resp->hwrm_intf_min;
        softc->ver_info->hwrm_if_update = resp->hwrm_intf_upd;
        snprintf(softc->ver_info->hwrm_fw_ver, BNXT_VERSTR_SIZE, "%d.%d.%d",
            resp->hwrm_fw_maj, resp->hwrm_fw_min, resp->hwrm_fw_bld);
        strlcpy(softc->ver_info->driver_hwrm_if_ver, HWRM_VERSION_STR,
            BNXT_VERSTR_SIZE);
        strlcpy(softc->ver_info->hwrm_fw_name, resp->hwrm_fw_name,
            BNXT_NAME_SIZE);

        if (resp->mgmt_fw_maj == 0 && resp->mgmt_fw_min == 0 &&
            resp->mgmt_fw_bld == 0) {
                strlcpy(softc->ver_info->mgmt_fw_ver, naver, BNXT_VERSTR_SIZE);
                strlcpy(softc->ver_info->mgmt_fw_name, nastr, BNXT_NAME_SIZE);
        }
        else {
                snprintf(softc->ver_info->mgmt_fw_ver, BNXT_VERSTR_SIZE,
                    "%d.%d.%d", resp->mgmt_fw_maj, resp->mgmt_fw_min,
                    resp->mgmt_fw_bld);
                strlcpy(softc->ver_info->mgmt_fw_name, resp->mgmt_fw_name,
                    BNXT_NAME_SIZE);
        }
        if (resp->netctrl_fw_maj == 0 && resp->netctrl_fw_min == 0 &&
            resp->netctrl_fw_bld == 0) {
                strlcpy(softc->ver_info->netctrl_fw_ver, naver,
                    BNXT_VERSTR_SIZE);
                strlcpy(softc->ver_info->netctrl_fw_name, nastr,
                    BNXT_NAME_SIZE);
        }
        else {
                snprintf(softc->ver_info->netctrl_fw_ver, BNXT_VERSTR_SIZE,
                    "%d.%d.%d", resp->netctrl_fw_maj, resp->netctrl_fw_min,
                    resp->netctrl_fw_bld);
                strlcpy(softc->ver_info->netctrl_fw_name, resp->netctrl_fw_name,
                    BNXT_NAME_SIZE);
        }
        if (resp->roce_fw_maj == 0 && resp->roce_fw_min == 0 &&
            resp->roce_fw_bld == 0) {
                strlcpy(softc->ver_info->roce_fw_ver, naver, BNXT_VERSTR_SIZE);
                strlcpy(softc->ver_info->roce_fw_name, nastr, BNXT_NAME_SIZE);
        }
        else {
                snprintf(softc->ver_info->roce_fw_ver, BNXT_VERSTR_SIZE,
                    "%d.%d.%d", resp->roce_fw_maj, resp->roce_fw_min,
                    resp->roce_fw_bld);
                strlcpy(softc->ver_info->roce_fw_name, resp->roce_fw_name,
                    BNXT_NAME_SIZE);
        }
        softc->ver_info->chip_num = le16toh(resp->chip_num);
        softc->ver_info->chip_rev = resp->chip_rev;
        softc->ver_info->chip_metal = resp->chip_metal;
        softc->ver_info->chip_bond_id = resp->chip_bond_id;
        softc->ver_info->chip_type = resp->chip_platform_type;
#endif

        if (resp->max_req_win_len)
                softc->sc_max_req_len = le16toh(resp->max_req_win_len);
        if (resp->def_req_timeout)
                softc->sc_cmd_timeo = le16toh(resp->def_req_timeout);

        dev_caps_cfg = le32toh(resp->dev_caps_cfg);
        if ((dev_caps_cfg & HWRM_VER_GET_OUTPUT_DEV_CAPS_CFG_SHORT_CMD_SUPPORTED) &&
            (dev_caps_cfg & HWRM_VER_GET_OUTPUT_DEV_CAPS_CFG_SHORT_CMD_REQUIRED))
                softc->sc_flags |= BNXT_FLAG_SHORT_CMD;

fail:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}


int
bnxt_hwrm_func_drv_rgtr(struct bnxt_softc *softc)
{
        struct hwrm_func_drv_rgtr_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_RGTR);

        req.enables = htole32(HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_VER |
            HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_OS_TYPE);
        req.os_type = htole16(HWRM_FUNC_DRV_RGTR_INPUT_OS_TYPE_FREEBSD);

        req.ver_maj = 6;
        req.ver_min = 4;
        req.ver_upd = 0;

        return hwrm_send_message(softc, &req, sizeof(req));
}

#if 0

int
bnxt_hwrm_func_drv_unrgtr(struct bnxt_softc *softc, bool shutdown)
{
        struct hwrm_func_drv_unrgtr_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_UNRGTR);
        if (shutdown == true)
                req.flags |=
                    HWRM_FUNC_DRV_UNRGTR_INPUT_FLAGS_PREPARE_FOR_SHUTDOWN;
        return hwrm_send_message(softc, &req, sizeof(req));
}

#endif

int
bnxt_hwrm_func_qcaps(struct bnxt_softc *softc)
{
        int rc = 0;
        struct hwrm_func_qcaps_input req = {0};
        struct hwrm_func_qcaps_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        /* struct bnxt_func_info *func = &softc->func; */

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_QCAPS);
        req.fid = htole16(0xffff);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        if (resp->flags &
            htole32(HWRM_FUNC_QCAPS_OUTPUT_FLAGS_WOL_MAGICPKT_SUPPORTED))
                softc->sc_flags |= BNXT_FLAG_WOL_CAP;

        memcpy(softc->sc_ac.ac_enaddr, resp->mac_address, 6);
        /*
        func->fw_fid = le16toh(resp->fid);
        memcpy(func->mac_addr, resp->mac_address, ETHER_ADDR_LEN);
        func->max_rsscos_ctxs = le16toh(resp->max_rsscos_ctx);
        func->max_cp_rings = le16toh(resp->max_cmpl_rings);
        func->max_tx_rings = le16toh(resp->max_tx_rings);
        func->max_rx_rings = le16toh(resp->max_rx_rings);
        func->max_hw_ring_grps = le32toh(resp->max_hw_ring_grps);
        if (!func->max_hw_ring_grps)
                func->max_hw_ring_grps = func->max_tx_rings;
        func->max_l2_ctxs = le16toh(resp->max_l2_ctxs);
        func->max_vnics = le16toh(resp->max_vnics);
        func->max_stat_ctxs = le16toh(resp->max_stat_ctx);
        if (BNXT_PF(softc)) {
                struct bnxt_pf_info *pf = &softc->pf;

                pf->port_id = le16toh(resp->port_id);
                pf->first_vf_id = le16toh(resp->first_vf_id);
                pf->max_vfs = le16toh(resp->max_vfs);
                pf->max_encap_records = le32toh(resp->max_encap_records);
                pf->max_decap_records = le32toh(resp->max_decap_records);
                pf->max_tx_em_flows = le32toh(resp->max_tx_em_flows);
                pf->max_tx_wm_flows = le32toh(resp->max_tx_wm_flows);
                pf->max_rx_em_flows = le32toh(resp->max_rx_em_flows);
                pf->max_rx_wm_flows = le32toh(resp->max_rx_wm_flows);
        }
        if (!_is_valid_ether_addr(func->mac_addr)) {
                device_printf(softc->dev, "Invalid ethernet address, generating random locally administered address\n");
                get_random_ether_addr(func->mac_addr);
        }
        */

fail:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}


int
bnxt_hwrm_func_qcfg(struct bnxt_softc *softc)
{
        struct hwrm_func_qcfg_input req = {0};
        /* struct hwrm_func_qcfg_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        struct bnxt_func_qcfg *fn_qcfg = &softc->fn_qcfg; */
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_QCFG);
        req.fid = htole16(0xffff);
        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        /*
        fn_qcfg->alloc_completion_rings = le16toh(resp->alloc_cmpl_rings);
        fn_qcfg->alloc_tx_rings = le16toh(resp->alloc_tx_rings);
        fn_qcfg->alloc_rx_rings = le16toh(resp->alloc_rx_rings);
        fn_qcfg->alloc_vnics = le16toh(resp->alloc_vnics);
        */
fail:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}


int
bnxt_hwrm_func_reset(struct bnxt_softc *softc)
{
        struct hwrm_func_reset_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_RESET);
        req.enables = 0;

        return hwrm_send_message(softc, &req, sizeof(req));
}

#if 0
static void
bnxt_hwrm_set_link_common(struct bnxt_softc *softc,
    struct hwrm_port_phy_cfg_input *req)
{
        uint8_t autoneg = softc->link_info.autoneg;
        uint16_t fw_link_speed = softc->link_info.req_link_speed;

        if (autoneg & BNXT_AUTONEG_SPEED) {
                req->auto_mode |=
                    HWRM_PORT_PHY_CFG_INPUT_AUTO_MODE_ALL_SPEEDS;

                req->enables |=
                    htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_AUTO_MODE);
                req->flags |=
                    htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_RESTART_AUTONEG);
        } else {
                req->force_link_speed = htole16(fw_link_speed);
                req->flags |= htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_FORCE);
        }

        /* tell chimp that the setting takes effect immediately */
        req->flags |= htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_RESET_PHY);
}


static void
bnxt_hwrm_set_pause_common(struct bnxt_softc *softc,
    struct hwrm_port_phy_cfg_input *req)
{
        struct bnxt_link_info *link_info = &softc->link_info;

        if (link_info->flow_ctrl.autoneg) {
                req->auto_pause =
                    HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_AUTONEG_PAUSE;
                if (link_info->flow_ctrl.rx)
                        req->auto_pause |=
                            HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_RX;
                if (link_info->flow_ctrl.tx)
                        req->auto_pause |=
                            HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_TX;
                req->enables |=
                    htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_AUTO_PAUSE);
        } else {
                if (link_info->flow_ctrl.rx)
                        req->force_pause |=
                            HWRM_PORT_PHY_CFG_INPUT_FORCE_PAUSE_RX;
                if (link_info->flow_ctrl.tx)
                        req->force_pause |=
                            HWRM_PORT_PHY_CFG_INPUT_FORCE_PAUSE_TX;
                req->enables |=
                        htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_FORCE_PAUSE);
        }
}


/* JFV this needs interface connection */
static void
bnxt_hwrm_set_eee(struct bnxt_softc *softc, struct hwrm_port_phy_cfg_input *req)
{
        /* struct ethtool_eee *eee = &softc->eee; */
        bool eee_enabled = false;

        if (eee_enabled) {
# i f 0
                uint16_t eee_speeds;
                uint32_t flags = HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_ENABLE;

                if (eee->tx_lpi_enabled)
                        flags |= HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_TX_LPI;

                req->flags |= htole32(flags);
                eee_speeds = bnxt_get_fw_auto_link_speeds(eee->advertised);
                req->eee_link_speed_mask = htole16(eee_speeds);
                req->tx_lpi_timer = htole32(eee->tx_lpi_timer);
# e n d i f
        } else {
                req->flags |=
                    htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_DISABLE);
        }
}


int
bnxt_hwrm_set_link_setting(struct bnxt_softc *softc, bool set_pause,
    bool set_eee, bool set_link)
{
        struct hwrm_port_phy_cfg_input req = {0};
        int rc;

        if (softc->sc_flags & BNXT_FLAG_NPAR)
                return ENOTSUP;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_PHY_CFG);
       
        if (set_pause) {
                bnxt_hwrm_set_pause_common(softc, &req);

                if (softc->link_info.flow_ctrl.autoneg)
                        set_link = true;
        }

        if (set_link)
                bnxt_hwrm_set_link_common(softc, &req);
       
        if (set_eee)
                bnxt_hwrm_set_eee(softc, &req);
       
        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));

        if (!rc) {
                if (set_pause) {
                        /* since changing of 'force pause' setting doesn't
                         * trigger any link change event, the driver needs to
                         * update the current pause result upon successfully i
                         * return of the phy_cfg command */
                        if (!softc->link_info.flow_ctrl.autoneg)
                                bnxt_report_link(softc);
                }
        }
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

#endif

int
bnxt_hwrm_vnic_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
{
        struct hwrm_vnic_cfg_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_CFG);

        if (vnic->flags & BNXT_VNIC_FLAG_DEFAULT)
                req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_DEFAULT);
        if (vnic->flags & BNXT_VNIC_FLAG_BD_STALL)
                req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_BD_STALL_MODE);
        if (vnic->flags & BNXT_VNIC_FLAG_VLAN_STRIP)
                req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_VLAN_STRIP_MODE);
        req.enables = htole32(HWRM_VNIC_CFG_INPUT_ENABLES_DFLT_RING_GRP |
            HWRM_VNIC_CFG_INPUT_ENABLES_RSS_RULE |
            HWRM_VNIC_CFG_INPUT_ENABLES_MRU);
        req.vnic_id = htole16(vnic->id);
        req.dflt_ring_grp = htole16(vnic->def_ring_grp);
        req.rss_rule = htole16(vnic->rss_id);
        req.cos_rule = htole16(vnic->cos_rule);
        req.lb_rule = htole16(vnic->lb_rule);
        req.mru = htole16(vnic->mru);

        return hwrm_send_message(softc, &req, sizeof(req));
}

int
bnxt_hwrm_vnic_alloc(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
{
        struct hwrm_vnic_alloc_input req = {0};
        struct hwrm_vnic_alloc_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        int rc;

        if (vnic->id != (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to re-allocate vnic %04x\n",
                    DEVNAME(softc), vnic->id);
                return EINVAL;
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_ALLOC);

        if (vnic->flags & BNXT_VNIC_FLAG_DEFAULT)
                req.flags = htole32(HWRM_VNIC_ALLOC_INPUT_FLAGS_DEFAULT);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        vnic->id = le32toh(resp->vnic_id);

fail:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_vnic_free(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
{
        struct hwrm_vnic_free_input req = {0};
        int rc;

        if (vnic->id == (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to deallocate vnic %04x\n",
                    DEVNAME(softc), vnic->id);
                return (EINVAL);
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_FREE);
        req.vnic_id = htole16(vnic->id);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc == 0)
                vnic->id = (uint16_t)HWRM_NA_SIGNATURE;
        BNXT_HWRM_UNLOCK(softc);

        return (rc);
}

int
bnxt_hwrm_vnic_ctx_alloc(struct bnxt_softc *softc, uint16_t *ctx_id)
{
        struct hwrm_vnic_rss_cos_lb_ctx_alloc_input req = {0};
        struct hwrm_vnic_rss_cos_lb_ctx_alloc_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        int rc;

        if (*ctx_id != (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to re-allocate vnic ctx %04x\n",
                    DEVNAME(softc), *ctx_id);
                return EINVAL;
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_COS_LB_CTX_ALLOC);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        *ctx_id = letoh16(resp->rss_cos_lb_ctx_id);

fail:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_vnic_ctx_free(struct bnxt_softc *softc, uint16_t *ctx_id)
{
        struct hwrm_vnic_rss_cos_lb_ctx_free_input req = {0};
        int rc;

        if (*ctx_id == (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to deallocate vnic ctx %04x\n",
                    DEVNAME(softc), *ctx_id);
                return (EINVAL);
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_COS_LB_CTX_FREE);
        req.rss_cos_lb_ctx_id = htole32(*ctx_id);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc == 0)
                *ctx_id = (uint16_t)HWRM_NA_SIGNATURE;
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_ring_grp_alloc(struct bnxt_softc *softc, struct bnxt_grp_info *grp)
{
        struct hwrm_ring_grp_alloc_input req = {0};
        struct hwrm_ring_grp_alloc_output *resp;
        int rc = 0;

        if (grp->grp_id != HWRM_NA_SIGNATURE) {
                printf("%s: attempt to re-allocate ring group %04x\n",
                    DEVNAME(softc), grp->grp_id);
                return EINVAL;
        }

        resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_GRP_ALLOC);
        req.cr = htole16(grp->cp_ring_id);
        req.rr = htole16(grp->rx_ring_id);
        req.ar = htole16(grp->ag_ring_id);
        req.sc = htole16(grp->stats_ctx);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        grp->grp_id = letoh32(resp->ring_group_id);

fail:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_ring_grp_free(struct bnxt_softc *softc, struct bnxt_grp_info *grp)
{
        struct hwrm_ring_grp_free_input req = {0};
        int rc = 0;

        if (grp->grp_id == HWRM_NA_SIGNATURE) {
                printf("%s: attempt to free ring group %04x\n",
                    DEVNAME(softc), grp->grp_id);
                return EINVAL;
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_GRP_FREE);
        req.ring_group_id = htole32(grp->grp_id);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc == 0)
                grp->grp_id = HWRM_NA_SIGNATURE;

        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

/*
 * Ring allocation message to the firmware
 */
int
bnxt_hwrm_ring_alloc(struct bnxt_softc *softc, uint8_t type,
    struct bnxt_ring *ring, uint16_t cmpl_ring_id, uint32_t stat_ctx_id,
    int irq)
{
        struct hwrm_ring_alloc_input req = {0};
        struct hwrm_ring_alloc_output *resp;
        int rc;

        if (ring->phys_id != (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to re-allocate ring %04x\n",
                    DEVNAME(softc), ring->phys_id);
                return EINVAL;
        }

        resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_ALLOC);
        req.enables = htole32(0);
        req.fbo = htole32(0);

        if (stat_ctx_id != HWRM_NA_SIGNATURE) {
                req.enables |= htole32(
                    HWRM_RING_ALLOC_INPUT_ENABLES_STAT_CTX_ID_VALID);
                req.stat_ctx_id = htole32(stat_ctx_id);
        }
        req.ring_type = type;
        req.page_tbl_addr = htole64(ring->paddr);
        req.length = htole32(ring->ring_size);
        req.logical_id = htole16(ring->id);
        req.cmpl_ring_id = htole16(cmpl_ring_id);
        req.queue_id = htole16(softc->sc_q_info[0].id);
        req.int_mode = 0;
        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        ring->phys_id = le16toh(resp->ring_id);

fail:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_ring_free(struct bnxt_softc *softc, uint8_t type, struct bnxt_ring *ring)
{
        struct hwrm_ring_free_input req = {0};
        int rc;

        if (ring->phys_id == (uint16_t)HWRM_NA_SIGNATURE) {
                printf("%s: attempt to deallocate ring %04x\n",
                    DEVNAME(softc), ring->phys_id);
                return (EINVAL);
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_FREE);
        req.ring_type = type;
        req.ring_id = htole16(ring->phys_id);
        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        ring->phys_id = (uint16_t)HWRM_NA_SIGNATURE;
fail:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}


int
bnxt_hwrm_stat_ctx_alloc(struct bnxt_softc *softc, struct bnxt_cp_ring *cpr,
    uint64_t paddr)
{
        struct hwrm_stat_ctx_alloc_input req = {0};
        struct hwrm_stat_ctx_alloc_output *resp;
        int rc = 0;

        if (cpr->stats_ctx_id != HWRM_NA_SIGNATURE) {
                printf("%s: attempt to re-allocate stats ctx %08x\n",
                    DEVNAME(softc), cpr->stats_ctx_id);
                return EINVAL;
        }

        resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_STAT_CTX_ALLOC);

        req.update_period_ms = htole32(1000);
        req.stats_dma_addr = htole64(paddr);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        cpr->stats_ctx_id = le32toh(resp->stat_ctx_id);

fail:
        BNXT_HWRM_UNLOCK(softc);

        return rc;
}

int
bnxt_hwrm_stat_ctx_free(struct bnxt_softc *softc, struct bnxt_cp_ring *cpr)
{
        struct hwrm_stat_ctx_free_input req = {0};
        int rc = 0;

        if (cpr->stats_ctx_id == HWRM_NA_SIGNATURE) {
                printf("%s: attempt to free stats ctx %08x\n",
                    DEVNAME(softc), cpr->stats_ctx_id);
                return EINVAL;
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_STAT_CTX_FREE);
        req.stat_ctx_id = htole32(cpr->stats_ctx_id);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        BNXT_HWRM_UNLOCK(softc);

        if (rc == 0)
                cpr->stats_ctx_id = HWRM_NA_SIGNATURE;

        return (rc);
}

#if 0

int
bnxt_hwrm_port_qstats(struct bnxt_softc *softc)
{
        struct hwrm_port_qstats_input req = {0};
        int rc = 0;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_QSTATS);

        req.port_id = htole16(softc->pf.port_id);
        req.rx_stat_host_addr = htole64(softc->hw_rx_port_stats.idi_paddr);
        req.tx_stat_host_addr = htole64(softc->hw_tx_port_stats.idi_paddr);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        BNXT_HWRM_UNLOCK(softc);

        return rc;
}

#endif

int
bnxt_hwrm_cfa_l2_set_rx_mask(struct bnxt_softc *softc,
    struct bnxt_vnic_info *vnic)
{
        struct hwrm_cfa_l2_set_rx_mask_input req = {0};
        uint32_t mask = vnic->rx_mask;

#if 0
        struct bnxt_vlan_tag *tag;
        uint32_t *tags;
        uint32_t num_vlan_tags = 0;;
        uint32_t i;
        int rc;

        SLIST_FOREACH(tag, &vnic->vlan_tags, next)
                num_vlan_tags++;

        if (num_vlan_tags) {
                if (!(mask &
                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN)) {
                        if (!vnic->vlan_only)
                                mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLAN_NONVLAN;
                        else
                                mask |=
                                    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLANONLY;
                }
                if (vnic->vlan_tag_list.idi_vaddr) {
                        iflib_dma_free(&vnic->vlan_tag_list);
                        vnic->vlan_tag_list.idi_vaddr = NULL;
                }
                rc = iflib_dma_alloc(softc->ctx, 4 * num_vlan_tags,
                    &vnic->vlan_tag_list, BUS_DMA_NOWAIT);
                if (rc)
                        return rc;
                tags = (uint32_t *)vnic->vlan_tag_list.idi_vaddr;

                i = 0;
                SLIST_FOREACH(tag, &vnic->vlan_tags, next) {
                        tags[i] = htole32((tag->tpid << 16) | tag->tag);
                        i++;
                }
        }
#endif
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_SET_RX_MASK);

        req.vnic_id = htole32(vnic->id);
        req.mask = htole32(mask);
#if 0
        req.mc_tbl_addr = htole64(vnic->mc_list.idi_paddr);
        req.num_mc_entries = htole32(vnic->mc_list_count);
        req.vlan_tag_tbl_addr = htole64(vnic->vlan_tag_list.idi_paddr);
        req.num_vlan_tags = htole32(num_vlan_tags);
#endif
        return hwrm_send_message(softc, &req, sizeof(req));
}

int
bnxt_hwrm_set_filter(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
{
        struct hwrm_cfa_l2_filter_alloc_input req = {0};
        struct hwrm_cfa_l2_filter_alloc_output *resp;
        uint32_t enables = 0;
        int rc = 0;

        if (vnic->filter_id != -1) {
                printf("%s: attempt to re-allocate l2 ctx filter\n",
                    DEVNAME(softc));
                return EINVAL;
        }

        resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_FILTER_ALLOC);

        req.flags = htole32(HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX);
        enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR
            | HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK
            | HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_DST_ID;
        req.enables = htole32(enables);
        req.dst_id = htole16(vnic->id);
        memcpy(req.l2_addr, softc->sc_ac.ac_enaddr, ETHER_ADDR_LEN);
        memset(&req.l2_addr_mask, 0xff, sizeof(req.l2_addr_mask));

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto fail;

        vnic->filter_id = le64toh(resp->l2_filter_id);
        vnic->flow_id = le64toh(resp->flow_id);

fail:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_free_filter(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
{
        struct hwrm_cfa_l2_filter_free_input req = {0};
        int rc = 0;

        if (vnic->filter_id == -1) {
                printf("%s: attempt to deallocate filter %llx\n",
                     DEVNAME(softc), vnic->filter_id);
                return (EINVAL);
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_FILTER_FREE);
        req.l2_filter_id = htole64(vnic->filter_id);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc == 0)
                vnic->filter_id = -1;
        BNXT_HWRM_UNLOCK(softc);

        return (rc);
}


#if 0

int
bnxt_hwrm_rss_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic,
    uint32_t hash_type)
{
        struct hwrm_vnic_rss_cfg_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_CFG);

        req.hash_type = htole32(hash_type);
        req.ring_grp_tbl_addr = htole64(vnic->rss_grp_tbl.idi_paddr);
        req.hash_key_tbl_addr = htole64(vnic->rss_hash_key_tbl.idi_paddr);
        req.rss_ctx_idx = htole16(vnic->rss_id);

        return hwrm_send_message(softc, &req, sizeof(req));
}

#endif

int
bnxt_cfg_async_cr(struct bnxt_softc *softc)
{
        int rc = 0;
       
        if (1 /* BNXT_PF(softc) */) {
                struct hwrm_func_cfg_input req = {0};

                bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_CFG);

                req.fid = htole16(0xffff);
                req.enables = htole32(HWRM_FUNC_CFG_INPUT_ENABLES_ASYNC_EVENT_CR);
                req.async_event_cr = htole16(softc->sc_cp_ring.ring.phys_id);

                rc = hwrm_send_message(softc, &req, sizeof(req));
        } else {
                struct hwrm_func_vf_cfg_input req = {0};

                bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_VF_CFG);

                req.enables = htole32(HWRM_FUNC_VF_CFG_INPUT_ENABLES_ASYNC_EVENT_CR);
                req.async_event_cr = htole16(softc->sc_cp_ring.ring.phys_id);

                rc = hwrm_send_message(softc, &req, sizeof(req));
        }
        return rc;
}

#if 0

void
bnxt_validate_hw_lro_settings(struct bnxt_softc *softc)
{
        softc->hw_lro.enable = min(softc->hw_lro.enable, 1);

        softc->hw_lro.is_mode_gro = min(softc->hw_lro.is_mode_gro, 1);

        softc->hw_lro.max_agg_segs = min(softc->hw_lro.max_agg_segs,
                HWRM_VNIC_TPA_CFG_INPUT_MAX_AGG_SEGS_MAX);

        softc->hw_lro.max_aggs = min(softc->hw_lro.max_aggs,
                HWRM_VNIC_TPA_CFG_INPUT_MAX_AGGS_MAX);

        softc->hw_lro.min_agg_len = min(softc->hw_lro.min_agg_len, BNXT_MAX_MTU);
}

int
bnxt_hwrm_vnic_tpa_cfg(struct bnxt_softc *softc)
{
        struct hwrm_vnic_tpa_cfg_input req = {0};
        uint32_t flags;

        if (softc->vnic_info.id == (uint16_t) HWRM_NA_SIGNATURE) {
                return 0;
        }

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_TPA_CFG);

        if (softc->hw_lro.enable) {
                flags = HWRM_VNIC_TPA_CFG_INPUT_FLAGS_TPA |
                        HWRM_VNIC_TPA_CFG_INPUT_FLAGS_ENCAP_TPA |
                        HWRM_VNIC_TPA_CFG_INPUT_FLAGS_AGG_WITH_ECN |
                        HWRM_VNIC_TPA_CFG_INPUT_FLAGS_AGG_WITH_SAME_GRE_SEQ;
               
        if (softc->hw_lro.is_mode_gro)
                        flags |= HWRM_VNIC_TPA_CFG_INPUT_FLAGS_GRO;
                else
                        flags |= HWRM_VNIC_TPA_CFG_INPUT_FLAGS_RSC_WND_UPDATE;
                       
                req.flags = htole32(flags);

                req.enables = htole32(HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MAX_AGG_SEGS |
                                HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MAX_AGGS |
                                HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MIN_AGG_LEN);

                req.max_agg_segs = htole16(softc->hw_lro.max_agg_segs);
                req.max_aggs = htole16(softc->hw_lro.max_aggs);
                req.min_agg_len = htole32(softc->hw_lro.min_agg_len);
        }

        req.vnic_id = htole16(softc->vnic_info.id);

        return hwrm_send_message(softc, &req, sizeof(req));
}

int
bnxt_hwrm_nvm_find_dir_entry(struct bnxt_softc *softc, uint16_t type,
    uint16_t *ordinal, uint16_t ext, uint16_t *index, bool use_index,
    uint8_t search_opt, uint32_t *data_length, uint32_t *item_length,
    uint32_t *fw_ver)
{
        struct hwrm_nvm_find_dir_entry_input req = {0};
        struct hwrm_nvm_find_dir_entry_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc = 0;
        uint32_t old_timeo;

        MPASS(ordinal);

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_FIND_DIR_ENTRY);
        if (use_index) {
                req.enables = htole32(
                    HWRM_NVM_FIND_DIR_ENTRY_INPUT_ENABLES_DIR_IDX_VALID);
                req.dir_idx = htole16(*index);
        }
        req.dir_type = htole16(type);
        req.dir_ordinal = htole16(*ordinal);
        req.dir_ext = htole16(ext);
        req.opt_ordinal = search_opt;

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        if (rc)
                goto exit;

        if (item_length)
                *item_length = le32toh(resp->dir_item_length);
        if (data_length)
                *data_length = le32toh(resp->dir_data_length);
        if (fw_ver)
                *fw_ver = le32toh(resp->fw_ver);
        *ordinal = le16toh(resp->dir_ordinal);
        if (index)
                *index = le16toh(resp->dir_idx);

exit:
        BNXT_HWRM_UNLOCK(softc);
        return (rc);
}

int
bnxt_hwrm_nvm_read(struct bnxt_softc *softc, uint16_t index, uint32_t offset,
    uint32_t length, struct iflib_dma_info *data)
{
        struct hwrm_nvm_read_input req = {0};
        int rc;
        uint32_t old_timeo;

        if (length > data->idi_size) {
                rc = EINVAL;
                goto exit;
        }
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_READ);
        req.host_dest_addr = htole64(data->idi_paddr);
        req.dir_idx = htole16(index);
        req.offset = htole32(offset);
        req.len = htole32(length);
        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        BNXT_HWRM_UNLOCK(softc);
        if (rc)
                goto exit;
        bus_dmamap_sync(data->idi_tag, data->idi_map, BUS_DMASYNC_POSTREAD);

        goto exit;

exit:
        return rc;
}

int
bnxt_hwrm_nvm_modify(struct bnxt_softc *softc, uint16_t index, uint32_t offset,
    void *data, bool cpyin, uint32_t length)
{
        struct hwrm_nvm_modify_input req = {0};
        struct iflib_dma_info dma_data;
        int rc;
        uint32_t old_timeo;

        if (length == 0 || !data)
                return EINVAL;
        rc = iflib_dma_alloc(softc->ctx, length, &dma_data,
            BUS_DMA_NOWAIT);
        if (rc)
                return ENOMEM;
        if (cpyin) {
                rc = copyin(data, dma_data.idi_vaddr, length);
                if (rc)
                        goto exit;
        }
        else
                memcpy(dma_data.idi_vaddr, data, length);
        bus_dmamap_sync(dma_data.idi_tag, dma_data.idi_map,
            BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_MODIFY);
        req.host_src_addr = htole64(dma_data.idi_paddr);
        req.dir_idx = htole16(index);
        req.offset = htole32(offset);
        req.len = htole32(length);
        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        BNXT_HWRM_UNLOCK(softc);

exit:
        iflib_dma_free(&dma_data);
        return rc;
}

int
bnxt_hwrm_fw_reset(struct bnxt_softc *softc, uint8_t processor,
    uint8_t *selfreset)
{
        struct hwrm_fw_reset_input req = {0};
        struct hwrm_fw_reset_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;

        MPASS(selfreset);

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_RESET);
        req.embedded_proc_type = processor;
        req.selfrst_status = *selfreset;

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto exit;
        *selfreset = resp->selfrst_status;

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_fw_qstatus(struct bnxt_softc *softc, uint8_t type, uint8_t *selfreset)
{
        struct hwrm_fw_qstatus_input req = {0};
        struct hwrm_fw_qstatus_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;

        MPASS(selfreset);

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_QSTATUS);
        req.embedded_proc_type = type;

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto exit;
        *selfreset = resp->selfrst_status;

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_nvm_write(struct bnxt_softc *softc, void *data, bool cpyin,
    uint16_t type, uint16_t ordinal, uint16_t ext, uint16_t attr,
    uint16_t option, uint32_t data_length, bool keep, uint32_t *item_length,
    uint16_t *index)
{
        struct hwrm_nvm_write_input req = {0};
        struct hwrm_nvm_write_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        struct iflib_dma_info dma_data;
        int rc;
        uint32_t old_timeo;

        if (data_length) {
                rc = iflib_dma_alloc(softc->ctx, data_length, &dma_data,
                    BUS_DMA_NOWAIT);
                if (rc)
                        return ENOMEM;
                if (cpyin) {
                        rc = copyin(data, dma_data.idi_vaddr, data_length);
                        if (rc)
                                goto early_exit;
                }
                else
                        memcpy(dma_data.idi_vaddr, data, data_length);
                bus_dmamap_sync(dma_data.idi_tag, dma_data.idi_map,
                    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
        }
        else
                dma_data.idi_paddr = 0;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_WRITE);

        req.host_src_addr = htole64(dma_data.idi_paddr);
        req.dir_type = htole16(type);
        req.dir_ordinal = htole16(ordinal);
        req.dir_ext = htole16(ext);
        req.dir_attr = htole16(attr);
        req.dir_data_length = htole32(data_length);
        req.option = htole16(option);
        if (keep) {
                req.flags =
                    htole16(HWRM_NVM_WRITE_INPUT_FLAGS_KEEP_ORIG_ACTIVE_IMG);
        }
        if (item_length)
                req.dir_item_length = htole32(*item_length);

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        if (rc)
                goto exit;
        if (item_length)
                *item_length = le32toh(resp->dir_item_length);
        if (index)
                *index = le16toh(resp->dir_idx);

exit:
        BNXT_HWRM_UNLOCK(softc);
early_exit:
        if (data_length)
                iflib_dma_free(&dma_data);
        return rc;
}

int
bnxt_hwrm_nvm_erase_dir_entry(struct bnxt_softc *softc, uint16_t index)
{
        struct hwrm_nvm_erase_dir_entry_input req = {0};
        uint32_t old_timeo;
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_ERASE_DIR_ENTRY);
        req.dir_idx = htole16(index);
        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_nvm_get_dir_info(struct bnxt_softc *softc, uint32_t *entries,
    uint32_t *entry_length)
{
        struct hwrm_nvm_get_dir_info_input req = {0};
        struct hwrm_nvm_get_dir_info_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;
        uint32_t old_timeo;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DIR_INFO);

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        if (rc)
                goto exit;

        if (entries)
                *entries = le32toh(resp->entries);
        if (entry_length)
                *entry_length = le32toh(resp->entry_length);

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_nvm_get_dir_entries(struct bnxt_softc *softc, uint32_t *entries,
    uint32_t *entry_length, struct iflib_dma_info *dma_data)
{
        struct hwrm_nvm_get_dir_entries_input req = {0};
        uint32_t ent;
        uint32_t ent_len;
        int rc;
        uint32_t old_timeo;

        if (!entries)
                entries = &ent;
        if (!entry_length)
                entry_length = &ent_len;

        rc = bnxt_hwrm_nvm_get_dir_info(softc, entries, entry_length);
        if (rc)
                goto exit;
        if (*entries * *entry_length > dma_data->idi_size) {
                rc = EINVAL;
                goto exit;
        }

        /*
         * TODO: There's a race condition here that could blow up DMA memory...
         * we need to allocate the max size, not the currently in use
         * size.  The command should totally have a max size here.
         */
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DIR_ENTRIES);
        req.host_dest_addr = htole64(dma_data->idi_paddr);
        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        BNXT_HWRM_UNLOCK(softc);
        if (rc)
                goto exit;
        bus_dmamap_sync(dma_data->idi_tag, dma_data->idi_map,
            BUS_DMASYNC_POSTWRITE);

exit:
        return rc;
}

#endif

int
bnxt_hwrm_nvm_get_dev_info(struct bnxt_softc *softc, uint16_t *mfg_id,
    uint16_t *device_id, uint32_t *sector_size, uint32_t *nvram_size,
    uint32_t *reserved_size, uint32_t *available_size)
{
        struct hwrm_nvm_get_dev_info_input req = {0};
        struct hwrm_nvm_get_dev_info_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        int rc;
        uint32_t old_timeo;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DEV_INFO);

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->sc_cmd_timeo;
        softc->sc_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->sc_cmd_timeo = old_timeo;
        if (rc)
                goto exit;

        if (mfg_id)
                *mfg_id = le16toh(resp->manufacturer_id);
        if (device_id)
                *device_id = le16toh(resp->device_id);
        if (sector_size)
                *sector_size = le32toh(resp->sector_size);
        if (nvram_size)
                *nvram_size = le32toh(resp->nvram_size);
        if (reserved_size)
                *reserved_size = le32toh(resp->reserved_size);
        if (available_size)
                *available_size = le32toh(resp->available_size);

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

#if 0

int
bnxt_hwrm_nvm_install_update(struct bnxt_softc *softc,
    uint32_t install_type, uint64_t *installed_items, uint8_t *result,
    uint8_t *problem_item, uint8_t *reset_required)
{
        struct hwrm_nvm_install_update_input req = {0};
        struct hwrm_nvm_install_update_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;
        uint32_t old_timeo;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_INSTALL_UPDATE);
        req.install_type = htole32(install_type);

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        if (rc)
                goto exit;

        if (installed_items)
                *installed_items = le32toh(resp->installed_items);
        if (result)
                *result = resp->result;
        if (problem_item)
                *problem_item = resp->problem_item;
        if (reset_required)
                *reset_required = resp->reset_required;

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_nvm_verify_update(struct bnxt_softc *softc, uint16_t type,
    uint16_t ordinal, uint16_t ext)
{
        struct hwrm_nvm_verify_update_input req = {0};
        uint32_t old_timeo;
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_VERIFY_UPDATE);

        req.dir_type = htole16(type);
        req.dir_ordinal = htole16(ordinal);
        req.dir_ext = htole16(ext);

        BNXT_HWRM_LOCK(softc);
        old_timeo = softc->hwrm_cmd_timeo;
        softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        softc->hwrm_cmd_timeo = old_timeo;
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_fw_get_time(struct bnxt_softc *softc, uint16_t *year, uint8_t *month,
    uint8_t *day, uint8_t *hour, uint8_t *minute, uint8_t *second,
    uint16_t *millisecond, uint16_t *zone)
{
        struct hwrm_fw_get_time_input req = {0};
        struct hwrm_fw_get_time_output *resp =
            (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_GET_TIME);

        BNXT_HWRM_LOCK(softc);
        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc)
                goto exit;

        if (year)
                *year = le16toh(resp->year);
        if (month)
                *month = resp->month;
        if (day)
                *day = resp->day;
        if (hour)
                *hour = resp->hour;
        if (minute)
                *minute = resp->minute;
        if (second)
                *second = resp->second;
        if (millisecond)
                *millisecond = le16toh(resp->millisecond);
        if (zone)
                *zone = le16toh(resp->zone);

exit:
        BNXT_HWRM_UNLOCK(softc);
        return rc;
}

int
bnxt_hwrm_fw_set_time(struct bnxt_softc *softc, uint16_t year, uint8_t month,
    uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
    uint16_t millisecond, uint16_t zone)
{
        struct hwrm_fw_set_time_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_SET_TIME);

        req.year = htole16(year);
        req.month = month;
        req.day = day;
        req.hour = hour;
        req.minute = minute;
        req.second = second;
        req.millisecond = htole16(millisecond);
        req.zone = htole16(zone);
        return hwrm_send_message(softc, &req, sizeof(req));
}

#endif

int
bnxt_hwrm_port_phy_qcfg(struct bnxt_softc *softc, struct ifmediareq *ifmr)
{
        struct ifnet *ifp = &softc->sc_ac.ac_if;
        struct hwrm_port_phy_qcfg_input req = {0};
        struct hwrm_port_phy_qcfg_output *resp =
            BNXT_DMA_KVA(softc->sc_cmd_resp);
        int rc = 0;
        int link_state = LINK_STATE_DOWN;

        BNXT_HWRM_LOCK(softc);
        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_PHY_QCFG);

        rc = _hwrm_send_message(softc, &req, sizeof(req));
        if (rc) {
                printf("%s: failed to query port phy config\n", DEVNAME(softc));
                goto exit;
        }

        if (resp->link == HWRM_PORT_PHY_QCFG_OUTPUT_LINK_LINK) {
                if (resp->duplex_state == HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_STATE_HALF)
                        link_state = LINK_STATE_HALF_DUPLEX;
                else
                        link_state = LINK_STATE_FULL_DUPLEX;

                switch (resp->link_speed) {
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10MB:
                        ifp->if_baudrate = IF_Mbps(10);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100MB:
                        ifp->if_baudrate = IF_Mbps(100);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_1GB:
                        ifp->if_baudrate = IF_Gbps(1);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2GB:
                        ifp->if_baudrate = IF_Gbps(2);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2_5GB:
                        ifp->if_baudrate = IF_Mbps(2500);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10GB:
                        ifp->if_baudrate = IF_Gbps(10);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_20GB:
                        ifp->if_baudrate = IF_Gbps(20);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_25GB:
                        ifp->if_baudrate = IF_Gbps(25);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_40GB:
                        ifp->if_baudrate = IF_Gbps(40);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_50GB:
                        ifp->if_baudrate = IF_Gbps(50);
                        break;
                case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100GB:
                        ifp->if_baudrate = IF_Gbps(100);
                        break;
                }
        }

        if (ifmr != NULL) {
                ifmr->ifm_status = IFM_AVALID;
                if (LINK_STATE_IS_UP(ifp->if_link_state)) {
                        ifmr->ifm_status |= IFM_ACTIVE;
                        ifmr->ifm_active = IFM_ETHER | IFM_AUTO;
                        if (resp->pause & HWRM_PORT_PHY_QCFG_OUTPUT_PAUSE_TX)
                                ifmr->ifm_active |= IFM_ETH_TXPAUSE;
                        if (resp->pause & HWRM_PORT_PHY_QCFG_OUTPUT_PAUSE_RX)
                                ifmr->ifm_active |= IFM_ETH_RXPAUSE;
                        if (resp->duplex_state == HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_STATE_HALF)
                                ifmr->ifm_active |= IFM_HDX;
                        else
                                ifmr->ifm_active |= IFM_FDX;
                }
        }

exit:
        BNXT_HWRM_UNLOCK(softc);

        if (rc == 0 && (link_state != ifp->if_link_state)) {
                ifp->if_link_state = link_state;
                if_link_state_change(ifp);
        }

        return rc;
}

#if 0

uint16_t
bnxt_hwrm_get_wol_fltrs(struct bnxt_softc *softc, uint16_t handle)
{
        struct hwrm_wol_filter_qcfg_input req = {0};
        struct hwrm_wol_filter_qcfg_output *resp =
                        (void *)softc->hwrm_cmd_resp.idi_vaddr;
        uint16_t next_handle = 0;
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_QCFG);
        req.port_id = htole16(softc->pf.port_id);
        req.handle = htole16(handle);
        rc = hwrm_send_message(softc, &req, sizeof(req));
        if (!rc) {
                next_handle = le16toh(resp->next_handle);
                if (next_handle != 0) {
                        if (resp->wol_type ==
                                HWRM_WOL_FILTER_ALLOC_INPUT_WOL_TYPE_MAGICPKT) {
                                softc->wol = 1;
                                softc->wol_filter_id = resp->wol_filter_id;
                        }
                }
        }
        return next_handle;
}

int
bnxt_hwrm_alloc_wol_fltr(struct bnxt_softc *softc)
{
        struct hwrm_wol_filter_alloc_input req = {0};
        struct hwrm_wol_filter_alloc_output *resp =
                (void *)softc->hwrm_cmd_resp.idi_vaddr;
        int rc;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_ALLOC);
        req.port_id = htole16(softc->pf.port_id);
        req.wol_type = HWRM_WOL_FILTER_ALLOC_INPUT_WOL_TYPE_MAGICPKT;
        req.enables =
                htole32(HWRM_WOL_FILTER_ALLOC_INPUT_ENABLES_MAC_ADDRESS);
        memcpy(req.mac_address, softc->func.mac_addr, ETHER_ADDR_LEN);
        rc = hwrm_send_message(softc, &req, sizeof(req));
        if (!rc)
                softc->wol_filter_id = resp->wol_filter_id;

        return rc;
}

int
bnxt_hwrm_free_wol_fltr(struct bnxt_softc *softc)
{
        struct hwrm_wol_filter_free_input req = {0};

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_FREE);
        req.port_id = htole16(softc->pf.port_id);
        req.enables =
                htole32(HWRM_WOL_FILTER_FREE_INPUT_ENABLES_WOL_FILTER_ID);
        req.wol_filter_id = softc->wol_filter_id;
        return hwrm_send_message(softc, &req, sizeof(req));
}

static void bnxt_hwrm_set_coal_params(struct bnxt_softc *softc, uint32_t max_frames,
        uint32_t buf_tmrs, uint16_t flags,
        struct hwrm_ring_cmpl_ring_cfg_aggint_params_input *req)
{
        req->flags = htole16(flags);
        req->num_cmpl_dma_aggr = htole16((uint16_t)max_frames);
        req->num_cmpl_dma_aggr_during_int = htole16(max_frames >> 16);
        req->cmpl_aggr_dma_tmr = htole16((uint16_t)buf_tmrs);
        req->cmpl_aggr_dma_tmr_during_int = htole16(buf_tmrs >> 16);
        /* Minimum time between 2 interrupts set to buf_tmr x 2 */
        req->int_lat_tmr_min = htole16((uint16_t)buf_tmrs * 2);
        req->int_lat_tmr_max = htole16((uint16_t)buf_tmrs * 4);
        req->num_cmpl_aggr_int = htole16((uint16_t)max_frames * 4);
}


int bnxt_hwrm_set_coal(struct bnxt_softc *softc)
{
        int i, rc = 0;
        struct hwrm_ring_cmpl_ring_cfg_aggint_params_input req_rx = {0},
                                                           req_tx = {0}, *req;
        uint16_t max_buf, max_buf_irq;
        uint16_t buf_tmr, buf_tmr_irq;
        uint32_t flags;

        bnxt_hwrm_cmd_hdr_init(softc, &req_rx,
                               HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS);
        bnxt_hwrm_cmd_hdr_init(softc, &req_tx,
                               HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS);

        /* Each rx completion (2 records) should be DMAed immediately.
         * DMA 1/4 of the completion buffers at a time.
         */
        max_buf = min_t(uint16_t, softc->rx_coal_frames / 4, 2);
        /* max_buf must not be zero */
        max_buf = clamp_t(uint16_t, max_buf, 1, 63);
        max_buf_irq = clamp_t(uint16_t, softc->rx_coal_frames_irq, 1, 63);
        buf_tmr = BNXT_USEC_TO_COAL_TIMER(softc->rx_coal_usecs);
        /* buf timer set to 1/4 of interrupt timer */
        buf_tmr = max_t(uint16_t, buf_tmr / 4, 1);
        buf_tmr_irq = BNXT_USEC_TO_COAL_TIMER(softc->rx_coal_usecs_irq);
        buf_tmr_irq = max_t(uint16_t, buf_tmr_irq, 1);

        flags = HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_TIMER_RESET;

        /* RING_IDLE generates more IRQs for lower latency.  Enable it only
         * if coal_usecs is less than 25 us.
         */
        if (softc->rx_coal_usecs < 25)
                flags |= HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_RING_IDLE;

        bnxt_hwrm_set_coal_params(softc, max_buf_irq << 16 | max_buf,
                                  buf_tmr_irq << 16 | buf_tmr, flags, &req_rx);

        /* max_buf must not be zero */
        max_buf = clamp_t(uint16_t, softc->tx_coal_frames, 1, 63);
        max_buf_irq = clamp_t(uint16_t, softc->tx_coal_frames_irq, 1, 63);
        buf_tmr = BNXT_USEC_TO_COAL_TIMER(softc->tx_coal_usecs);
        /* buf timer set to 1/4 of interrupt timer */
        buf_tmr = max_t(uint16_t, buf_tmr / 4, 1);
        buf_tmr_irq = BNXT_USEC_TO_COAL_TIMER(softc->tx_coal_usecs_irq);
        buf_tmr_irq = max_t(uint16_t, buf_tmr_irq, 1);
        flags = HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_TIMER_RESET;
        bnxt_hwrm_set_coal_params(softc, max_buf_irq << 16 | max_buf,
                                  buf_tmr_irq << 16 | buf_tmr, flags, &req_tx);

        for (i = 0; i < softc->nrxqsets; i++) {

               
                req = &req_rx;
                /*
                 * TBD:
                 *      Check if Tx also needs to be done
                 *      So far, Tx processing has been done in softirq contest
                 *
                 * req = &req_tx;
                 */
                req->ring_id = htole16(softc->grp_info[i].cp_ring_id);

                rc = hwrm_send_message(softc, req, sizeof(*req));
                if (rc)
                        break;
        }
        return rc;
}

#endif

void
_bnxt_hwrm_set_async_event_bit(struct hwrm_func_drv_rgtr_input *req, int bit)
{
        req->async_event_fwd[bit/32] |= (1 << (bit % 32));
}

int bnxt_hwrm_func_rgtr_async_events(struct bnxt_softc *softc)
{
        struct hwrm_func_drv_rgtr_input req = {0};
        int events[] = {
                HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE,
                HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD,
                HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED,
                HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_CFG_CHANGE,
                HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE
        };
        int i;

        bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_RGTR);

        req.enables =
                htole32(HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_ASYNC_EVENT_FWD);

        for (i = 0; i < nitems(events); i++)
                _bnxt_hwrm_set_async_event_bit(&req, events[i]);

        return hwrm_send_message(softc, &req, sizeof(req));
}

Reply | Threaded
Open this post in threaded view
|

Re: broadcom netxtreme-c/e driver

Mark Kettenis
> Date: Mon, 9 Jul 2018 14:23:43 +1000
> From: Jonathan Matthew <[hidden email]>
>
> This started out as a port of freebsd's bnxt driver, but along the way I
> had to rewrite the interesting bits.
>
> NetXtreme-C/E (BCM573xx and BCM574xx) is a different line of chips to
> NetXtreme II 10G (BCM577xx, which mje was working on), and luckily for me it's
> much easier to talk to.  The reason these ones are interesting to me is that
> they're the only 10G mezzanine option for Dell's Epyc based servers.
>
> I've got it to the point where I could commit to cvs over it, so I'd
> like to get it into the tree.  Lots of stuff is still missing -
> media types, multicast, jumbos, any of the vast array of offloads,
> and it's not particularly fast yet, only slightly over a gigabit in
> iperf/tcpbench type tests.  Lots of work to do still.
>
> The current code is below, only I'm not including bnxtreg.h as it's
> fairly large (>30k lines) and it came unmodified from freebsd:
> https://svnweb.freebsd.org/base/head/sys/dev/bnxt/hsi_struct_def.h?revision=323233&view=markup
>
> ok?

ok kettenis@

> /* $OpenBSD$ */
> /*-
>  * Broadcom NetXtreme-C/E network driver.
>  *
>  * Copyright (c) 2016 Broadcom, All Rights Reserved.
>  * The term Broadcom refers to Broadcom Limited and/or its subsidiaries
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>  * are met:
>  * 1. Redistributions of source code must retain the above copyright
>  *    notice, this list of conditions and the following disclaimer.
>  * 2. Redistributions in binary form must reproduce the above copyright
>  *    notice, this list of conditions and the following disclaimer in the
>  *    documentation and/or other materials provided with the distribution.
>  *
>  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS'
>  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
>  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>  * THE POSSIBILITY OF SUCH DAMAGE.
>  */
>
> /*
>  * Copyright (c) 2018 Jonathan Matthew <[hidden email]>
>  *
>  * Permission to use, copy, modify, and distribute this software for any
>  * purpose with or without fee is hereby granted, provided that the above
>  * copyright notice and this permission notice appear in all copies.
>  *
>  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
>  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
>  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
>  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
>  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
>  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
>  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
>  */
>
>
> #include "bpfilter.h"
>
> #include <sys/param.h>
> #include <sys/systm.h>
> #include <sys/mbuf.h>
> #include <sys/kernel.h>
> #include <sys/malloc.h>
> #include <sys/device.h>
> #include <sys/stdint.h>
> #include <sys/sockio.h>
> #include <sys/atomic.h>
>
> #include <machine/bus.h>
>
> #include <dev/pci/pcireg.h>
> #include <dev/pci/pcivar.h>
> #include <dev/pci/pcidevs.h>
>
> #define __FBSDID(x)
> #include <dev/pci/bnxtreg.h>
>
> #include <net/if.h>
> #include <net/if_media.h>
>
> #if NBPFILTER > 0
> #include <net/bpf.h>
> #endif
>
> #include <netinet/in.h>
> #include <netinet/if_ether.h>
>
> #define BNXT_HWRM_BAR 0x10
> #define BNXT_DOORBELL_BAR 0x18
>
> #define BNXT_RX_RING_ID 0
> #define BNXT_AG_RING_ID 1
> #define BNXT_TX_RING_ID 3
>
> #define BNXT_MAX_QUEUE 8
> #define BNXT_MAX_MTU 9000
>
> #define BNXT_MAX_TX_SEGS 32 /* a bit much? */
>
> #define BNXT_HWRM_SHORT_REQ_LEN sizeof(struct hwrm_short_input)
>
> #define BNXT_HWRM_LOCK_INIT(_sc, _name) \
> mtx_init_flags(&sc->sc_lock, IPL_NET, _name, 0)
> #define BNXT_HWRM_LOCK(_sc) mtx_enter(&_sc->sc_lock)
> #define BNXT_HWRM_UNLOCK(_sc) mtx_leave(&_sc->sc_lock)
> #define BNXT_HWRM_LOCK_DESTROY(_sc) /* nothing */
> #define BNXT_HWRM_LOCK_ASSERT(_sc) MUTEX_ASSERT_LOCKED(&_sc->sc_lock)
>
> #define BNXT_FLAG_VF            0x0001
> #define BNXT_FLAG_NPAR          0x0002
> #define BNXT_FLAG_WOL_CAP       0x0004
> #define BNXT_FLAG_SHORT_CMD     0x0008
>
> #define NEXT_CP_CONS_V(_ring, _cons, _v_bit) \
> do { \
> if (++(_cons) == (_ring)->ring_size) \
> ((_cons) = 0, (_v_bit) = !_v_bit); \
> } while (0);
>
> struct bnxt_cos_queue {
> uint8_t id;
> uint8_t profile;
> };
>
> struct bnxt_ring {
> uint64_t paddr;
> uint64_t doorbell;
> caddr_t vaddr;
> uint32_t ring_size;
> uint16_t id;
> uint16_t phys_id;
> struct bnxt_full_tpa_start *tpa_start;
> };
>
> struct bnxt_cp_ring {
> struct bnxt_ring ring;
> void *irq;
> struct bnxt_softc *softc;
> uint32_t cons;
> int v_bit;
> struct ctx_hw_stats *stats;
> uint32_t stats_ctx_id;
> uint32_t last_idx;
> };
>
> struct bnxt_grp_info {
> uint32_t grp_id;
> uint16_t stats_ctx;
> uint16_t rx_ring_id;
> uint16_t cp_ring_id;
> uint16_t ag_ring_id;
> };
>
> struct bnxt_vnic_info {
> uint16_t id;
> uint16_t def_ring_grp;
> uint16_t cos_rule;
> uint16_t lb_rule;
> uint16_t mru;
>
> uint32_t rx_mask;
> /* multicast things */
>
> uint32_t flags;
> #define BNXT_VNIC_FLAG_DEFAULT 0x01
> #define BNXT_VNIC_FLAG_BD_STALL 0x02
> #define BNXT_VNIC_FLAG_VLAN_STRIP 0x04
>
> uint64_t filter_id;
> uint32_t flow_id;
>
> uint16_t rss_id;
> /* rss things */
>
> /* vlan things */
> };
>
> struct bnxt_slot {
> bus_dmamap_t bs_map;
> struct mbuf *bs_m;
> };
>
> struct bnxt_dmamem {
> bus_dmamap_t bdm_map;
> bus_dma_segment_t bdm_seg;
> size_t bdm_size;
> caddr_t bdm_kva;
> };
> #define BNXT_DMA_MAP(_bdm) ((_bdm)->bdm_map)
> #define BNXT_DMA_LEN(_bdm) ((_bdm)->bdm_size)
> #define BNXT_DMA_DVA(_bdm) ((u_int64_t)(_bdm)->bdm_map->dm_segs[0].ds_addr)
> #define BNXT_DMA_KVA(_bdm) ((void *)(_bdm)->bdm_kva)
>
> struct bnxt_softc {
> struct device sc_dev;
> struct arpcom sc_ac;
> struct ifmedia sc_media;
>
> struct mutex sc_lock;
>
> pci_chipset_tag_t sc_pc;
> pcitag_t sc_tag;
> bus_dma_tag_t sc_dmat;
>
> bus_space_tag_t sc_hwrm_t;
> bus_space_handle_t sc_hwrm_h;
> bus_size_t sc_hwrm_s;
>
> struct bnxt_dmamem *sc_cmd_resp;
> uint16_t sc_cmd_seq;
> uint16_t sc_max_req_len;
> uint32_t sc_cmd_timeo;
> uint32_t sc_flags;
>
> bus_space_tag_t sc_db_t;
> bus_space_handle_t sc_db_h;
> bus_size_t sc_db_s;
>
> void *sc_ih;
>
> int sc_max_tc;
> struct bnxt_cos_queue sc_q_info[BNXT_MAX_QUEUE];
>
> struct bnxt_vnic_info sc_vnic;
> struct bnxt_dmamem *sc_stats_ctx_mem;
>
> struct bnxt_cp_ring sc_cp_ring;
> struct bnxt_dmamem *sc_cp_ring_mem;
>
> /* rx */
> struct bnxt_dmamem *sc_rx_ring_mem; /* rx and ag */
> struct bnxt_ring sc_rx_ring;
> /* struct bnxt_ring sc_rx_ag_ring; */
> struct bnxt_grp_info sc_ring_group;
> struct if_rxring sc_rxr;
> struct bnxt_slot *sc_rx_slots;
> int sc_rx_prod;
> int sc_rx_cons;
> struct timeout sc_rx_refill;
>
> /* tx */
> struct bnxt_dmamem *sc_tx_ring_mem;
> struct bnxt_ring sc_tx_ring;
> struct bnxt_slot *sc_tx_slots;
> int sc_tx_prod;
> int sc_tx_cons;
> int sc_tx_ring_prod;
> int sc_tx_ring_cons;
> };
> #define DEVNAME(_sc) ((_sc)->sc_dev.dv_xname)
>
> const struct pci_matchid bnxt_devices[] = {
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57301 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57302 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57304 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57311 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57312 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57314 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57402 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57404 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57406 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57407 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57412 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57414 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57416 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57416_SFP },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57417 },
> { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM57417_SFP }
> };
>
> int bnxt_match(struct device *, void *, void *);
> void bnxt_attach(struct device *, struct device *, void *);
>
> void bnxt_up(struct bnxt_softc *);
> void bnxt_down(struct bnxt_softc *);
> void bnxt_iff(struct bnxt_softc *);
> int bnxt_ioctl(struct ifnet *, u_long, caddr_t);
> int bnxt_rxrinfo(struct bnxt_softc *, struct if_rxrinfo *);
> void bnxt_start(struct ifqueue *);
> int bnxt_intr(void *);
> void bnxt_watchdog(struct ifnet *);
> void bnxt_media_status(struct ifnet *, struct ifmediareq *);
> int bnxt_media_change(struct ifnet *);
>
> void bnxt_mark_cpr_invalid(struct bnxt_cp_ring *);
> void bnxt_write_cp_doorbell(struct bnxt_softc *, struct bnxt_ring *,
>    int);
> void bnxt_write_cp_doorbell_index(struct bnxt_softc *,
>    struct bnxt_ring *, uint32_t, int);
> void bnxt_write_rx_doorbell(struct bnxt_softc *, struct bnxt_ring *,
>    int);
> void bnxt_write_tx_doorbell(struct bnxt_softc *, struct bnxt_ring *,
>    int);
>
> int bnxt_rx_fill(struct bnxt_softc *);
> u_int bnxt_rx_fill_slots(struct bnxt_softc *, u_int);
> void bnxt_refill(void *);
> void bnxt_rx(struct bnxt_softc *, struct mbuf_list *, int *,
>    struct cmpl_base *, struct cmpl_base *);
>
> int bnxt_txeof(struct bnxt_softc *, struct cmpl_base *);
>
>
> /* HWRM Function Prototypes */
> int bnxt_hwrm_ring_alloc(struct bnxt_softc *, uint8_t,
>    struct bnxt_ring *, uint16_t, uint32_t, int);
> int bnxt_hwrm_ring_free(struct bnxt_softc *, uint8_t,
>    struct bnxt_ring *);
> int bnxt_hwrm_ver_get(struct bnxt_softc *);
> int bnxt_hwrm_queue_qportcfg(struct bnxt_softc *);
> int bnxt_hwrm_func_drv_rgtr(struct bnxt_softc *);
> int bnxt_hwrm_func_qcaps(struct bnxt_softc *);
> int bnxt_hwrm_func_qcfg(struct bnxt_softc *);
> int bnxt_hwrm_func_reset(struct bnxt_softc *);
> int bnxt_hwrm_vnic_ctx_alloc(struct bnxt_softc *, uint16_t *);
> int bnxt_hwrm_vnic_ctx_free(struct bnxt_softc *, uint16_t *);
> int bnxt_hwrm_vnic_cfg(struct bnxt_softc *,
>    struct bnxt_vnic_info *);
> int bnxt_hwrm_stat_ctx_alloc(struct bnxt_softc *,
>    struct bnxt_cp_ring *, uint64_t);
> int bnxt_hwrm_stat_ctx_free(struct bnxt_softc *,
>    struct bnxt_cp_ring *);
> int bnxt_hwrm_ring_grp_alloc(struct bnxt_softc *,
>    struct bnxt_grp_info *);
> int bnxt_hwrm_ring_grp_free(struct bnxt_softc *,
>    struct bnxt_grp_info *);
> int bnxt_hwrm_vnic_alloc(struct bnxt_softc *,
>    struct bnxt_vnic_info *);
> int bnxt_hwrm_vnic_free(struct bnxt_softc *,
>    struct bnxt_vnic_info *);
> int bnxt_hwrm_cfa_l2_set_rx_mask(struct bnxt_softc *,
>    struct bnxt_vnic_info *vnic);
> int bnxt_hwrm_set_filter(struct bnxt_softc *,
>    struct bnxt_vnic_info *);
> int bnxt_hwrm_free_filter(struct bnxt_softc *,
>    struct bnxt_vnic_info *);
> int bnxt_cfg_async_cr(struct bnxt_softc *);
> int bnxt_hwrm_nvm_get_dev_info(struct bnxt_softc *, uint16_t *,
>    uint16_t *, uint32_t *, uint32_t *, uint32_t *, uint32_t *);
> int bnxt_hwrm_port_phy_qcfg(struct bnxt_softc *,
>    struct ifmediareq *);
> int bnxt_hwrm_func_rgtr_async_events(struct bnxt_softc *);
>
> /* not used yet: */
> #if 0
> int bnxt_hwrm_func_drv_unrgtr(struct bnxt_softc *softc, bool shutdown);
>
> int bnxt_hwrm_set_link_setting(struct bnxt_softc *softc, bool set_pause,
>     bool set_eee, bool set_link);
> int bnxt_hwrm_set_pause(struct bnxt_softc *softc);
>
> int bnxt_hwrm_port_qstats(struct bnxt_softc *softc);
>
> int bnxt_hwrm_rss_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic,
>     uint32_t hash_type);
>
> int bnxt_hwrm_vnic_tpa_cfg(struct bnxt_softc *softc);
> void bnxt_validate_hw_lro_settings(struct bnxt_softc *softc);
> int bnxt_hwrm_nvm_find_dir_entry(struct bnxt_softc *softc, uint16_t type,
>     uint16_t *ordinal, uint16_t ext, uint16_t *index, bool use_index,
>     uint8_t search_opt, uint32_t *data_length, uint32_t *item_length,
>     uint32_t *fw_ver);
> int bnxt_hwrm_nvm_read(struct bnxt_softc *softc, uint16_t index,
>     uint32_t offset, uint32_t length, struct iflib_dma_info *data);
> int bnxt_hwrm_nvm_modify(struct bnxt_softc *softc, uint16_t index,
>     uint32_t offset, void *data, bool cpyin, uint32_t length);
> int bnxt_hwrm_fw_reset(struct bnxt_softc *softc, uint8_t processor,
>     uint8_t *selfreset);
> int bnxt_hwrm_fw_qstatus(struct bnxt_softc *softc, uint8_t type,
>     uint8_t *selfreset);
> int bnxt_hwrm_nvm_write(struct bnxt_softc *softc, void *data, bool cpyin,
>     uint16_t type, uint16_t ordinal, uint16_t ext, uint16_t attr,
>     uint16_t option, uint32_t data_length, bool keep, uint32_t *item_length,
>     uint16_t *index);
> int bnxt_hwrm_nvm_erase_dir_entry(struct bnxt_softc *softc, uint16_t index);
> int bnxt_hwrm_nvm_get_dir_info(struct bnxt_softc *softc, uint32_t *entries,
>     uint32_t *entry_length);
> int bnxt_hwrm_nvm_get_dir_entries(struct bnxt_softc *softc,
>     uint32_t *entries, uint32_t *entry_length, struct iflib_dma_info *dma_data);
>
> int bnxt_hwrm_nvm_install_update(struct bnxt_softc *softc,
>     uint32_t install_type, uint64_t *installed_items, uint8_t *result,
>     uint8_t *problem_item, uint8_t *reset_required);
> int bnxt_hwrm_nvm_verify_update(struct bnxt_softc *softc, uint16_t type,
>     uint16_t ordinal, uint16_t ext);
> int bnxt_hwrm_fw_get_time(struct bnxt_softc *softc, uint16_t *year,
>     uint8_t *month, uint8_t *day, uint8_t *hour, uint8_t *minute,
>     uint8_t *second, uint16_t *millisecond, uint16_t *zone);
> int bnxt_hwrm_fw_set_time(struct bnxt_softc *softc, uint16_t year,
>     uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
>     uint16_t millisecond, uint16_t zone);
>
> uint16_t bnxt_hwrm_get_wol_fltrs(struct bnxt_softc *softc, uint16_t handle);
> int bnxt_hwrm_alloc_wol_fltr(struct bnxt_softc *softc);
> int bnxt_hwrm_free_wol_fltr(struct bnxt_softc *softc);
> int bnxt_hwrm_set_coal(struct bnxt_softc *softc);
>
> #endif
>
>
> struct cfattach bnxt_ca = {
> sizeof(struct bnxt_softc), bnxt_match, bnxt_attach
> };
>
> struct cfdriver bnxt_cd = {
> NULL, "bnxt", DV_IFNET
> };
>
> struct bnxt_dmamem *
> bnxt_dmamem_alloc(struct bnxt_softc *sc, size_t size)
> {
> struct bnxt_dmamem *m;
> int nsegs;
>
> m = malloc(sizeof(*m), M_DEVBUF, M_NOWAIT | M_ZERO);
> if (m == NULL)
> return (NULL);
>
> m->bdm_size = size;
>
> if (bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
>    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &m->bdm_map) != 0)
> goto bdmfree;
>
> if (bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &m->bdm_seg, 1,
>    &nsegs, BUS_DMA_NOWAIT | BUS_DMA_ZERO) != 0)
> goto destroy;
>
> if (bus_dmamem_map(sc->sc_dmat, &m->bdm_seg, nsegs, size, &m->bdm_kva,
>    BUS_DMA_NOWAIT) != 0)
> goto free;
>
> if (bus_dmamap_load(sc->sc_dmat, m->bdm_map, m->bdm_kva, size, NULL,
>    BUS_DMA_NOWAIT) != 0)
> goto unmap;
>
> return (m);
>
> unmap:
> bus_dmamem_unmap(sc->sc_dmat, m->bdm_kva, m->bdm_size);
> free:
> bus_dmamem_free(sc->sc_dmat, &m->bdm_seg, 1);
> destroy:
> bus_dmamap_destroy(sc->sc_dmat, m->bdm_map);
> bdmfree:
> free(m, M_DEVBUF, sizeof *m);
>
> return (NULL);
> }
>
> void
> bnxt_dmamem_free(struct bnxt_softc *sc, struct bnxt_dmamem *m)
> {
> bus_dmamem_unmap(sc->sc_dmat, m->bdm_kva, m->bdm_size);
> bus_dmamem_free(sc->sc_dmat, &m->bdm_seg, 1);
> bus_dmamap_destroy(sc->sc_dmat, m->bdm_map);
> free(m, M_DEVBUF, sizeof *m);
> }
>
> int
> bnxt_match(struct device *parent, void *match, void *aux)
> {
> return (pci_matchbyid(aux, bnxt_devices, nitems(bnxt_devices)));
> }
>
> void
> bnxt_attach(struct device *parent, struct device *self, void *aux)
> {
> struct bnxt_softc *sc = (struct bnxt_softc *)self;
> struct ifnet *ifp = &sc->sc_ac.ac_if;
> struct pci_attach_args *pa = aux;
> pci_intr_handle_t ih;
> const char *intrstr;
> u_int memtype;
>
> /* enable busmaster? */
>
> sc->sc_pc = pa->pa_pc;
> sc->sc_tag = pa->pa_tag;
> sc->sc_dmat = pa->pa_dmat;
>
> memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, BNXT_HWRM_BAR);
> if (pci_mapreg_map(pa, BNXT_HWRM_BAR, memtype, 0, &sc->sc_hwrm_t,
>    &sc->sc_hwrm_h, NULL, &sc->sc_hwrm_s, 0)) {
> printf(": failed to map hwrm\n");
> return;
> }
>
> memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, BNXT_DOORBELL_BAR);
> if (pci_mapreg_map(pa, BNXT_DOORBELL_BAR, memtype, 0, &sc->sc_db_t,
>    &sc->sc_db_h, NULL, &sc->sc_db_s, 0)) {
> printf(": failed to map doorbell\n");
> goto unmap_1;
> }
>
> BNXT_HWRM_LOCK_INIT(sc, DEVNAME(sc));
> sc->sc_cmd_resp = bnxt_dmamem_alloc(sc, PAGE_SIZE);
> if (sc->sc_cmd_resp == NULL) {
> printf(": failed to allocate command response buffer\n");
> goto unmap_2;
> }
>
> if (bnxt_hwrm_ver_get(sc) != 0) {
> printf(": failed to query version info\n");
> goto free_resp;
> }
>
> if (bnxt_hwrm_nvm_get_dev_info(sc, NULL, NULL, NULL, NULL, NULL, NULL)
>    != 0) {
> printf(": failed to get nvram info\n");
> goto free_resp;
> }
>
> if (bnxt_hwrm_func_drv_rgtr(sc) != 0) {
> printf(": failed to register driver with firmware\n");
> goto free_resp;
> }
>
> if (bnxt_hwrm_func_rgtr_async_events(sc) != 0) {
> printf(": failed to register async events\n");
> goto free_resp;
> }
>
> if (bnxt_hwrm_func_qcaps(sc) != 0) {
> printf(": failed to get queue capabilities\n");
> goto free_resp;
> }
>
> /*
> * devices advertise msi support, but there's no way to tell a
> * completion queue to use msi mode, only legacy or msi-x.
> */
> if (/*pci_intr_map_msi(pa, &ih) != 0 && */ pci_intr_map(pa, &ih) != 0) {
> printf(": unable to map interrupt\n");
> goto free_resp;
> }
> intrstr = pci_intr_string(sc->sc_pc, ih);
> sc->sc_ih = pci_intr_establish(sc->sc_pc, ih, IPL_NET | IPL_MPSAFE,
>    bnxt_intr, sc, DEVNAME(sc));
> if (sc->sc_ih == NULL) {
> printf(": unable to establish interrupt");
> if (intrstr != NULL)
> printf(" at %s", intrstr);
> printf("\n");
> goto deintr;
> }
> printf("%s, address %s\n", intrstr, ether_sprintf(sc->sc_ac.ac_enaddr));
>
> if (bnxt_hwrm_func_qcfg(sc) != 0) {
> printf("%s: failed to query function config\n", DEVNAME(sc));
> goto deintr;
> }
>
> if (bnxt_hwrm_queue_qportcfg(sc) != 0) {
> printf("%s: failed to query port config\n", DEVNAME(sc));
> goto deintr;
> }
>
> if (bnxt_hwrm_func_reset(sc) != 0) {
> printf("%s: reset failed\n", DEVNAME(sc));
> goto deintr;
> }
>
> sc->sc_cp_ring.stats_ctx_id = HWRM_NA_SIGNATURE;
> sc->sc_cp_ring.ring.phys_id = HWRM_NA_SIGNATURE;
> sc->sc_cp_ring.softc = sc;
> sc->sc_cp_ring.ring.id = 0;
> sc->sc_cp_ring.ring.doorbell = sc->sc_cp_ring.ring.id * 0x80;
> sc->sc_cp_ring.ring.ring_size = PAGE_SIZE / sizeof(struct cmpl_base);
> sc->sc_cp_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE);
> if (sc->sc_cp_ring_mem == NULL) {
> printf("%s: failed to allocate completion queue memory\n",
>    DEVNAME(sc));
> goto deintr;
> }
> sc->sc_cp_ring.ring.vaddr = BNXT_DMA_KVA(sc->sc_cp_ring_mem);
> sc->sc_cp_ring.ring.paddr = BNXT_DMA_DVA(sc->sc_cp_ring_mem);
> sc->sc_cp_ring.cons = UINT32_MAX;
> sc->sc_cp_ring.v_bit = 1;
> bnxt_mark_cpr_invalid(&sc->sc_cp_ring);
> if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_L2_CMPL,
>    &sc->sc_cp_ring.ring, (uint16_t)HWRM_NA_SIGNATURE,
>    HWRM_NA_SIGNATURE, 1) != 0) {
> printf("%s: failed to allocate completion queue\n",
>    DEVNAME(sc));
> goto free_cp_mem;
> }
> if (bnxt_cfg_async_cr(sc) != 0) {
> printf("%s: failed to set async completion ring\n",
>    DEVNAME(sc));
> goto free_cp_mem;
> }
> bnxt_write_cp_doorbell(sc, &sc->sc_cp_ring.ring, 1);
>
> strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
> ifp->if_softc = sc;
> ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX;
> ifp->if_xflags = IFXF_MPSAFE;
> ifp->if_ioctl = bnxt_ioctl;
> ifp->if_qstart = bnxt_start;
> ifp->if_watchdog = bnxt_watchdog;
> ifp->if_hardmtu = BNXT_MAX_MTU;
> ifp->if_capabilities = IFCAP_VLAN_MTU; /* ? */
> /* checksum flags, hwtagging? */
> IFQ_SET_MAXLEN(&ifp->if_snd, 1024); /* ? */
>
> ifmedia_init(&sc->sc_media, IFM_IMASK, bnxt_media_change,
>    bnxt_media_status);
> ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_AUTO, 0, NULL);
> ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_AUTO);
>
> if_attach(ifp);
> ether_ifattach(ifp);
>
> timeout_set(&sc->sc_rx_refill, bnxt_refill, sc);
>
> bnxt_hwrm_port_phy_qcfg(sc, NULL);
> return;
>
> free_cp_mem:
> bnxt_dmamem_free(sc, sc->sc_cp_ring_mem);
> deintr:
> pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
> sc->sc_ih = NULL;
> free_resp:
> bnxt_dmamem_free(sc, sc->sc_cmd_resp);
> unmap_2:
> bus_space_unmap(sc->sc_hwrm_t, sc->sc_hwrm_h, sc->sc_hwrm_s);
> sc->sc_hwrm_s = 0;
> unmap_1:
> bus_space_unmap(sc->sc_db_t, sc->sc_db_h, sc->sc_db_s);
> sc->sc_db_s = 0;
> }
>
> void
> bnxt_free_slots(struct bnxt_softc *sc, struct bnxt_slot *slots, int allocated,
>     int total)
> {
> struct bnxt_slot *bs;
>
> int i = allocated;
> while (i-- > 0) {
> bs = &slots[i];
> bus_dmamap_destroy(sc->sc_dmat, bs->bs_map);
> }
> free(slots, M_DEVBUF, total * sizeof(*bs));
> }
>
> void
> bnxt_up(struct bnxt_softc *sc)
> {
> struct ifnet *ifp = &sc->sc_ac.ac_if;
> struct bnxt_slot *bs;
> int i;
>
> sc->sc_stats_ctx_mem = bnxt_dmamem_alloc(sc,
>    sizeof(struct ctx_hw_stats));
> if (sc->sc_stats_ctx_mem == NULL) {
> printf("%s: failed to allocate stats contexts\n", DEVNAME(sc));
> return;
> }
>
> sc->sc_tx_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE);
> if (sc->sc_tx_ring_mem == NULL) {
> printf("%s: failed to allocate tx ring\n", DEVNAME(sc));
> goto free_stats;
> }
>
> sc->sc_rx_ring_mem = bnxt_dmamem_alloc(sc, PAGE_SIZE * 2);
> if (sc->sc_rx_ring_mem == NULL) {
> printf("%s: failed to allocate rx ring\n", DEVNAME(sc));
> goto free_tx;
> }
>
> if (bnxt_hwrm_stat_ctx_alloc(sc, &sc->sc_cp_ring,
>    BNXT_DMA_DVA(sc->sc_stats_ctx_mem)) != 0) {
> printf("%s: failed to set up stats context\n", DEVNAME(sc));
> goto free_rx;
> }
>
> sc->sc_tx_ring.phys_id = HWRM_NA_SIGNATURE;
> sc->sc_tx_ring.id = BNXT_TX_RING_ID;
> sc->sc_tx_ring.doorbell = sc->sc_tx_ring.id * 0x80;
> sc->sc_tx_ring.ring_size = PAGE_SIZE / sizeof(struct tx_bd_short);
> sc->sc_tx_ring.vaddr = BNXT_DMA_KVA(sc->sc_tx_ring_mem);
> sc->sc_tx_ring.paddr = BNXT_DMA_DVA(sc->sc_tx_ring_mem);
> if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
>    &sc->sc_tx_ring, sc->sc_cp_ring.ring.phys_id,
>    HWRM_NA_SIGNATURE, 1) != 0) {
> printf("%s: failed to set up tx ring\n",
>    DEVNAME(sc));
> goto dealloc_stats;
> }
> bnxt_write_tx_doorbell(sc, &sc->sc_tx_ring, 0);
>
> sc->sc_rx_ring.phys_id = HWRM_NA_SIGNATURE;
> sc->sc_rx_ring.id = BNXT_RX_RING_ID;
> sc->sc_rx_ring.doorbell = sc->sc_rx_ring.id * 0x80;
> sc->sc_rx_ring.ring_size = PAGE_SIZE / sizeof(struct rx_prod_pkt_bd);
> sc->sc_rx_ring.vaddr = BNXT_DMA_KVA(sc->sc_rx_ring_mem);
> sc->sc_rx_ring.paddr = BNXT_DMA_DVA(sc->sc_rx_ring_mem);
> if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
>    &sc->sc_rx_ring, sc->sc_cp_ring.ring.phys_id,
>    HWRM_NA_SIGNATURE, 1) != 0) {
> printf("%s: failed to set up rx ring\n",
>    DEVNAME(sc));
> goto dealloc_tx;
> }
> bnxt_write_rx_doorbell(sc, &sc->sc_rx_ring, 0);
>
> #if 0
> sc->sc_rx_ag_ring.phys_id = HWRM_NA_SIGNATURE;
> sc->sc_rx_ag_ring.id = BNXT_AG_RING_ID;
> sc->sc_rx_ag_ring.doorbell = sc->sc_rx_ring.id * 0x80;
> sc->sc_rx_ag_ring.ring_size = PAGE_SIZE / sizeof(struct rx_prod_pkt_bd);
> sc->sc_rx_ag_ring.vaddr = BNXT_DMA_KVA(sc->sc_rx_ring_mem) + PAGE_SIZE;
> sc->sc_rx_ag_ring.paddr = BNXT_DMA_DVA(sc->sc_rx_ring_mem) + PAGE_SIZE;
> if (bnxt_hwrm_ring_alloc(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
>    &sc->sc_rx_ag_ring, sc->sc_cp_ring.ring.phys_id,
>    HWRM_NA_SIGNATURE, 1) != 0) {
> printf("%s: failed to set up rx ag ring\n",
>    DEVNAME(sc));
> goto dealloc_rx;
> }
> #endif
>
> sc->sc_ring_group.grp_id = HWRM_NA_SIGNATURE;
> sc->sc_ring_group.stats_ctx = sc->sc_cp_ring.stats_ctx_id;
> sc->sc_ring_group.rx_ring_id = sc->sc_rx_ring.phys_id;
> sc->sc_ring_group.ag_ring_id = HWRM_NA_SIGNATURE;
> sc->sc_ring_group.cp_ring_id = sc->sc_cp_ring.ring.phys_id;
> if (bnxt_hwrm_ring_grp_alloc(sc, &sc->sc_ring_group) != 0) {
> printf("%s: failed to allocate ring group\n",
>    DEVNAME(sc));
> goto dealloc_rx;
> }
>
> sc->sc_vnic.rss_id = HWRM_NA_SIGNATURE;
> if (bnxt_hwrm_vnic_ctx_alloc(sc, &sc->sc_vnic.rss_id) != 0) {
> printf("%s: failed to allocate vnic rss context\n",
>    DEVNAME(sc));
> goto dealloc_ring_group;
> }
>
> sc->sc_vnic.id = HWRM_NA_SIGNATURE;
> sc->sc_vnic.def_ring_grp = sc->sc_ring_group.grp_id;
> sc->sc_vnic.mru = MCLBYTES;
> sc->sc_vnic.cos_rule = (uint16_t)HWRM_NA_SIGNATURE;
> sc->sc_vnic.lb_rule = (uint16_t)HWRM_NA_SIGNATURE;
> sc->sc_vnic.rx_mask = HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_BCAST;
> /* sc->sc_vnic.mc_list_count = 0; */
> sc->sc_vnic.flags = BNXT_VNIC_FLAG_DEFAULT;
> if (bnxt_hwrm_vnic_alloc(sc, &sc->sc_vnic) != 0) {
> printf("%s: failed to allocate vnic\n", DEVNAME(sc));
> goto dealloc_vnic_ctx;
> }
>
> if (bnxt_hwrm_vnic_cfg(sc, &sc->sc_vnic) != 0) {
> printf("%s: failed to configure vnic\n", DEVNAME(sc));
> goto dealloc_vnic;
> }
>
> sc->sc_vnic.filter_id = -1;
> if (bnxt_hwrm_set_filter(sc, &sc->sc_vnic) != 0) {
> printf("%s: failed to set vnic filter\n", DEVNAME(sc));
> goto dealloc_vnic;
> }
>
> /* don't configure rss or tpa yet */
>
> sc->sc_rx_slots = mallocarray(sizeof(*bs), sc->sc_rx_ring.ring_size,
>    M_DEVBUF, M_WAITOK | M_ZERO);
> if (sc->sc_rx_slots == NULL) {
> printf("%s: failed to allocate rx slots\n", DEVNAME(sc));
> goto dealloc_filter;
> }
>
> for (i = 0; i < sc->sc_rx_ring.ring_size; i++) {
> bs = &sc->sc_rx_slots[i];
> if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES, 0,
>    BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW, &bs->bs_map) != 0) {
> printf("%s: failed to allocate rx dma maps\n",
>    DEVNAME(sc));
> goto destroy_rx_slots;
> }
> }
>
> sc->sc_tx_slots = mallocarray(sizeof(*bs), sc->sc_tx_ring.ring_size,
>    M_DEVBUF, M_WAITOK | M_ZERO);
> if (sc->sc_tx_slots == NULL) {
> printf("%s: failed to allocate tx slots\n", DEVNAME(sc));
> goto destroy_rx_slots;
> }
>
> for (i = 0; i < sc->sc_tx_ring.ring_size; i++) {
> bs = &sc->sc_tx_slots[i];
> if (bus_dmamap_create(sc->sc_dmat, MCLBYTES, BNXT_MAX_TX_SEGS,
>    MCLBYTES, 0, BUS_DMA_WAITOK | BUS_DMA_ALLOCNOW,
>    &bs->bs_map) != 0) {
> printf("%s: failed to allocate tx dma maps\n",
>    DEVNAME(sc));
> goto destroy_tx_slots;
> }
> }
>
> bnxt_iff(sc);
>
> /*
> * initially, the rx ring must be filled at least some distance beyond
> * the current consumer index, as it looks like the firmware assumes the
> * ring is full on creation, but doesn't prefetch the whole thing.
> * once the whole ring has been used once, we should be able to back off
> * to 2 or so slots, but we currently don't have a way of doing that.
> */
> if_rxr_init(&sc->sc_rxr, 32, sc->sc_rx_ring.ring_size - 1);
> sc->sc_rx_prod = 0;
> sc->sc_rx_cons = 0;
> bnxt_rx_fill(sc);
>
> SET(ifp->if_flags, IFF_RUNNING);
>
> sc->sc_tx_cons = 0;
> sc->sc_tx_prod = 0;
> sc->sc_tx_ring_cons = 0;
> sc->sc_tx_ring_prod = 0;
> ifq_clr_oactive(&ifp->if_snd);
> ifq_restart(&ifp->if_snd);
>
> return;
>
> destroy_tx_slots:
> bnxt_free_slots(sc, sc->sc_tx_slots, i, sc->sc_tx_ring.ring_size);
> sc->sc_tx_slots = NULL;
>
> i = sc->sc_rx_ring.ring_size;
> destroy_rx_slots:
> bnxt_free_slots(sc, sc->sc_rx_slots, i, sc->sc_rx_ring.ring_size);
> sc->sc_rx_slots = NULL;
> dealloc_filter:
> bnxt_hwrm_free_filter(sc, &sc->sc_vnic);
> dealloc_vnic:
> bnxt_hwrm_vnic_free(sc, &sc->sc_vnic);
> dealloc_vnic_ctx:
> bnxt_hwrm_vnic_ctx_free(sc, &sc->sc_vnic.rss_id);
> dealloc_ring_group:
> bnxt_hwrm_ring_grp_free(sc, &sc->sc_ring_group);
> /* dealloc_ag: */
> dealloc_tx:
> bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
>    &sc->sc_tx_ring);
> dealloc_rx:
> bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
>    &sc->sc_rx_ring);
> dealloc_stats:
> bnxt_hwrm_stat_ctx_free(sc, &sc->sc_cp_ring);
> free_rx:
> bnxt_dmamem_free(sc, sc->sc_rx_ring_mem);
> sc->sc_rx_ring_mem = NULL;
> free_tx:
> bnxt_dmamem_free(sc, sc->sc_tx_ring_mem);
> sc->sc_tx_ring_mem = NULL;
> free_stats:
> bnxt_dmamem_free(sc, sc->sc_stats_ctx_mem);
> sc->sc_stats_ctx_mem = NULL;
> }
>
> void
> bnxt_down(struct bnxt_softc *sc)
> {
> struct ifnet *ifp = &sc->sc_ac.ac_if;
>
> CLR(ifp->if_flags, IFF_RUNNING);
>
> ifq_clr_oactive(&ifp->if_snd);
> ifq_barrier(&ifp->if_snd);
>
> timeout_del(&sc->sc_rx_refill);
>
> /* empty rx ring first i guess */
>
> bnxt_free_slots(sc, sc->sc_tx_slots, sc->sc_tx_ring.ring_size,
>    sc->sc_tx_ring.ring_size);
> sc->sc_tx_slots = NULL;
>
> bnxt_free_slots(sc, sc->sc_rx_slots, sc->sc_rx_ring.ring_size,
>    sc->sc_rx_ring.ring_size);
> sc->sc_rx_slots = NULL;
>
> bnxt_hwrm_free_filter(sc, &sc->sc_vnic);
> bnxt_hwrm_vnic_free(sc, &sc->sc_vnic);
> bnxt_hwrm_vnic_ctx_free(sc, &sc->sc_vnic.rss_id);
> bnxt_hwrm_ring_grp_free(sc, &sc->sc_ring_group);
> bnxt_hwrm_stat_ctx_free(sc, &sc->sc_cp_ring);
>
> /* may need to wait for 500ms here before we can free the rings */
>
> bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_TX,
>    &sc->sc_tx_ring);
> bnxt_hwrm_ring_free(sc, HWRM_RING_ALLOC_INPUT_RING_TYPE_RX,
>    &sc->sc_rx_ring);
>
> bnxt_dmamem_free(sc, sc->sc_rx_ring_mem);
> sc->sc_rx_ring_mem = NULL;
>
> bnxt_dmamem_free(sc, sc->sc_tx_ring_mem);
> sc->sc_tx_ring_mem = NULL;
>
> bnxt_dmamem_free(sc, sc->sc_stats_ctx_mem);
> sc->sc_stats_ctx_mem = NULL;
> }
>
> void
> bnxt_iff(struct bnxt_softc *sc)
> {
> struct ifnet *ifp = &sc->sc_ac.ac_if;
>
> if (ifp->if_flags & IFF_ALLMULTI)
> sc->sc_vnic.rx_mask |=
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
> else
> sc->sc_vnic.rx_mask &=
>    ~HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ALL_MCAST;
>
> if (ifp->if_flags & IFF_PROMISC)
> sc->sc_vnic.rx_mask |=
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN;
> else
> sc->sc_vnic.rx_mask &=
>    ~(HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_PROMISCUOUS |
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN);
>
> bnxt_hwrm_cfa_l2_set_rx_mask(sc, &sc->sc_vnic);
> }
>
> int
> bnxt_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
> {
> struct bnxt_softc *sc = (struct bnxt_softc *)ifp->if_softc;
> struct ifreq *ifr = (struct ifreq *)data;
> int s, error = 0;
>
> s = splnet();
> switch (cmd) {
> case SIOCSIFADDR:
> ifp->if_flags |= IFF_UP;
> /* FALLTHROUGH */
>
> case SIOCSIFFLAGS:
> if (ISSET(ifp->if_flags, IFF_UP)) {
> if (ISSET(ifp->if_flags, IFF_RUNNING))
> error = ENETRESET;
> else
> bnxt_up(sc);
> } else {
> if (ISSET(ifp->if_flags, IFF_RUNNING))
> bnxt_down(sc);
> }
> break;
>
> case SIOCGIFMEDIA:
> case SIOCSIFMEDIA:
> error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
> break;
>
> case SIOCGIFRXR:
> error = bnxt_rxrinfo(sc, (struct if_rxrinfo *)ifr->ifr_data);
> break;
>
> default:
> error = ether_ioctl(ifp, &sc->sc_ac, cmd, data);
> }
>
> if (error == ENETRESET) {
> if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
>    (IFF_UP | IFF_RUNNING))
> bnxt_iff(sc);
> error = 0;
> }
>
> splx(s);
>
> return (error);
> }
>
> int
> bnxt_rxrinfo(struct bnxt_softc *sc, struct if_rxrinfo *ifri)
> {
> struct if_rxring_info ifr;
>
> memset(&ifr, 0, sizeof(ifr));
> ifr.ifr_size = MCLBYTES;
> ifr.ifr_info = sc->sc_rxr;
>
> return (if_rxr_info_ioctl(ifri, 1, &ifr));
> }
>
> int
> bnxt_load_mbuf(struct bnxt_softc *sc, struct bnxt_slot *bs, struct mbuf *m)
> {
> switch (bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
>    BUS_DMA_STREAMING | BUS_DMA_NOWAIT)) {
> case 0:
> break;
>
> case EFBIG:
> if (m_defrag(m, M_DONTWAIT) == 0 &&
>    bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
>    BUS_DMA_STREAMING | BUS_DMA_NOWAIT) == 0)
> break;
>
> default:
> return (1);
> }
>
> bs->bs_m = m;
> return (0);
> }
>
> void
> bnxt_start(struct ifqueue *ifq)
> {
> struct ifnet *ifp = ifq->ifq_if;
> struct tx_bd_short *txring;
> struct bnxt_softc *sc = ifp->if_softc;
> struct bnxt_slot *bs;
> bus_dmamap_t map;
> struct mbuf *m;
> u_int idx, free, used;
> uint16_t txflags;
> int i;
>
> txring = (struct tx_bd_short *)BNXT_DMA_KVA(sc->sc_tx_ring_mem);
>
> idx = sc->sc_tx_ring_prod;
> free = sc->sc_tx_ring_cons;
> if (free <= idx)
> free += sc->sc_tx_ring.ring_size;
> free -= idx;
>
> used = 0;
>
> for (;;) {
> if (used + BNXT_MAX_TX_SEGS > free) {
> ifq_set_oactive(ifq);
> break;
> }
>
> m = ifq_dequeue(ifq);
> if (m == NULL)
> break;
>
> bs = &sc->sc_tx_slots[sc->sc_tx_prod];
> if (bnxt_load_mbuf(sc, bs, m) != 0) {
> m_freem(m);
> ifp->if_oerrors++;
> continue;
> }
>
> #if NBPFILTER > 0
> if (ifp->if_bpf)
> bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
> #endif
> map = bs->bs_map;
> bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
>    BUS_DMASYNC_PREWRITE);
> used += map->dm_nsegs;
>
> if (map->dm_mapsize < 512)
> txflags = TX_BD_SHORT_FLAGS_LHINT_LT512;
> else if (map->dm_mapsize < 1024)
> txflags = TX_BD_SHORT_FLAGS_LHINT_LT1K;
> else if (map->dm_mapsize < 2048)
> txflags = TX_BD_SHORT_FLAGS_LHINT_LT2K;
> else
> txflags = TX_BD_SHORT_FLAGS_LHINT_GTE2K;
>
> txflags |= TX_BD_SHORT_TYPE_TX_BD_SHORT |
>    (map->dm_nsegs << TX_BD_SHORT_FLAGS_BD_CNT_SFT);
>
> for (i = 0; i < map->dm_nsegs; i++) {
> txring[idx].flags_type = htole16(txflags);
> if (i == map->dm_nsegs - 1)
> txring[idx].flags_type |=
>    TX_BD_SHORT_FLAGS_PACKET_END;
> txflags = TX_BD_SHORT_TYPE_TX_BD_SHORT;
>
> txring[idx].len =
>    htole16(bs->bs_map->dm_segs[i].ds_len);
> txring[idx].opaque = sc->sc_tx_prod;
> txring[idx].addr =
>    htole64(bs->bs_map->dm_segs[i].ds_addr);
>
> idx++;
> if (idx == sc->sc_tx_ring.ring_size)
> idx = 0;
> }
>
> if (++sc->sc_tx_prod >= sc->sc_tx_ring.ring_size)
> sc->sc_tx_prod = 0;
> }
>
> bnxt_write_tx_doorbell(sc, &sc->sc_tx_ring, idx);
> sc->sc_tx_ring_prod = idx;
> }
>
> void
> bnxt_handle_async_event(struct bnxt_softc *sc, struct cmpl_base *cmpl)
> {
> struct hwrm_async_event_cmpl *ae = (struct hwrm_async_event_cmpl *)cmpl;
> uint16_t type = le16toh(ae->event_id);
>
> switch (type) {
> case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE:
> case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CHANGE:
> case HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE:
> bnxt_hwrm_port_phy_qcfg(sc, NULL);
> break;
>
> default:
> printf("%s: unexpected async event %x\n", DEVNAME(sc), type);
> break;
> }
> }
>
> int
> bnxt_intr(void *xsc)
> {
> struct bnxt_softc *sc = (struct bnxt_softc *)xsc;
> struct ifnet *ifp = &sc->sc_ac.ac_if;
> struct bnxt_cp_ring *cpr = &sc->sc_cp_ring;
> struct cmpl_base *cmpl, *cmpl2;
> struct mbuf_list ml = MBUF_LIST_INITIALIZER();
> uint32_t cons, last_cons;
> int v_bit, last_v_bit;
> uint16_t type;
> int rxfree, txfree;
>
> cons = cpr->cons;
> v_bit = cpr->v_bit;
>
> bnxt_write_cp_doorbell(sc, &cpr->ring, 0);
> rxfree = 0;
> txfree = 0;
> for (;;) {
> last_cons = cons;
> last_v_bit = v_bit;
> NEXT_CP_CONS_V(&cpr->ring, cons, v_bit);
> cmpl = &((struct cmpl_base *)cpr->ring.vaddr)[cons];
>
> if ((!!(cmpl->info3_v & htole32(CMPL_BASE_V))) != (!!v_bit))
> break;
>
> type = le16toh(cmpl->type) & CMPL_BASE_TYPE_MASK;
> switch (type) {
> case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
> bnxt_handle_async_event(sc, cmpl);
> break;
> case CMPL_BASE_TYPE_RX_L2:
> /* rx takes two slots */
> last_cons = cons;
> last_v_bit = v_bit;
> NEXT_CP_CONS_V(&cpr->ring, cons, v_bit);
> cmpl2 = &((struct cmpl_base *)cpr->ring.vaddr)[cons];
> bnxt_rx(sc, &ml, &rxfree, cmpl, cmpl2);
> break;
> case CMPL_BASE_TYPE_TX_L2:
> txfree += bnxt_txeof(sc, cmpl);
> break;
> default:
> printf("%s: unexpected completion type %u\n",
>    DEVNAME(sc), type);
> }
> }
>
> cpr->cons = last_cons;
> cpr->v_bit = last_v_bit;
>
> /*
> * comments in bnxtreg.h suggest we should be writing cpr->cons here,
> * but writing cpr->cons + 1 makes it stop interrupting.
> */
> bnxt_write_cp_doorbell_index(sc, &cpr->ring,
>    (cpr->cons+1) % cpr->ring.ring_size, 1);
>
> if (rxfree != 0) {
> sc->sc_rx_cons += rxfree;
> if (sc->sc_rx_cons >= sc->sc_rx_ring.ring_size)
> sc->sc_rx_cons -= sc->sc_rx_ring.ring_size;
>
> if_rxr_put(&sc->sc_rxr, rxfree);
>
> bnxt_rx_fill(sc);
> if (sc->sc_rx_cons == sc->sc_rx_prod)
> timeout_add(&sc->sc_rx_refill, 0);
>
> if_input(&sc->sc_ac.ac_if, &ml);
> }
> if (txfree != 0) {
> if (ifq_is_oactive(&ifp->if_snd))
> ifq_restart(&ifp->if_snd);
> }
> return (1);
> }
>
> void
> bnxt_watchdog(struct ifnet *ifp)
> {
> }
>
> void
> bnxt_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
> {
> struct bnxt_softc *sc = (struct bnxt_softc *)ifp->if_softc;
> bnxt_hwrm_port_phy_qcfg(sc, ifmr);
> }
>
> int
> bnxt_media_change(struct ifnet *ifp)
> {
> return 0;
> }
>
> void
> bnxt_mark_cpr_invalid(struct bnxt_cp_ring *cpr)
> {
> struct cmpl_base *cmp = (void *)cpr->ring.vaddr;
> int i;
>
> for (i = 0; i < cpr->ring.ring_size; i++)
> cmp[i].info3_v = !cpr->v_bit;
> }
>
> void
> bnxt_write_cp_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring,
>     int enable)
> {
> uint32_t val = CMPL_DOORBELL_KEY_CMPL;
> if (enable == 0)
> val |= CMPL_DOORBELL_MASK;
>
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, 0, sc->sc_db_s,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
> }
>
> void
> bnxt_write_cp_doorbell_index(struct bnxt_softc *sc, struct bnxt_ring *ring,
>     uint32_t index, int enable)
> {
> uint32_t val = CMPL_DOORBELL_KEY_CMPL | CMPL_DOORBELL_IDX_VALID |
>    (index & CMPL_DOORBELL_IDX_MASK);
> if (enable == 0)
> val |= CMPL_DOORBELL_MASK;
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, 0, sc->sc_db_s,
>    BUS_SPACE_BARRIER_WRITE);
> }
>
> void
> bnxt_write_rx_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring, int index)
> {
> uint32_t val = RX_DOORBELL_KEY_RX | index;
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
>
> /* second write isn't necessary on all hardware */
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
> }
>
> void
> bnxt_write_tx_doorbell(struct bnxt_softc *sc, struct bnxt_ring *ring, int index)
> {
> uint32_t val = TX_DOORBELL_KEY_TX | index;
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
>
> /* second write isn't necessary on all hardware */
> bus_space_barrier(sc->sc_db_t, sc->sc_db_h, ring->doorbell, 4,
>    BUS_SPACE_BARRIER_WRITE);
> bus_space_write_4(sc->sc_db_t, sc->sc_db_h, ring->doorbell,
>    htole32(val));
> }
>
> u_int
> bnxt_rx_fill_slots(struct bnxt_softc *sc, u_int slots)
> {
> struct rx_prod_pkt_bd *rxring;
> struct bnxt_slot *bs;
> struct mbuf *m;
> uint p, fills;
> uint16_t type;
>
> type = RX_PROD_PKT_BD_TYPE_RX_PROD_PKT;
>
> rxring = (struct rx_prod_pkt_bd *)BNXT_DMA_KVA(sc->sc_rx_ring_mem);
> p = sc->sc_rx_prod;
> for (fills = 0; fills < slots; fills++) {
> bs = &sc->sc_rx_slots[p];
> m = MCLGETI(NULL, M_DONTWAIT, NULL, MCLBYTES);
> if (m == NULL)
> break;
>
> m->m_len = m->m_pkthdr.len = MCLBYTES;
> if (bus_dmamap_load_mbuf(sc->sc_dmat, bs->bs_map, m,
>    BUS_DMA_NOWAIT) != 0) {
> m_freem(m);
> break;
> }
> bs->bs_m = m;
>
> rxring[p].flags_type = htole16(type);
> rxring[p].len = htole16(MCLBYTES);
> rxring[p].opaque = p;
> rxring[p].addr = htole64(bs->bs_map->dm_segs[0].ds_addr);
>
> if (++p >= sc->sc_rx_ring.ring_size)
> p = 0;
> }
>
> if (fills != 0)
> bnxt_write_rx_doorbell(sc, &sc->sc_rx_ring, p);
> sc->sc_rx_prod = p;
>
> return (slots - fills);
> }
>
> int
> bnxt_rx_fill(struct bnxt_softc *sc)
> {
> u_int slots;
>
> slots = if_rxr_get(&sc->sc_rxr, sc->sc_rx_ring.ring_size);
> if (slots == 0)
> return (1);
>
> slots = bnxt_rx_fill_slots(sc, slots);
> if_rxr_put(&sc->sc_rxr, slots);
>
> return (0);
> }
>
> void
> bnxt_refill(void *xsc)
> {
> struct bnxt_softc *sc = xsc;
>
> bnxt_rx_fill(sc);
>
> if (sc->sc_rx_cons == sc->sc_rx_prod)
> timeout_add(&sc->sc_rx_refill, 1);
> }
>
> void
> bnxt_rx(struct bnxt_softc *sc, struct mbuf_list *ml, int *slots,
>     struct cmpl_base *cmpl, struct cmpl_base *cmpl2)
> {
> struct mbuf *m;
> struct bnxt_slot *bs;
> struct rx_pkt_cmpl *rx = (struct rx_pkt_cmpl *)cmpl;
> /* struct rx_pkt_cmpl_hi *rxhi = (struct rx_pkt_cmpl_hi *)cmpl2; */
>
> if (rx->opaque != sc->sc_rx_cons)
> printf("%s: expected rx %d, got %d\n", DEVNAME(sc), sc->sc_rx_cons, rx->opaque);
> bs = &sc->sc_rx_slots[rx->opaque];
>
> bus_dmamap_sync(sc->sc_dmat, bs->bs_map, 0, bs->bs_map->dm_mapsize,
>    BUS_DMASYNC_POSTREAD);
> bus_dmamap_unload(sc->sc_dmat, bs->bs_map);
>
> m = bs->bs_m;
> bs->bs_m = NULL;
> m->m_pkthdr.len = m->m_len = letoh16(rx->len);
> ml_enqueue(ml, m);
> (*slots)++;
> }
>
> int
> bnxt_txeof(struct bnxt_softc *sc, struct cmpl_base *cmpl)
> {
> struct tx_cmpl *txcmpl = (struct tx_cmpl *)cmpl;
> struct bnxt_slot *bs;
> bus_dmamap_t map;
> u_int idx, freed;
>
> if (txcmpl->opaque != sc->sc_tx_cons)
> printf("%s: txeof for %d, expected %d?\n",
>    DEVNAME(sc), txcmpl->opaque, sc->sc_tx_cons);
> idx = sc->sc_tx_ring_cons;
>
> bs = &sc->sc_tx_slots[sc->sc_tx_cons];
> map = bs->bs_map;
>
> freed = map->dm_nsegs;
> bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize,
>    BUS_DMASYNC_POSTWRITE);
> bus_dmamap_unload(sc->sc_dmat, map);
> m_freem(bs->bs_m);
> bs->bs_m = NULL;
>
> idx += freed;
> if (idx >= sc->sc_tx_ring.ring_size)
> idx -= sc->sc_tx_ring.ring_size;
> sc->sc_tx_ring_cons = idx;
>
> if (++sc->sc_tx_cons >= sc->sc_tx_ring.ring_size)
> sc->sc_tx_cons = 0;
>
> return (freed);
> }
>
> /* bnxt_hwrm.c */
>
> static int bnxt_hwrm_err_map(uint16_t err);
> #if 0
> static void bnxt_hwrm_set_link_common(struct bnxt_softc *softc,
>    struct hwrm_port_phy_cfg_input *req);
> static void bnxt_hwrm_set_pause_common(struct bnxt_softc *softc,
>    struct hwrm_port_phy_cfg_input *req);
> static void bnxt_hwrm_set_eee(struct bnxt_softc *softc,
>    struct hwrm_port_phy_cfg_input *req);
> #endif
>
> static int _hwrm_send_message(struct bnxt_softc *, void *, uint32_t);
> static int hwrm_send_message(struct bnxt_softc *, void *, uint32_t);
> static void bnxt_hwrm_cmd_hdr_init(struct bnxt_softc *, void *, uint16_t);
>
> /* NVRam stuff has a five minute timeout */
> #define BNXT_NVM_TIMEO (5 * 60 * 1000)
>
> static int
> bnxt_hwrm_err_map(uint16_t err)
> {
> int rc;
>
> switch (err) {
> case HWRM_ERR_CODE_SUCCESS:
> return 0;
> case HWRM_ERR_CODE_INVALID_PARAMS:
> case HWRM_ERR_CODE_INVALID_FLAGS:
> case HWRM_ERR_CODE_INVALID_ENABLES:
> return EINVAL;
> case HWRM_ERR_CODE_RESOURCE_ACCESS_DENIED:
> return EACCES;
> case HWRM_ERR_CODE_RESOURCE_ALLOC_ERROR:
> return ENOMEM;
> case HWRM_ERR_CODE_CMD_NOT_SUPPORTED:
> return ENOSYS;
> case HWRM_ERR_CODE_FAIL:
> return EIO;
> case HWRM_ERR_CODE_HWRM_ERROR:
> case HWRM_ERR_CODE_UNKNOWN_ERR:
> default:
> return EIO;
> }
>
> return rc;
> }
>
> static void
> bnxt_hwrm_cmd_hdr_init(struct bnxt_softc *softc, void *request,
>     uint16_t req_type)
> {
> struct input *req = request;
>
> req->req_type = htole16(req_type);
> req->cmpl_ring = 0xffff;
> req->target_id = 0xffff;
> req->resp_addr = htole64(BNXT_DMA_DVA(softc->sc_cmd_resp));
> }
>
> static int
> _hwrm_send_message(struct bnxt_softc *softc, void *msg, uint32_t msg_len)
> {
> struct input *req = msg;
> struct hwrm_err_output *resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
> uint32_t *data = msg;
> int i;
> uint16_t cp_ring_id;
> uint8_t *valid;
> uint16_t err;
> uint16_t max_req_len = HWRM_MAX_REQ_LEN;
> struct hwrm_short_input short_input = {0};
>
> /* TODO: DMASYNC in here. */
> req->seq_id = htole16(softc->sc_cmd_seq++);
> memset(resp, 0, PAGE_SIZE);
> cp_ring_id = le16toh(req->cmpl_ring);
>
> if (softc->sc_flags & BNXT_FLAG_SHORT_CMD) {
> void *short_cmd_req = BNXT_DMA_KVA(softc->sc_cmd_resp);
>
> memcpy(short_cmd_req, req, msg_len);
> memset((uint8_t *) short_cmd_req + msg_len, 0,
>    softc->sc_max_req_len - msg_len);
>
> short_input.req_type = req->req_type;
> short_input.signature =
>    htole16(HWRM_SHORT_INPUT_SIGNATURE_SHORT_CMD);
> short_input.size = htole16(msg_len);
> short_input.req_addr =
>    htole64(BNXT_DMA_DVA(softc->sc_cmd_resp));
>
> data = (uint32_t *)&short_input;
> msg_len = sizeof(short_input);
>
> /* Sync memory write before updating doorbell */
> membar_sync();
>
> max_req_len = BNXT_HWRM_SHORT_REQ_LEN;
> }
>
> /* Write request msg to hwrm channel */
> for (i = 0; i < msg_len; i += 4) {
> bus_space_write_4(softc->sc_hwrm_t,
>  softc->sc_hwrm_h,
>  i, *data);
> data++;
> }
>
> /* Clear to the end of the request buffer */
> for (i = msg_len; i < max_req_len; i += 4)
> bus_space_write_4(softc->sc_hwrm_t, softc->sc_hwrm_h,
>    i, 0);
>
> /* Ring channel doorbell */
> bus_space_write_4(softc->sc_hwrm_t, softc->sc_hwrm_h, 0x100,
>    htole32(1));
>
> /* Check if response len is updated */
> for (i = 0; i < softc->sc_cmd_timeo; i++) {
> if (resp->resp_len && resp->resp_len <= 4096)
> break;
> DELAY(1000);
> }
> if (i >= softc->sc_cmd_timeo) {
> printf("%s: timeout sending %s: (timeout: %u) seq: %d\n",
>    DEVNAME(softc), GET_HWRM_REQ_TYPE(req->req_type),
>    softc->sc_cmd_timeo,
>    le16toh(req->seq_id));
> return ETIMEDOUT;
> }
> /* Last byte of resp contains the valid key */
> valid = (uint8_t *)resp + resp->resp_len - 1;
> for (i = 0; i < softc->sc_cmd_timeo; i++) {
> if (*valid == HWRM_RESP_VALID_KEY)
> break;
> DELAY(1000);
> }
> if (i >= softc->sc_cmd_timeo) {
> printf("%s: timeout sending %s: "
>    "(timeout: %u) msg {0x%x 0x%x} len:%d v: %d\n",
>    DEVNAME(softc), GET_HWRM_REQ_TYPE(req->req_type),
>    softc->sc_cmd_timeo, le16toh(req->req_type),
>    le16toh(req->seq_id), msg_len,
>    *valid);
> return ETIMEDOUT;
> }
>
> err = le16toh(resp->error_code);
> if (err) {
> /* HWRM_ERR_CODE_FAIL is a "normal" error, don't log */
> if (err != HWRM_ERR_CODE_FAIL) {
> printf("%s: %s command returned %s error.\n",
>    DEVNAME(softc),
>    GET_HWRM_REQ_TYPE(req->req_type),
>    GET_HWRM_ERROR_CODE(err));
> }
> return bnxt_hwrm_err_map(err);
> }
>
> return 0;
> }
>
>
> static int
> hwrm_send_message(struct bnxt_softc *softc, void *msg, uint32_t msg_len)
> {
> int rc;
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, msg, msg_len);
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
>
> int
> bnxt_hwrm_queue_qportcfg(struct bnxt_softc *softc)
> {
> struct hwrm_queue_qportcfg_input req = {0};
> struct hwrm_queue_qportcfg_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
>
> int rc = 0;
> uint8_t *qptr;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_QUEUE_QPORTCFG);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto qportcfg_exit;
>
> if (!resp->max_configurable_queues) {
> rc = -EINVAL;
> goto qportcfg_exit;
> }
> softc->sc_max_tc = resp->max_configurable_queues;
> if (softc->sc_max_tc > BNXT_MAX_QUEUE)
> softc->sc_max_tc = BNXT_MAX_QUEUE;
>
> qptr = &resp->queue_id0;
> for (int i = 0; i < softc->sc_max_tc; i++) {
> softc->sc_q_info[i].id = *qptr++;
> softc->sc_q_info[i].profile = *qptr++;
> }
>
> qportcfg_exit:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_ver_get(struct bnxt_softc *softc)
> {
> struct hwrm_ver_get_input req = {0};
> struct hwrm_ver_get_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> int rc;
> #if 0
> const char nastr[] = "<not installed>";
> const char naver[] = "<N/A>";
> #endif
> uint32_t dev_caps_cfg;
>
> softc->sc_max_req_len = HWRM_MAX_REQ_LEN;
> softc->sc_cmd_timeo = 1000;
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VER_GET);
>
> req.hwrm_intf_maj = HWRM_VERSION_MAJOR;
> req.hwrm_intf_min = HWRM_VERSION_MINOR;
> req.hwrm_intf_upd = HWRM_VERSION_UPDATE;
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> printf(": fw ver %d.%d.%d, ", resp->hwrm_fw_maj, resp->hwrm_fw_min,
>    resp->hwrm_fw_bld);
> #if 0
> snprintf(softc->ver_info->hwrm_if_ver, BNXT_VERSTR_SIZE, "%d.%d.%d",
>    resp->hwrm_intf_maj, resp->hwrm_intf_min, resp->hwrm_intf_upd);
> softc->ver_info->hwrm_if_major = resp->hwrm_intf_maj;
> softc->ver_info->hwrm_if_minor = resp->hwrm_intf_min;
> softc->ver_info->hwrm_if_update = resp->hwrm_intf_upd;
> snprintf(softc->ver_info->hwrm_fw_ver, BNXT_VERSTR_SIZE, "%d.%d.%d",
>    resp->hwrm_fw_maj, resp->hwrm_fw_min, resp->hwrm_fw_bld);
> strlcpy(softc->ver_info->driver_hwrm_if_ver, HWRM_VERSION_STR,
>    BNXT_VERSTR_SIZE);
> strlcpy(softc->ver_info->hwrm_fw_name, resp->hwrm_fw_name,
>    BNXT_NAME_SIZE);
>
> if (resp->mgmt_fw_maj == 0 && resp->mgmt_fw_min == 0 &&
>    resp->mgmt_fw_bld == 0) {
> strlcpy(softc->ver_info->mgmt_fw_ver, naver, BNXT_VERSTR_SIZE);
> strlcpy(softc->ver_info->mgmt_fw_name, nastr, BNXT_NAME_SIZE);
> }
> else {
> snprintf(softc->ver_info->mgmt_fw_ver, BNXT_VERSTR_SIZE,
>    "%d.%d.%d", resp->mgmt_fw_maj, resp->mgmt_fw_min,
>    resp->mgmt_fw_bld);
> strlcpy(softc->ver_info->mgmt_fw_name, resp->mgmt_fw_name,
>    BNXT_NAME_SIZE);
> }
> if (resp->netctrl_fw_maj == 0 && resp->netctrl_fw_min == 0 &&
>    resp->netctrl_fw_bld == 0) {
> strlcpy(softc->ver_info->netctrl_fw_ver, naver,
>    BNXT_VERSTR_SIZE);
> strlcpy(softc->ver_info->netctrl_fw_name, nastr,
>    BNXT_NAME_SIZE);
> }
> else {
> snprintf(softc->ver_info->netctrl_fw_ver, BNXT_VERSTR_SIZE,
>    "%d.%d.%d", resp->netctrl_fw_maj, resp->netctrl_fw_min,
>    resp->netctrl_fw_bld);
> strlcpy(softc->ver_info->netctrl_fw_name, resp->netctrl_fw_name,
>    BNXT_NAME_SIZE);
> }
> if (resp->roce_fw_maj == 0 && resp->roce_fw_min == 0 &&
>    resp->roce_fw_bld == 0) {
> strlcpy(softc->ver_info->roce_fw_ver, naver, BNXT_VERSTR_SIZE);
> strlcpy(softc->ver_info->roce_fw_name, nastr, BNXT_NAME_SIZE);
> }
> else {
> snprintf(softc->ver_info->roce_fw_ver, BNXT_VERSTR_SIZE,
>    "%d.%d.%d", resp->roce_fw_maj, resp->roce_fw_min,
>    resp->roce_fw_bld);
> strlcpy(softc->ver_info->roce_fw_name, resp->roce_fw_name,
>    BNXT_NAME_SIZE);
> }
> softc->ver_info->chip_num = le16toh(resp->chip_num);
> softc->ver_info->chip_rev = resp->chip_rev;
> softc->ver_info->chip_metal = resp->chip_metal;
> softc->ver_info->chip_bond_id = resp->chip_bond_id;
> softc->ver_info->chip_type = resp->chip_platform_type;
> #endif
>
> if (resp->max_req_win_len)
> softc->sc_max_req_len = le16toh(resp->max_req_win_len);
> if (resp->def_req_timeout)
> softc->sc_cmd_timeo = le16toh(resp->def_req_timeout);
>
> dev_caps_cfg = le32toh(resp->dev_caps_cfg);
> if ((dev_caps_cfg & HWRM_VER_GET_OUTPUT_DEV_CAPS_CFG_SHORT_CMD_SUPPORTED) &&
>    (dev_caps_cfg & HWRM_VER_GET_OUTPUT_DEV_CAPS_CFG_SHORT_CMD_REQUIRED))
> softc->sc_flags |= BNXT_FLAG_SHORT_CMD;
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
>
> int
> bnxt_hwrm_func_drv_rgtr(struct bnxt_softc *softc)
> {
> struct hwrm_func_drv_rgtr_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_RGTR);
>
> req.enables = htole32(HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_VER |
>    HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_OS_TYPE);
> req.os_type = htole16(HWRM_FUNC_DRV_RGTR_INPUT_OS_TYPE_FREEBSD);
>
> req.ver_maj = 6;
> req.ver_min = 4;
> req.ver_upd = 0;
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> #if 0
>
> int
> bnxt_hwrm_func_drv_unrgtr(struct bnxt_softc *softc, bool shutdown)
> {
> struct hwrm_func_drv_unrgtr_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_UNRGTR);
> if (shutdown == true)
> req.flags |=
>    HWRM_FUNC_DRV_UNRGTR_INPUT_FLAGS_PREPARE_FOR_SHUTDOWN;
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> #endif
>
> int
> bnxt_hwrm_func_qcaps(struct bnxt_softc *softc)
> {
> int rc = 0;
> struct hwrm_func_qcaps_input req = {0};
> struct hwrm_func_qcaps_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> /* struct bnxt_func_info *func = &softc->func; */
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_QCAPS);
> req.fid = htole16(0xffff);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> if (resp->flags &
>    htole32(HWRM_FUNC_QCAPS_OUTPUT_FLAGS_WOL_MAGICPKT_SUPPORTED))
> softc->sc_flags |= BNXT_FLAG_WOL_CAP;
>
> memcpy(softc->sc_ac.ac_enaddr, resp->mac_address, 6);
> /*
> func->fw_fid = le16toh(resp->fid);
> memcpy(func->mac_addr, resp->mac_address, ETHER_ADDR_LEN);
> func->max_rsscos_ctxs = le16toh(resp->max_rsscos_ctx);
> func->max_cp_rings = le16toh(resp->max_cmpl_rings);
> func->max_tx_rings = le16toh(resp->max_tx_rings);
> func->max_rx_rings = le16toh(resp->max_rx_rings);
> func->max_hw_ring_grps = le32toh(resp->max_hw_ring_grps);
> if (!func->max_hw_ring_grps)
> func->max_hw_ring_grps = func->max_tx_rings;
> func->max_l2_ctxs = le16toh(resp->max_l2_ctxs);
> func->max_vnics = le16toh(resp->max_vnics);
> func->max_stat_ctxs = le16toh(resp->max_stat_ctx);
> if (BNXT_PF(softc)) {
> struct bnxt_pf_info *pf = &softc->pf;
>
> pf->port_id = le16toh(resp->port_id);
> pf->first_vf_id = le16toh(resp->first_vf_id);
> pf->max_vfs = le16toh(resp->max_vfs);
> pf->max_encap_records = le32toh(resp->max_encap_records);
> pf->max_decap_records = le32toh(resp->max_decap_records);
> pf->max_tx_em_flows = le32toh(resp->max_tx_em_flows);
> pf->max_tx_wm_flows = le32toh(resp->max_tx_wm_flows);
> pf->max_rx_em_flows = le32toh(resp->max_rx_em_flows);
> pf->max_rx_wm_flows = le32toh(resp->max_rx_wm_flows);
> }
> if (!_is_valid_ether_addr(func->mac_addr)) {
> device_printf(softc->dev, "Invalid ethernet address, generating random locally administered address\n");
> get_random_ether_addr(func->mac_addr);
> }
> */
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
>
> int
> bnxt_hwrm_func_qcfg(struct bnxt_softc *softc)
> {
>         struct hwrm_func_qcfg_input req = {0};
>         /* struct hwrm_func_qcfg_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> struct bnxt_func_qcfg *fn_qcfg = &softc->fn_qcfg; */
>         int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_QCFG);
>         req.fid = htole16(0xffff);
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
>         if (rc)
> goto fail;
>
> /*
> fn_qcfg->alloc_completion_rings = le16toh(resp->alloc_cmpl_rings);
> fn_qcfg->alloc_tx_rings = le16toh(resp->alloc_tx_rings);
> fn_qcfg->alloc_rx_rings = le16toh(resp->alloc_rx_rings);
> fn_qcfg->alloc_vnics = le16toh(resp->alloc_vnics);
> */
> fail:
> BNXT_HWRM_UNLOCK(softc);
>         return rc;
> }
>
>
> int
> bnxt_hwrm_func_reset(struct bnxt_softc *softc)
> {
> struct hwrm_func_reset_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_RESET);
> req.enables = 0;
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> #if 0
> static void
> bnxt_hwrm_set_link_common(struct bnxt_softc *softc,
>     struct hwrm_port_phy_cfg_input *req)
> {
> uint8_t autoneg = softc->link_info.autoneg;
> uint16_t fw_link_speed = softc->link_info.req_link_speed;
>
> if (autoneg & BNXT_AUTONEG_SPEED) {
> req->auto_mode |=
>    HWRM_PORT_PHY_CFG_INPUT_AUTO_MODE_ALL_SPEEDS;
>
> req->enables |=
>    htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_AUTO_MODE);
> req->flags |=
>    htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_RESTART_AUTONEG);
> } else {
> req->force_link_speed = htole16(fw_link_speed);
> req->flags |= htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_FORCE);
> }
>
> /* tell chimp that the setting takes effect immediately */
> req->flags |= htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_RESET_PHY);
> }
>
>
> static void
> bnxt_hwrm_set_pause_common(struct bnxt_softc *softc,
>     struct hwrm_port_phy_cfg_input *req)
> {
> struct bnxt_link_info *link_info = &softc->link_info;
>
> if (link_info->flow_ctrl.autoneg) {
> req->auto_pause =
>    HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_AUTONEG_PAUSE;
> if (link_info->flow_ctrl.rx)
> req->auto_pause |=
>    HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_RX;
> if (link_info->flow_ctrl.tx)
> req->auto_pause |=
>    HWRM_PORT_PHY_CFG_INPUT_AUTO_PAUSE_TX;
> req->enables |=
>    htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_AUTO_PAUSE);
> } else {
> if (link_info->flow_ctrl.rx)
> req->force_pause |=
>    HWRM_PORT_PHY_CFG_INPUT_FORCE_PAUSE_RX;
> if (link_info->flow_ctrl.tx)
> req->force_pause |=
>    HWRM_PORT_PHY_CFG_INPUT_FORCE_PAUSE_TX;
> req->enables |=
> htole32(HWRM_PORT_PHY_CFG_INPUT_ENABLES_FORCE_PAUSE);
> }
> }
>
>
> /* JFV this needs interface connection */
> static void
> bnxt_hwrm_set_eee(struct bnxt_softc *softc, struct hwrm_port_phy_cfg_input *req)
> {
> /* struct ethtool_eee *eee = &softc->eee; */
> bool eee_enabled = false;
>
> if (eee_enabled) {
> # i f 0
> uint16_t eee_speeds;
> uint32_t flags = HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_ENABLE;
>
> if (eee->tx_lpi_enabled)
> flags |= HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_TX_LPI;
>
> req->flags |= htole32(flags);
> eee_speeds = bnxt_get_fw_auto_link_speeds(eee->advertised);
> req->eee_link_speed_mask = htole16(eee_speeds);
> req->tx_lpi_timer = htole32(eee->tx_lpi_timer);
> # e n d i f
> } else {
> req->flags |=
>    htole32(HWRM_PORT_PHY_CFG_INPUT_FLAGS_EEE_DISABLE);
> }
> }
>
>
> int
> bnxt_hwrm_set_link_setting(struct bnxt_softc *softc, bool set_pause,
>     bool set_eee, bool set_link)
> {
> struct hwrm_port_phy_cfg_input req = {0};
> int rc;
>
> if (softc->sc_flags & BNXT_FLAG_NPAR)
> return ENOTSUP;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_PHY_CFG);
>
> if (set_pause) {
> bnxt_hwrm_set_pause_common(softc, &req);
>
> if (softc->link_info.flow_ctrl.autoneg)
> set_link = true;
> }
>
> if (set_link)
> bnxt_hwrm_set_link_common(softc, &req);
>
> if (set_eee)
> bnxt_hwrm_set_eee(softc, &req);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
>
> if (!rc) {
> if (set_pause) {
> /* since changing of 'force pause' setting doesn't
> * trigger any link change event, the driver needs to
> * update the current pause result upon successfully i
> * return of the phy_cfg command */
> if (!softc->link_info.flow_ctrl.autoneg)
> bnxt_report_link(softc);
> }
> }
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> #endif
>
> int
> bnxt_hwrm_vnic_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
> {
> struct hwrm_vnic_cfg_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_CFG);
>
> if (vnic->flags & BNXT_VNIC_FLAG_DEFAULT)
> req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_DEFAULT);
> if (vnic->flags & BNXT_VNIC_FLAG_BD_STALL)
> req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_BD_STALL_MODE);
> if (vnic->flags & BNXT_VNIC_FLAG_VLAN_STRIP)
> req.flags |= htole32(HWRM_VNIC_CFG_INPUT_FLAGS_VLAN_STRIP_MODE);
> req.enables = htole32(HWRM_VNIC_CFG_INPUT_ENABLES_DFLT_RING_GRP |
>    HWRM_VNIC_CFG_INPUT_ENABLES_RSS_RULE |
>    HWRM_VNIC_CFG_INPUT_ENABLES_MRU);
> req.vnic_id = htole16(vnic->id);
> req.dflt_ring_grp = htole16(vnic->def_ring_grp);
> req.rss_rule = htole16(vnic->rss_id);
> req.cos_rule = htole16(vnic->cos_rule);
> req.lb_rule = htole16(vnic->lb_rule);
> req.mru = htole16(vnic->mru);
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> int
> bnxt_hwrm_vnic_alloc(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
> {
> struct hwrm_vnic_alloc_input req = {0};
> struct hwrm_vnic_alloc_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> int rc;
>
> if (vnic->id != (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to re-allocate vnic %04x\n",
>    DEVNAME(softc), vnic->id);
> return EINVAL;
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_ALLOC);
>
> if (vnic->flags & BNXT_VNIC_FLAG_DEFAULT)
> req.flags = htole32(HWRM_VNIC_ALLOC_INPUT_FLAGS_DEFAULT);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> vnic->id = le32toh(resp->vnic_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_vnic_free(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
> {
> struct hwrm_vnic_free_input req = {0};
> int rc;
>
> if (vnic->id == (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to deallocate vnic %04x\n",
>    DEVNAME(softc), vnic->id);
> return (EINVAL);
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_FREE);
> req.vnic_id = htole16(vnic->id);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc == 0)
> vnic->id = (uint16_t)HWRM_NA_SIGNATURE;
> BNXT_HWRM_UNLOCK(softc);
>
> return (rc);
> }
>
> int
> bnxt_hwrm_vnic_ctx_alloc(struct bnxt_softc *softc, uint16_t *ctx_id)
> {
> struct hwrm_vnic_rss_cos_lb_ctx_alloc_input req = {0};
> struct hwrm_vnic_rss_cos_lb_ctx_alloc_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> int rc;
>
> if (*ctx_id != (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to re-allocate vnic ctx %04x\n",
>    DEVNAME(softc), *ctx_id);
> return EINVAL;
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_COS_LB_CTX_ALLOC);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> *ctx_id = letoh16(resp->rss_cos_lb_ctx_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_vnic_ctx_free(struct bnxt_softc *softc, uint16_t *ctx_id)
> {
> struct hwrm_vnic_rss_cos_lb_ctx_free_input req = {0};
> int rc;
>
> if (*ctx_id == (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to deallocate vnic ctx %04x\n",
>    DEVNAME(softc), *ctx_id);
> return (EINVAL);
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_COS_LB_CTX_FREE);
> req.rss_cos_lb_ctx_id = htole32(*ctx_id);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc == 0)
> *ctx_id = (uint16_t)HWRM_NA_SIGNATURE;
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_ring_grp_alloc(struct bnxt_softc *softc, struct bnxt_grp_info *grp)
> {
> struct hwrm_ring_grp_alloc_input req = {0};
> struct hwrm_ring_grp_alloc_output *resp;
> int rc = 0;
>
> if (grp->grp_id != HWRM_NA_SIGNATURE) {
> printf("%s: attempt to re-allocate ring group %04x\n",
>    DEVNAME(softc), grp->grp_id);
> return EINVAL;
> }
>
> resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_GRP_ALLOC);
> req.cr = htole16(grp->cp_ring_id);
> req.rr = htole16(grp->rx_ring_id);
> req.ar = htole16(grp->ag_ring_id);
> req.sc = htole16(grp->stats_ctx);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> grp->grp_id = letoh32(resp->ring_group_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_ring_grp_free(struct bnxt_softc *softc, struct bnxt_grp_info *grp)
> {
> struct hwrm_ring_grp_free_input req = {0};
> int rc = 0;
>
> if (grp->grp_id == HWRM_NA_SIGNATURE) {
> printf("%s: attempt to free ring group %04x\n",
>    DEVNAME(softc), grp->grp_id);
> return EINVAL;
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_GRP_FREE);
> req.ring_group_id = htole32(grp->grp_id);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc == 0)
> grp->grp_id = HWRM_NA_SIGNATURE;
>
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> /*
>  * Ring allocation message to the firmware
>  */
> int
> bnxt_hwrm_ring_alloc(struct bnxt_softc *softc, uint8_t type,
>     struct bnxt_ring *ring, uint16_t cmpl_ring_id, uint32_t stat_ctx_id,
>     int irq)
> {
> struct hwrm_ring_alloc_input req = {0};
> struct hwrm_ring_alloc_output *resp;
> int rc;
>
> if (ring->phys_id != (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to re-allocate ring %04x\n",
>    DEVNAME(softc), ring->phys_id);
> return EINVAL;
> }
>
> resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_ALLOC);
> req.enables = htole32(0);
> req.fbo = htole32(0);
>
> if (stat_ctx_id != HWRM_NA_SIGNATURE) {
> req.enables |= htole32(
>    HWRM_RING_ALLOC_INPUT_ENABLES_STAT_CTX_ID_VALID);
> req.stat_ctx_id = htole32(stat_ctx_id);
> }
> req.ring_type = type;
> req.page_tbl_addr = htole64(ring->paddr);
> req.length = htole32(ring->ring_size);
> req.logical_id = htole16(ring->id);
> req.cmpl_ring_id = htole16(cmpl_ring_id);
> req.queue_id = htole16(softc->sc_q_info[0].id);
> req.int_mode = 0;
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> ring->phys_id = le16toh(resp->ring_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_ring_free(struct bnxt_softc *softc, uint8_t type, struct bnxt_ring *ring)
> {
> struct hwrm_ring_free_input req = {0};
> int rc;
>
> if (ring->phys_id == (uint16_t)HWRM_NA_SIGNATURE) {
> printf("%s: attempt to deallocate ring %04x\n",
>    DEVNAME(softc), ring->phys_id);
> return (EINVAL);
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_RING_FREE);
> req.ring_type = type;
> req.ring_id = htole16(ring->phys_id);
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> ring->phys_id = (uint16_t)HWRM_NA_SIGNATURE;
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
>
> int
> bnxt_hwrm_stat_ctx_alloc(struct bnxt_softc *softc, struct bnxt_cp_ring *cpr,
>     uint64_t paddr)
> {
> struct hwrm_stat_ctx_alloc_input req = {0};
> struct hwrm_stat_ctx_alloc_output *resp;
> int rc = 0;
>
> if (cpr->stats_ctx_id != HWRM_NA_SIGNATURE) {
> printf("%s: attempt to re-allocate stats ctx %08x\n",
>    DEVNAME(softc), cpr->stats_ctx_id);
> return EINVAL;
> }
>
> resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_STAT_CTX_ALLOC);
>
> req.update_period_ms = htole32(1000);
> req.stats_dma_addr = htole64(paddr);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> cpr->stats_ctx_id = le32toh(resp->stat_ctx_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
>
> return rc;
> }
>
> int
> bnxt_hwrm_stat_ctx_free(struct bnxt_softc *softc, struct bnxt_cp_ring *cpr)
> {
> struct hwrm_stat_ctx_free_input req = {0};
> int rc = 0;
>
> if (cpr->stats_ctx_id == HWRM_NA_SIGNATURE) {
> printf("%s: attempt to free stats ctx %08x\n",
>    DEVNAME(softc), cpr->stats_ctx_id);
> return EINVAL;
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_STAT_CTX_FREE);
> req.stat_ctx_id = htole32(cpr->stats_ctx_id);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> BNXT_HWRM_UNLOCK(softc);
>
> if (rc == 0)
> cpr->stats_ctx_id = HWRM_NA_SIGNATURE;
>
> return (rc);
> }
>
> #if 0
>
> int
> bnxt_hwrm_port_qstats(struct bnxt_softc *softc)
> {
> struct hwrm_port_qstats_input req = {0};
> int rc = 0;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_QSTATS);
>
> req.port_id = htole16(softc->pf.port_id);
> req.rx_stat_host_addr = htole64(softc->hw_rx_port_stats.idi_paddr);
> req.tx_stat_host_addr = htole64(softc->hw_tx_port_stats.idi_paddr);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> BNXT_HWRM_UNLOCK(softc);
>
> return rc;
> }
>
> #endif
>
> int
> bnxt_hwrm_cfa_l2_set_rx_mask(struct bnxt_softc *softc,
>     struct bnxt_vnic_info *vnic)
> {
> struct hwrm_cfa_l2_set_rx_mask_input req = {0};
> uint32_t mask = vnic->rx_mask;
>
> #if 0
> struct bnxt_vlan_tag *tag;
> uint32_t *tags;
> uint32_t num_vlan_tags = 0;;
> uint32_t i;
> int rc;
>
> SLIST_FOREACH(tag, &vnic->vlan_tags, next)
> num_vlan_tags++;
>
> if (num_vlan_tags) {
> if (!(mask &
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_ANYVLAN_NONVLAN)) {
> if (!vnic->vlan_only)
> mask |= HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLAN_NONVLAN;
> else
> mask |=
>    HWRM_CFA_L2_SET_RX_MASK_INPUT_MASK_VLANONLY;
> }
> if (vnic->vlan_tag_list.idi_vaddr) {
> iflib_dma_free(&vnic->vlan_tag_list);
> vnic->vlan_tag_list.idi_vaddr = NULL;
> }
> rc = iflib_dma_alloc(softc->ctx, 4 * num_vlan_tags,
>    &vnic->vlan_tag_list, BUS_DMA_NOWAIT);
> if (rc)
> return rc;
> tags = (uint32_t *)vnic->vlan_tag_list.idi_vaddr;
>
> i = 0;
> SLIST_FOREACH(tag, &vnic->vlan_tags, next) {
> tags[i] = htole32((tag->tpid << 16) | tag->tag);
> i++;
> }
> }
> #endif
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_SET_RX_MASK);
>
> req.vnic_id = htole32(vnic->id);
> req.mask = htole32(mask);
> #if 0
> req.mc_tbl_addr = htole64(vnic->mc_list.idi_paddr);
> req.num_mc_entries = htole32(vnic->mc_list_count);
> req.vlan_tag_tbl_addr = htole64(vnic->vlan_tag_list.idi_paddr);
> req.num_vlan_tags = htole32(num_vlan_tags);
> #endif
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> int
> bnxt_hwrm_set_filter(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
> {
> struct hwrm_cfa_l2_filter_alloc_input req = {0};
> struct hwrm_cfa_l2_filter_alloc_output *resp;
> uint32_t enables = 0;
> int rc = 0;
>
> if (vnic->filter_id != -1) {
> printf("%s: attempt to re-allocate l2 ctx filter\n",
>    DEVNAME(softc));
> return EINVAL;
> }
>
> resp = BNXT_DMA_KVA(softc->sc_cmd_resp);
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_FILTER_ALLOC);
>
> req.flags = htole32(HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX);
> enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR
>    | HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK
>    | HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_DST_ID;
> req.enables = htole32(enables);
> req.dst_id = htole16(vnic->id);
> memcpy(req.l2_addr, softc->sc_ac.ac_enaddr, ETHER_ADDR_LEN);
> memset(&req.l2_addr_mask, 0xff, sizeof(req.l2_addr_mask));
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto fail;
>
> vnic->filter_id = le64toh(resp->l2_filter_id);
> vnic->flow_id = le64toh(resp->flow_id);
>
> fail:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_free_filter(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic)
> {
> struct hwrm_cfa_l2_filter_free_input req = {0};
> int rc = 0;
>
> if (vnic->filter_id == -1) {
> printf("%s: attempt to deallocate filter %llx\n",
>     DEVNAME(softc), vnic->filter_id);
> return (EINVAL);
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_CFA_L2_FILTER_FREE);
> req.l2_filter_id = htole64(vnic->filter_id);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc == 0)
> vnic->filter_id = -1;
> BNXT_HWRM_UNLOCK(softc);
>
> return (rc);
> }
>
>
> #if 0
>
> int
> bnxt_hwrm_rss_cfg(struct bnxt_softc *softc, struct bnxt_vnic_info *vnic,
>     uint32_t hash_type)
> {
> struct hwrm_vnic_rss_cfg_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_RSS_CFG);
>
> req.hash_type = htole32(hash_type);
> req.ring_grp_tbl_addr = htole64(vnic->rss_grp_tbl.idi_paddr);
> req.hash_key_tbl_addr = htole64(vnic->rss_hash_key_tbl.idi_paddr);
> req.rss_ctx_idx = htole16(vnic->rss_id);
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> #endif
>
> int
> bnxt_cfg_async_cr(struct bnxt_softc *softc)
> {
> int rc = 0;
>
> if (1 /* BNXT_PF(softc) */) {
> struct hwrm_func_cfg_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_CFG);
>
> req.fid = htole16(0xffff);
> req.enables = htole32(HWRM_FUNC_CFG_INPUT_ENABLES_ASYNC_EVENT_CR);
> req.async_event_cr = htole16(softc->sc_cp_ring.ring.phys_id);
>
> rc = hwrm_send_message(softc, &req, sizeof(req));
> } else {
> struct hwrm_func_vf_cfg_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_VF_CFG);
>
> req.enables = htole32(HWRM_FUNC_VF_CFG_INPUT_ENABLES_ASYNC_EVENT_CR);
> req.async_event_cr = htole16(softc->sc_cp_ring.ring.phys_id);
>
> rc = hwrm_send_message(softc, &req, sizeof(req));
> }
> return rc;
> }
>
> #if 0
>
> void
> bnxt_validate_hw_lro_settings(struct bnxt_softc *softc)
> {
> softc->hw_lro.enable = min(softc->hw_lro.enable, 1);
>
>         softc->hw_lro.is_mode_gro = min(softc->hw_lro.is_mode_gro, 1);
>
> softc->hw_lro.max_agg_segs = min(softc->hw_lro.max_agg_segs,
> HWRM_VNIC_TPA_CFG_INPUT_MAX_AGG_SEGS_MAX);
>
> softc->hw_lro.max_aggs = min(softc->hw_lro.max_aggs,
> HWRM_VNIC_TPA_CFG_INPUT_MAX_AGGS_MAX);
>
> softc->hw_lro.min_agg_len = min(softc->hw_lro.min_agg_len, BNXT_MAX_MTU);
> }
>
> int
> bnxt_hwrm_vnic_tpa_cfg(struct bnxt_softc *softc)
> {
> struct hwrm_vnic_tpa_cfg_input req = {0};
> uint32_t flags;
>
> if (softc->vnic_info.id == (uint16_t) HWRM_NA_SIGNATURE) {
> return 0;
> }
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_VNIC_TPA_CFG);
>
> if (softc->hw_lro.enable) {
> flags = HWRM_VNIC_TPA_CFG_INPUT_FLAGS_TPA |
> HWRM_VNIC_TPA_CFG_INPUT_FLAGS_ENCAP_TPA |
> HWRM_VNIC_TPA_CFG_INPUT_FLAGS_AGG_WITH_ECN |
> HWRM_VNIC_TPA_CFG_INPUT_FLAGS_AGG_WITH_SAME_GRE_SEQ;
>
>         if (softc->hw_lro.is_mode_gro)
> flags |= HWRM_VNIC_TPA_CFG_INPUT_FLAGS_GRO;
> else
> flags |= HWRM_VNIC_TPA_CFG_INPUT_FLAGS_RSC_WND_UPDATE;
>
> req.flags = htole32(flags);
>
> req.enables = htole32(HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MAX_AGG_SEGS |
> HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MAX_AGGS |
> HWRM_VNIC_TPA_CFG_INPUT_ENABLES_MIN_AGG_LEN);
>
> req.max_agg_segs = htole16(softc->hw_lro.max_agg_segs);
> req.max_aggs = htole16(softc->hw_lro.max_aggs);
> req.min_agg_len = htole32(softc->hw_lro.min_agg_len);
> }
>
> req.vnic_id = htole16(softc->vnic_info.id);
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> int
> bnxt_hwrm_nvm_find_dir_entry(struct bnxt_softc *softc, uint16_t type,
>     uint16_t *ordinal, uint16_t ext, uint16_t *index, bool use_index,
>     uint8_t search_opt, uint32_t *data_length, uint32_t *item_length,
>     uint32_t *fw_ver)
> {
> struct hwrm_nvm_find_dir_entry_input req = {0};
> struct hwrm_nvm_find_dir_entry_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc = 0;
> uint32_t old_timeo;
>
> MPASS(ordinal);
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_FIND_DIR_ENTRY);
> if (use_index) {
> req.enables = htole32(
>    HWRM_NVM_FIND_DIR_ENTRY_INPUT_ENABLES_DIR_IDX_VALID);
> req.dir_idx = htole16(*index);
> }
> req.dir_type = htole16(type);
> req.dir_ordinal = htole16(*ordinal);
> req.dir_ext = htole16(ext);
> req.opt_ordinal = search_opt;
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> if (rc)
> goto exit;
>
> if (item_length)
> *item_length = le32toh(resp->dir_item_length);
> if (data_length)
> *data_length = le32toh(resp->dir_data_length);
> if (fw_ver)
> *fw_ver = le32toh(resp->fw_ver);
> *ordinal = le16toh(resp->dir_ordinal);
> if (index)
> *index = le16toh(resp->dir_idx);
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return (rc);
> }
>
> int
> bnxt_hwrm_nvm_read(struct bnxt_softc *softc, uint16_t index, uint32_t offset,
>     uint32_t length, struct iflib_dma_info *data)
> {
> struct hwrm_nvm_read_input req = {0};
> int rc;
> uint32_t old_timeo;
>
> if (length > data->idi_size) {
> rc = EINVAL;
> goto exit;
> }
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_READ);
> req.host_dest_addr = htole64(data->idi_paddr);
> req.dir_idx = htole16(index);
> req.offset = htole32(offset);
> req.len = htole32(length);
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> BNXT_HWRM_UNLOCK(softc);
> if (rc)
> goto exit;
> bus_dmamap_sync(data->idi_tag, data->idi_map, BUS_DMASYNC_POSTREAD);
>
> goto exit;
>
> exit:
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_modify(struct bnxt_softc *softc, uint16_t index, uint32_t offset,
>     void *data, bool cpyin, uint32_t length)
> {
> struct hwrm_nvm_modify_input req = {0};
> struct iflib_dma_info dma_data;
> int rc;
> uint32_t old_timeo;
>
> if (length == 0 || !data)
> return EINVAL;
> rc = iflib_dma_alloc(softc->ctx, length, &dma_data,
>    BUS_DMA_NOWAIT);
> if (rc)
> return ENOMEM;
> if (cpyin) {
> rc = copyin(data, dma_data.idi_vaddr, length);
> if (rc)
> goto exit;
> }
> else
> memcpy(dma_data.idi_vaddr, data, length);
> bus_dmamap_sync(dma_data.idi_tag, dma_data.idi_map,
>    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_MODIFY);
> req.host_src_addr = htole64(dma_data.idi_paddr);
> req.dir_idx = htole16(index);
> req.offset = htole32(offset);
> req.len = htole32(length);
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> BNXT_HWRM_UNLOCK(softc);
>
> exit:
> iflib_dma_free(&dma_data);
> return rc;
> }
>
> int
> bnxt_hwrm_fw_reset(struct bnxt_softc *softc, uint8_t processor,
>     uint8_t *selfreset)
> {
> struct hwrm_fw_reset_input req = {0};
> struct hwrm_fw_reset_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
>
> MPASS(selfreset);
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_RESET);
> req.embedded_proc_type = processor;
> req.selfrst_status = *selfreset;
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto exit;
> *selfreset = resp->selfrst_status;
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_fw_qstatus(struct bnxt_softc *softc, uint8_t type, uint8_t *selfreset)
> {
> struct hwrm_fw_qstatus_input req = {0};
> struct hwrm_fw_qstatus_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
>
> MPASS(selfreset);
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_QSTATUS);
> req.embedded_proc_type = type;
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto exit;
> *selfreset = resp->selfrst_status;
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_write(struct bnxt_softc *softc, void *data, bool cpyin,
>     uint16_t type, uint16_t ordinal, uint16_t ext, uint16_t attr,
>     uint16_t option, uint32_t data_length, bool keep, uint32_t *item_length,
>     uint16_t *index)
> {
> struct hwrm_nvm_write_input req = {0};
> struct hwrm_nvm_write_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> struct iflib_dma_info dma_data;
> int rc;
> uint32_t old_timeo;
>
> if (data_length) {
> rc = iflib_dma_alloc(softc->ctx, data_length, &dma_data,
>    BUS_DMA_NOWAIT);
> if (rc)
> return ENOMEM;
> if (cpyin) {
> rc = copyin(data, dma_data.idi_vaddr, data_length);
> if (rc)
> goto early_exit;
> }
> else
> memcpy(dma_data.idi_vaddr, data, data_length);
> bus_dmamap_sync(dma_data.idi_tag, dma_data.idi_map,
>    BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
> }
> else
> dma_data.idi_paddr = 0;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_WRITE);
>
> req.host_src_addr = htole64(dma_data.idi_paddr);
> req.dir_type = htole16(type);
> req.dir_ordinal = htole16(ordinal);
> req.dir_ext = htole16(ext);
> req.dir_attr = htole16(attr);
> req.dir_data_length = htole32(data_length);
> req.option = htole16(option);
> if (keep) {
> req.flags =
>    htole16(HWRM_NVM_WRITE_INPUT_FLAGS_KEEP_ORIG_ACTIVE_IMG);
> }
> if (item_length)
> req.dir_item_length = htole32(*item_length);
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> if (rc)
> goto exit;
> if (item_length)
> *item_length = le32toh(resp->dir_item_length);
> if (index)
> *index = le16toh(resp->dir_idx);
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> early_exit:
> if (data_length)
> iflib_dma_free(&dma_data);
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_erase_dir_entry(struct bnxt_softc *softc, uint16_t index)
> {
> struct hwrm_nvm_erase_dir_entry_input req = {0};
> uint32_t old_timeo;
> int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_ERASE_DIR_ENTRY);
> req.dir_idx = htole16(index);
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_get_dir_info(struct bnxt_softc *softc, uint32_t *entries,
>     uint32_t *entry_length)
> {
> struct hwrm_nvm_get_dir_info_input req = {0};
> struct hwrm_nvm_get_dir_info_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
> uint32_t old_timeo;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DIR_INFO);
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> if (rc)
> goto exit;
>
> if (entries)
> *entries = le32toh(resp->entries);
> if (entry_length)
> *entry_length = le32toh(resp->entry_length);
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_get_dir_entries(struct bnxt_softc *softc, uint32_t *entries,
>     uint32_t *entry_length, struct iflib_dma_info *dma_data)
> {
> struct hwrm_nvm_get_dir_entries_input req = {0};
> uint32_t ent;
> uint32_t ent_len;
> int rc;
> uint32_t old_timeo;
>
> if (!entries)
> entries = &ent;
> if (!entry_length)
> entry_length = &ent_len;
>
> rc = bnxt_hwrm_nvm_get_dir_info(softc, entries, entry_length);
> if (rc)
> goto exit;
> if (*entries * *entry_length > dma_data->idi_size) {
> rc = EINVAL;
> goto exit;
> }
>
> /*
> * TODO: There's a race condition here that could blow up DMA memory...
> * we need to allocate the max size, not the currently in use
> * size.  The command should totally have a max size here.
> */
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DIR_ENTRIES);
> req.host_dest_addr = htole64(dma_data->idi_paddr);
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> BNXT_HWRM_UNLOCK(softc);
> if (rc)
> goto exit;
> bus_dmamap_sync(dma_data->idi_tag, dma_data->idi_map,
>    BUS_DMASYNC_POSTWRITE);
>
> exit:
> return rc;
> }
>
> #endif
>
> int
> bnxt_hwrm_nvm_get_dev_info(struct bnxt_softc *softc, uint16_t *mfg_id,
>     uint16_t *device_id, uint32_t *sector_size, uint32_t *nvram_size,
>     uint32_t *reserved_size, uint32_t *available_size)
> {
> struct hwrm_nvm_get_dev_info_input req = {0};
> struct hwrm_nvm_get_dev_info_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> int rc;
> uint32_t old_timeo;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_GET_DEV_INFO);
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->sc_cmd_timeo;
> softc->sc_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->sc_cmd_timeo = old_timeo;
> if (rc)
> goto exit;
>
> if (mfg_id)
> *mfg_id = le16toh(resp->manufacturer_id);
> if (device_id)
> *device_id = le16toh(resp->device_id);
> if (sector_size)
> *sector_size = le32toh(resp->sector_size);
> if (nvram_size)
> *nvram_size = le32toh(resp->nvram_size);
> if (reserved_size)
> *reserved_size = le32toh(resp->reserved_size);
> if (available_size)
> *available_size = le32toh(resp->available_size);
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> #if 0
>
> int
> bnxt_hwrm_nvm_install_update(struct bnxt_softc *softc,
>     uint32_t install_type, uint64_t *installed_items, uint8_t *result,
>     uint8_t *problem_item, uint8_t *reset_required)
> {
> struct hwrm_nvm_install_update_input req = {0};
> struct hwrm_nvm_install_update_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
> uint32_t old_timeo;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_INSTALL_UPDATE);
> req.install_type = htole32(install_type);
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> if (rc)
> goto exit;
>
> if (installed_items)
> *installed_items = le32toh(resp->installed_items);
> if (result)
> *result = resp->result;
> if (problem_item)
> *problem_item = resp->problem_item;
> if (reset_required)
> *reset_required = resp->reset_required;
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_nvm_verify_update(struct bnxt_softc *softc, uint16_t type,
>     uint16_t ordinal, uint16_t ext)
> {
> struct hwrm_nvm_verify_update_input req = {0};
> uint32_t old_timeo;
> int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_NVM_VERIFY_UPDATE);
>
> req.dir_type = htole16(type);
> req.dir_ordinal = htole16(ordinal);
> req.dir_ext = htole16(ext);
>
> BNXT_HWRM_LOCK(softc);
> old_timeo = softc->hwrm_cmd_timeo;
> softc->hwrm_cmd_timeo = BNXT_NVM_TIMEO;
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> softc->hwrm_cmd_timeo = old_timeo;
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_fw_get_time(struct bnxt_softc *softc, uint16_t *year, uint8_t *month,
>     uint8_t *day, uint8_t *hour, uint8_t *minute, uint8_t *second,
>     uint16_t *millisecond, uint16_t *zone)
> {
> struct hwrm_fw_get_time_input req = {0};
> struct hwrm_fw_get_time_output *resp =
>    (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_GET_TIME);
>
> BNXT_HWRM_LOCK(softc);
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc)
> goto exit;
>
> if (year)
> *year = le16toh(resp->year);
> if (month)
> *month = resp->month;
> if (day)
> *day = resp->day;
> if (hour)
> *hour = resp->hour;
> if (minute)
> *minute = resp->minute;
> if (second)
> *second = resp->second;
> if (millisecond)
> *millisecond = le16toh(resp->millisecond);
> if (zone)
> *zone = le16toh(resp->zone);
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
> return rc;
> }
>
> int
> bnxt_hwrm_fw_set_time(struct bnxt_softc *softc, uint16_t year, uint8_t month,
>     uint8_t day, uint8_t hour, uint8_t minute, uint8_t second,
>     uint16_t millisecond, uint16_t zone)
> {
> struct hwrm_fw_set_time_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FW_SET_TIME);
>
> req.year = htole16(year);
> req.month = month;
> req.day = day;
> req.hour = hour;
> req.minute = minute;
> req.second = second;
> req.millisecond = htole16(millisecond);
> req.zone = htole16(zone);
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> #endif
>
> int
> bnxt_hwrm_port_phy_qcfg(struct bnxt_softc *softc, struct ifmediareq *ifmr)
> {
> struct ifnet *ifp = &softc->sc_ac.ac_if;
> struct hwrm_port_phy_qcfg_input req = {0};
> struct hwrm_port_phy_qcfg_output *resp =
>    BNXT_DMA_KVA(softc->sc_cmd_resp);
> int rc = 0;
> int link_state = LINK_STATE_DOWN;
>
> BNXT_HWRM_LOCK(softc);
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_PORT_PHY_QCFG);
>
> rc = _hwrm_send_message(softc, &req, sizeof(req));
> if (rc) {
> printf("%s: failed to query port phy config\n", DEVNAME(softc));
> goto exit;
> }
>
> if (resp->link == HWRM_PORT_PHY_QCFG_OUTPUT_LINK_LINK) {
> if (resp->duplex_state == HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_STATE_HALF)
> link_state = LINK_STATE_HALF_DUPLEX;
> else
> link_state = LINK_STATE_FULL_DUPLEX;
>
> switch (resp->link_speed) {
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10MB:
> ifp->if_baudrate = IF_Mbps(10);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100MB:
> ifp->if_baudrate = IF_Mbps(100);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_1GB:
> ifp->if_baudrate = IF_Gbps(1);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2GB:
> ifp->if_baudrate = IF_Gbps(2);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_2_5GB:
> ifp->if_baudrate = IF_Mbps(2500);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_10GB:
> ifp->if_baudrate = IF_Gbps(10);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_20GB:
> ifp->if_baudrate = IF_Gbps(20);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_25GB:
> ifp->if_baudrate = IF_Gbps(25);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_40GB:
> ifp->if_baudrate = IF_Gbps(40);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_50GB:
> ifp->if_baudrate = IF_Gbps(50);
> break;
> case HWRM_PORT_PHY_QCFG_OUTPUT_LINK_SPEED_100GB:
> ifp->if_baudrate = IF_Gbps(100);
> break;
> }
> }
>
> if (ifmr != NULL) {
> ifmr->ifm_status = IFM_AVALID;
> if (LINK_STATE_IS_UP(ifp->if_link_state)) {
> ifmr->ifm_status |= IFM_ACTIVE;
> ifmr->ifm_active = IFM_ETHER | IFM_AUTO;
> if (resp->pause & HWRM_PORT_PHY_QCFG_OUTPUT_PAUSE_TX)
> ifmr->ifm_active |= IFM_ETH_TXPAUSE;
> if (resp->pause & HWRM_PORT_PHY_QCFG_OUTPUT_PAUSE_RX)
> ifmr->ifm_active |= IFM_ETH_RXPAUSE;
> if (resp->duplex_state == HWRM_PORT_PHY_QCFG_OUTPUT_DUPLEX_STATE_HALF)
> ifmr->ifm_active |= IFM_HDX;
> else
> ifmr->ifm_active |= IFM_FDX;
> }
> }
>
> exit:
> BNXT_HWRM_UNLOCK(softc);
>
> if (rc == 0 && (link_state != ifp->if_link_state)) {
> ifp->if_link_state = link_state;
> if_link_state_change(ifp);
> }
>
> return rc;
> }
>
> #if 0
>
> uint16_t
> bnxt_hwrm_get_wol_fltrs(struct bnxt_softc *softc, uint16_t handle)
> {
> struct hwrm_wol_filter_qcfg_input req = {0};
> struct hwrm_wol_filter_qcfg_output *resp =
> (void *)softc->hwrm_cmd_resp.idi_vaddr;
> uint16_t next_handle = 0;
> int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_QCFG);
> req.port_id = htole16(softc->pf.port_id);
> req.handle = htole16(handle);
> rc = hwrm_send_message(softc, &req, sizeof(req));
> if (!rc) {
> next_handle = le16toh(resp->next_handle);
> if (next_handle != 0) {
> if (resp->wol_type ==
> HWRM_WOL_FILTER_ALLOC_INPUT_WOL_TYPE_MAGICPKT) {
> softc->wol = 1;
> softc->wol_filter_id = resp->wol_filter_id;
> }
> }
> }
> return next_handle;
> }
>
> int
> bnxt_hwrm_alloc_wol_fltr(struct bnxt_softc *softc)
> {
> struct hwrm_wol_filter_alloc_input req = {0};
> struct hwrm_wol_filter_alloc_output *resp =
> (void *)softc->hwrm_cmd_resp.idi_vaddr;
> int rc;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_ALLOC);
> req.port_id = htole16(softc->pf.port_id);
> req.wol_type = HWRM_WOL_FILTER_ALLOC_INPUT_WOL_TYPE_MAGICPKT;
> req.enables =
> htole32(HWRM_WOL_FILTER_ALLOC_INPUT_ENABLES_MAC_ADDRESS);
> memcpy(req.mac_address, softc->func.mac_addr, ETHER_ADDR_LEN);
> rc = hwrm_send_message(softc, &req, sizeof(req));
> if (!rc)
> softc->wol_filter_id = resp->wol_filter_id;
>
> return rc;
> }
>
> int
> bnxt_hwrm_free_wol_fltr(struct bnxt_softc *softc)
> {
> struct hwrm_wol_filter_free_input req = {0};
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_WOL_FILTER_FREE);
> req.port_id = htole16(softc->pf.port_id);
> req.enables =
> htole32(HWRM_WOL_FILTER_FREE_INPUT_ENABLES_WOL_FILTER_ID);
> req.wol_filter_id = softc->wol_filter_id;
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
> static void bnxt_hwrm_set_coal_params(struct bnxt_softc *softc, uint32_t max_frames,
>         uint32_t buf_tmrs, uint16_t flags,
>         struct hwrm_ring_cmpl_ring_cfg_aggint_params_input *req)
> {
>         req->flags = htole16(flags);
>         req->num_cmpl_dma_aggr = htole16((uint16_t)max_frames);
>         req->num_cmpl_dma_aggr_during_int = htole16(max_frames >> 16);
>         req->cmpl_aggr_dma_tmr = htole16((uint16_t)buf_tmrs);
>         req->cmpl_aggr_dma_tmr_during_int = htole16(buf_tmrs >> 16);
>         /* Minimum time between 2 interrupts set to buf_tmr x 2 */
>         req->int_lat_tmr_min = htole16((uint16_t)buf_tmrs * 2);
>         req->int_lat_tmr_max = htole16((uint16_t)buf_tmrs * 4);
>         req->num_cmpl_aggr_int = htole16((uint16_t)max_frames * 4);
> }
>
>
> int bnxt_hwrm_set_coal(struct bnxt_softc *softc)
> {
>         int i, rc = 0;
>         struct hwrm_ring_cmpl_ring_cfg_aggint_params_input req_rx = {0},
>                                                            req_tx = {0}, *req;
>         uint16_t max_buf, max_buf_irq;
>         uint16_t buf_tmr, buf_tmr_irq;
>         uint32_t flags;
>
>         bnxt_hwrm_cmd_hdr_init(softc, &req_rx,
>                                HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS);
>         bnxt_hwrm_cmd_hdr_init(softc, &req_tx,
>                                HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS);
>
>         /* Each rx completion (2 records) should be DMAed immediately.
>          * DMA 1/4 of the completion buffers at a time.
>          */
>         max_buf = min_t(uint16_t, softc->rx_coal_frames / 4, 2);
>         /* max_buf must not be zero */
>         max_buf = clamp_t(uint16_t, max_buf, 1, 63);
>         max_buf_irq = clamp_t(uint16_t, softc->rx_coal_frames_irq, 1, 63);
>         buf_tmr = BNXT_USEC_TO_COAL_TIMER(softc->rx_coal_usecs);
>         /* buf timer set to 1/4 of interrupt timer */
>         buf_tmr = max_t(uint16_t, buf_tmr / 4, 1);
>         buf_tmr_irq = BNXT_USEC_TO_COAL_TIMER(softc->rx_coal_usecs_irq);
>         buf_tmr_irq = max_t(uint16_t, buf_tmr_irq, 1);
>
>         flags = HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_TIMER_RESET;
>
>         /* RING_IDLE generates more IRQs for lower latency.  Enable it only
>          * if coal_usecs is less than 25 us.
>          */
>         if (softc->rx_coal_usecs < 25)
>                 flags |= HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_RING_IDLE;
>
>         bnxt_hwrm_set_coal_params(softc, max_buf_irq << 16 | max_buf,
>                                   buf_tmr_irq << 16 | buf_tmr, flags, &req_rx);
>
>         /* max_buf must not be zero */
>         max_buf = clamp_t(uint16_t, softc->tx_coal_frames, 1, 63);
>         max_buf_irq = clamp_t(uint16_t, softc->tx_coal_frames_irq, 1, 63);
>         buf_tmr = BNXT_USEC_TO_COAL_TIMER(softc->tx_coal_usecs);
>         /* buf timer set to 1/4 of interrupt timer */
>         buf_tmr = max_t(uint16_t, buf_tmr / 4, 1);
>         buf_tmr_irq = BNXT_USEC_TO_COAL_TIMER(softc->tx_coal_usecs_irq);
>         buf_tmr_irq = max_t(uint16_t, buf_tmr_irq, 1);
>         flags = HWRM_RING_CMPL_RING_CFG_AGGINT_PARAMS_INPUT_FLAGS_TIMER_RESET;
>         bnxt_hwrm_set_coal_params(softc, max_buf_irq << 16 | max_buf,
>                                   buf_tmr_irq << 16 | buf_tmr, flags, &req_tx);
>
>         for (i = 0; i < softc->nrxqsets; i++) {
>
>                
> req = &req_rx;
>                 /*
>                  * TBD:
> *      Check if Tx also needs to be done
>                  *      So far, Tx processing has been done in softirq contest
>                  *
> * req = &req_tx;
> */
> req->ring_id = htole16(softc->grp_info[i].cp_ring_id);
>
>                 rc = hwrm_send_message(softc, req, sizeof(*req));
>                 if (rc)
>                         break;
>         }
>         return rc;
> }
>
> #endif
>
> void
> _bnxt_hwrm_set_async_event_bit(struct hwrm_func_drv_rgtr_input *req, int bit)
> {
> req->async_event_fwd[bit/32] |= (1 << (bit % 32));
> }
>
> int bnxt_hwrm_func_rgtr_async_events(struct bnxt_softc *softc)
> {
> struct hwrm_func_drv_rgtr_input req = {0};
> int events[] = {
> HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE,
> HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PF_DRVR_UNLOAD,
> HWRM_ASYNC_EVENT_CMPL_EVENT_ID_PORT_CONN_NOT_ALLOWED,
> HWRM_ASYNC_EVENT_CMPL_EVENT_ID_VF_CFG_CHANGE,
> HWRM_ASYNC_EVENT_CMPL_EVENT_ID_LINK_SPEED_CFG_CHANGE
> };
> int i;
>
> bnxt_hwrm_cmd_hdr_init(softc, &req, HWRM_FUNC_DRV_RGTR);
>
> req.enables =
> htole32(HWRM_FUNC_DRV_RGTR_INPUT_ENABLES_ASYNC_EVENT_FWD);
>
> for (i = 0; i < nitems(events); i++)
> _bnxt_hwrm_set_async_event_bit(&req, events[i]);
>
> return hwrm_send_message(softc, &req, sizeof(req));
> }
>
>