#include "bpfilter.h"
#include "vlan.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sockio.h>
#include <sys/mbuf.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/intrmap.h>
#include <net/if.h>
#include <net/if_media.h>
#include <net/toeplitz.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#if NBPFILTER > 0
#include <net/bpf.h>
#endif
#include <machine/bus.h>
#include <machine/intr.h>
#include <dev/mii/mii.h>
#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcidevs.h>
#include <dev/pci/if_ngbereg.h>
const struct pci_matchid ngbe_devices[] = {
{ PCI_VENDOR_WANGXUN, PCI_PRODUCT_WANGXUN_WX1860A2 },
{ PCI_VENDOR_WANGXUN, PCI_PRODUCT_WANGXUN_WX1860AL1 }
};
int ngbe_match(struct device *, void *, void *);
void ngbe_attach(struct device *, struct device *, void *);
int ngbe_detach(struct device *, int);
void ngbe_init(void *);
int ngbe_ioctl(struct ifnet *, u_long, caddr_t);
int ngbe_media_change(struct ifnet *);
void ngbe_media_status(struct ifnet *, struct ifmediareq *);
int ngbe_rxfill(struct rx_ring *);
int ngbe_rxrinfo(struct ngbe_softc *, struct if_rxrinfo *);
void ngbe_start(struct ifqueue *);
void ngbe_stop(struct ngbe_softc *);
void ngbe_update_link_status(struct ngbe_softc *);
void ngbe_watchdog(struct ifnet *);
int ngbe_allocate_pci_resources(struct ngbe_softc *);
void ngbe_free_pci_resources(struct ngbe_softc *);
int ngbe_allocate_msix(struct ngbe_softc *);
void ngbe_setup_interface(struct ngbe_softc *);
int ngbe_setup_msix(struct ngbe_softc *);
int ngbe_dma_malloc(struct ngbe_softc *, bus_size_t,
struct ngbe_dma_alloc *);
void ngbe_dma_free(struct ngbe_softc *,
struct ngbe_dma_alloc *);
int ngbe_allocate_isb(struct ngbe_softc *);
void ngbe_free_isb(struct ngbe_softc *);
int ngbe_allocate_queues(struct ngbe_softc *);
void ngbe_free_receive_structures(struct ngbe_softc *);
void ngbe_free_receive_buffers(struct rx_ring *);
void ngbe_free_transmit_structures(struct ngbe_softc *);
void ngbe_free_transmit_buffers(struct tx_ring *);
int ngbe_allocate_receive_buffers(struct rx_ring *);
int ngbe_allocate_transmit_buffers(struct tx_ring *);
int ngbe_setup_receive_ring(struct rx_ring *);
int ngbe_setup_transmit_ring(struct tx_ring *);
int ngbe_setup_receive_structures(struct ngbe_softc *);
int ngbe_setup_transmit_structures(struct ngbe_softc *);
uint8_t * ngbe_addr_list_itr(struct ngbe_hw *, uint8_t **,
uint32_t *);
void ngbe_iff(struct ngbe_softc *);
int ngbe_initialize_receive_unit(struct ngbe_softc *);
void ngbe_initialize_rss_mapping(struct ngbe_softc *);
int ngbe_initialize_transmit_unit(struct ngbe_softc *);
int ngbe_intr_link(void *);
int ngbe_intr_queue(void *);
void ngbe_init_eeprom_params(struct ngbe_hw *);
int ngbe_init_hw(struct ngbe_softc *);
void ngbe_init_ops(struct ngbe_hw *);
void ngbe_init_rx_addrs(struct ngbe_softc *);
void ngbe_init_shared_code(struct ngbe_softc *);
void ngbe_init_thermal_sensor_thresh(struct ngbe_hw *);
void ngbe_init_uta_tables(struct ngbe_hw *);
void ngbe_fc_autoneg(struct ngbe_softc *);
int ngbe_fc_autoneg_copper(struct ngbe_softc *);
int ngbe_fc_enable(struct ngbe_softc *);
int ngbe_fmgr_cmd_op(struct ngbe_hw *, uint32_t, uint32_t);
uint32_t ngbe_flash_read_dword(struct ngbe_hw *, uint32_t);
uint8_t ngbe_calculate_checksum(uint8_t *, uint32_t);
int ngbe_check_flash_load(struct ngbe_softc *, uint32_t);
int ngbe_check_internal_phy_id(struct ngbe_softc *);
int ngbe_check_mac_link(struct ngbe_hw *, uint32_t *, int *,
int);
int ngbe_check_mng_access(struct ngbe_hw *);
int ngbe_check_reset_blocked(struct ngbe_softc *);
void ngbe_clear_hw_cntrs(struct ngbe_hw *);
void ngbe_clear_vfta(struct ngbe_hw *);
void ngbe_configure_ivars(struct ngbe_softc *);
void ngbe_configure_pb(struct ngbe_softc *);
void ngbe_disable_intr(struct ngbe_softc *);
int ngbe_disable_pcie_master(struct ngbe_softc *);
void ngbe_disable_queue(struct ngbe_softc *, uint32_t);
void ngbe_disable_rx(struct ngbe_hw *);
void ngbe_disable_sec_rx_path(struct ngbe_hw *);
int ngbe_eepromcheck_cap(struct ngbe_softc *, uint16_t,
uint32_t *);
void ngbe_enable_intr(struct ngbe_softc *);
void ngbe_enable_queue(struct ngbe_softc *, uint32_t);
void ngbe_enable_rx(struct ngbe_hw *);
void ngbe_enable_rx_dma(struct ngbe_hw *, uint32_t);
void ngbe_enable_sec_rx_path(struct ngbe_hw *);
int ngbe_encap(struct tx_ring *, struct mbuf *);
int ngbe_get_buf(struct rx_ring *, int);
void ngbe_get_bus_info(struct ngbe_softc *);
void ngbe_get_copper_link_capabilities(struct ngbe_hw *,
uint32_t *, int *);
int ngbe_get_eeprom_semaphore(struct ngbe_softc *);
void ngbe_get_hw_control(struct ngbe_hw *);
void ngbe_release_hw_control(struct ngbe_softc *);
void ngbe_get_mac_addr(struct ngbe_hw *, uint8_t *);
enum ngbe_media_type ngbe_get_media_type(struct ngbe_hw *);
void ngbe_gphy_dis_eee(struct ngbe_hw *);
void ngbe_gphy_efuse_calibration(struct ngbe_softc *);
void ngbe_gphy_wait_mdio_access_on(struct ngbe_hw *);
void ngbe_handle_phy_event(struct ngbe_softc *);
int ngbe_host_interface_command(struct ngbe_softc *,
uint32_t *, uint32_t, uint32_t, int);
int ngbe_hpbthresh(struct ngbe_softc *);
int ngbe_lpbthresh(struct ngbe_softc *);
int ngbe_mng_present(struct ngbe_hw *);
int ngbe_mta_vector(struct ngbe_hw *, uint8_t *);
int ngbe_negotiate_fc(struct ngbe_softc *, uint32_t,
uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
int ngbe_non_sfp_link_config(struct ngbe_softc *);
void ngbe_pbthresh_setup(struct ngbe_softc *);
void ngbe_phy_check_event(struct ngbe_softc *);
int ngbe_phy_check_overtemp(struct ngbe_hw *);
void ngbe_phy_get_advertised_pause(struct ngbe_hw *,
uint8_t *);
void ngbe_phy_get_lp_advertised_pause(struct ngbe_hw *,
uint8_t *);
int ngbe_phy_identify(struct ngbe_softc *);
int ngbe_phy_init(struct ngbe_softc *);
void ngbe_phy_led_ctrl(struct ngbe_softc *);
int ngbe_phy_led_oem_chk(struct ngbe_softc *, uint32_t *);
int ngbe_phy_read_reg(struct ngbe_hw *, uint32_t, uint32_t,
uint16_t *);
int ngbe_phy_write_reg(struct ngbe_hw *, uint32_t, uint32_t,
uint16_t);
int ngbe_phy_reset(struct ngbe_softc *);
int ngbe_phy_set_pause_advertisement(struct ngbe_hw *,
uint16_t);
int ngbe_phy_setup(struct ngbe_softc *);
int ngbe_phy_setup_link(struct ngbe_softc *, uint32_t, int);
uint16_t ngbe_read_pci_cfg_word(struct ngbe_softc *, uint32_t);
void ngbe_release_eeprom_semaphore(struct ngbe_hw *);
int ngbe_acquire_swfw_sync(struct ngbe_softc *, uint32_t);
void ngbe_release_swfw_sync(struct ngbe_softc *, uint32_t);
void ngbe_reset(struct ngbe_softc *);
int ngbe_reset_hw(struct ngbe_softc *);
void ngbe_reset_misc(struct ngbe_hw *);
int ngbe_set_fw_drv_ver(struct ngbe_softc *, uint8_t,
uint8_t, uint8_t, uint8_t);
void ngbe_set_ivar(struct ngbe_softc *, uint16_t, uint16_t,
int8_t);
void ngbe_set_lan_id_multi_port_pcie(struct ngbe_hw *);
void ngbe_set_mta(struct ngbe_hw *, uint8_t *);
void ngbe_set_pci_config_data(struct ngbe_hw *, uint16_t);
int ngbe_set_rar(struct ngbe_softc *, uint32_t, uint8_t *,
uint64_t, uint32_t);
void ngbe_set_rx_drop_en(struct ngbe_softc *);
void ngbe_set_rxpba(struct ngbe_hw *, int, uint32_t, int);
int ngbe_setup_copper_link(struct ngbe_softc *, uint32_t,
int);
int ngbe_setup_fc(struct ngbe_softc *);
void ngbe_setup_gpie(struct ngbe_hw *);
void ngbe_setup_isb(struct ngbe_softc *);
void ngbe_setup_psrtype(struct ngbe_hw *);
void ngbe_setup_vlan_hw_support(struct ngbe_softc *);
int ngbe_start_hw(struct ngbe_softc *);
int ngbe_stop_adapter(struct ngbe_softc *);
void ngbe_rx_checksum(uint32_t, struct mbuf *);
void ngbe_rxeof(struct rx_ring *);
void ngbe_rxrefill(void *);
int ngbe_tx_ctx_setup(struct tx_ring *, struct mbuf *,
uint32_t *, uint32_t *);
void ngbe_txeof(struct tx_ring *);
void ngbe_update_mc_addr_list(struct ngbe_hw *, uint8_t *,
uint32_t, ngbe_mc_addr_itr, int);
int ngbe_validate_mac_addr(uint8_t *);
struct cfdriver ngbe_cd = {
NULL, "ngbe", DV_IFNET
};
const struct cfattach ngbe_ca = {
sizeof(struct ngbe_softc), ngbe_match, ngbe_attach, ngbe_detach
};
int
ngbe_match(struct device *parent, void *match, void *aux)
{
return pci_matchbyid((struct pci_attach_args *)aux, ngbe_devices,
nitems(ngbe_devices));
}
void
ngbe_attach(struct device *parent, struct device *self, void *aux)
{
struct pci_attach_args *pa = (struct pci_attach_args *)aux;
struct ngbe_softc *sc = (struct ngbe_softc *)self;
struct ngbe_hw *hw = &sc->hw;
uint32_t eeprom_cksum_devcap, devcap, led_conf;
int error;
sc->osdep.os_sc = sc;
sc->osdep.os_pa = *pa;
if (ngbe_allocate_pci_resources(sc))
goto fail1;
sc->num_tx_desc = NGBE_DEFAULT_TXD;
sc->num_rx_desc = NGBE_DEFAULT_RXD;
if (ngbe_allocate_queues(sc))
goto fail1;
sc->mta = mallocarray(ETHER_ADDR_LEN, NGBE_SP_RAR_ENTRIES, M_DEVBUF,
M_NOWAIT);
if (sc->mta == NULL) {
printf(": can not allocate multicast setup array\n");
goto fail1;
}
if (ngbe_allocate_isb(sc))
goto fail2;
hw->mac.autoneg = 1;
hw->phy.autoneg_advertised = NGBE_LINK_SPEED_AUTONEG;
hw->phy.force_speed = NGBE_LINK_SPEED_UNKNOWN;
ngbe_init_shared_code(sc);
sc->hw.mac.ops.set_lan_id(&sc->hw);
error = ngbe_check_flash_load(sc, NGBE_SPI_ILDR_STATUS_PERST);
if (error)
goto fail3;
error = ngbe_check_flash_load(sc, NGBE_SPI_ILDR_STATUS_PWRRST);
if (error)
goto fail3;
hw->phy.reset_if_overtemp = 1;
error = sc->hw.mac.ops.reset_hw(sc);
hw->phy.reset_if_overtemp = 0;
if (error) {
printf(": HW reset failed\n");
goto fail3;
}
eeprom_cksum_devcap = devcap = 0;
if (hw->bus.lan_id == 0) {
NGBE_WRITE_REG(hw, NGBE_CALSUM_CAP_STATUS, 0);
NGBE_WRITE_REG(hw, NGBE_EEPROM_VERSION_STORE_REG, 0);
} else
eeprom_cksum_devcap = NGBE_READ_REG(hw, NGBE_CALSUM_CAP_STATUS);
hw->eeprom.ops.init_params(hw);
hw->mac.ops.release_swfw_sync(sc, NGBE_MNG_SWFW_SYNC_SW_MB);
if (hw->bus.lan_id == 0 || eeprom_cksum_devcap == 0) {
if (hw->eeprom.ops.eeprom_chksum_cap_st(sc, NGBE_CALSUM_COMMAND,
&devcap)) {
printf(": eeprom checksum is not valid\n");
goto fail3;
}
}
led_conf = 0;
if (hw->eeprom.ops.phy_led_oem_chk(sc, &led_conf))
sc->led_conf = -1;
else
sc->led_conf = led_conf;
memcpy(sc->sc_ac.ac_enaddr, sc->hw.mac.addr, ETHER_ADDR_LEN);
error = ngbe_allocate_msix(sc);
if (error)
goto fail3;
ngbe_setup_interface(sc);
error = hw->mac.ops.start_hw(sc);
if (error) {
printf(": HW init failed\n");
goto fail3;
}
hw->mac.ops.get_bus_info(sc);
hw->mac.ops.set_fw_drv_ver(sc, 0xff, 0xff, 0xff, 0xff);
printf(", address %s\n", ether_sprintf(sc->hw.mac.addr));
return;
fail3:
ngbe_free_isb(sc);
fail2:
ngbe_free_transmit_structures(sc);
ngbe_free_receive_structures(sc);
free(sc->mta, M_DEVBUF, ETHER_ADDR_LEN * NGBE_SP_RAR_ENTRIES);
fail1:
ngbe_free_pci_resources(sc);
}
int
ngbe_detach(struct device *self, int flags)
{
struct ngbe_softc *sc = (struct ngbe_softc *)self;
struct ifnet *ifp = &sc->sc_ac.ac_if;
ngbe_stop(sc);
ngbe_release_hw_control(sc);
ether_ifdetach(ifp);
if_detach(ifp);
ngbe_free_pci_resources(sc);
ngbe_free_transmit_structures(sc);
ngbe_free_receive_structures(sc);
ngbe_free_isb(sc);
free(sc->mta, M_DEVBUF, ETHER_ADDR_LEN * NGBE_SP_RAR_ENTRIES);
return 0;
}
static inline uint32_t
NGBE_READ_REG_MASK(struct ngbe_hw *hw, uint32_t reg, uint32_t mask)
{
uint32_t val;
val = NGBE_READ_REG(hw, reg);
if (val == NGBE_FAILED_READ_REG)
return val;
return val & mask;
}
static inline void
NGBE_WRITE_REG_MASK(struct ngbe_hw *hw, uint32_t reg, uint32_t mask,
uint32_t field)
{
uint32_t val;
val = NGBE_READ_REG(hw, reg);
if (val == NGBE_FAILED_READ_REG)
return;
val = ((val & ~mask) | (field & mask));
NGBE_WRITE_REG(hw, reg, val);
}
static inline uint32_t
ngbe_misc_isb(struct ngbe_softc *sc, enum ngbe_isb_idx idx)
{
return htole32(sc->isb_base[idx]);
}
void
ngbe_init(void *arg)
{
struct ngbe_softc *sc = (struct ngbe_softc *)arg;
struct ngbe_hw *hw = &sc->hw;
struct ifnet *ifp = &sc->sc_ac.ac_if;
int i, s;
s = splnet();
ngbe_stop(sc);
ngbe_setup_isb(sc);
hw->mac.ops.set_rar(sc, 0, hw->mac.addr, 0, NGBE_PSR_MAC_SWC_AD_H_AV);
bcopy(sc->sc_ac.ac_enaddr, sc->hw.mac.addr, ETHER_ADDR_LEN);
hw->mac.ops.set_rar(sc, 0, hw->mac.addr, 0, 1);
ngbe_configure_pb(sc);
ngbe_iff(sc);
ngbe_setup_vlan_hw_support(sc);
if (ngbe_setup_transmit_structures(sc)) {
printf("%s: could not setup transmit structures\n",
DEVNAME(sc));
ngbe_stop(sc);
splx(s);
return;
}
if (ngbe_initialize_transmit_unit(sc)) {
ngbe_stop(sc);
splx(s);
return;
}
if (ngbe_setup_receive_structures(sc)) {
printf("%s: could not setup receive structures\n",
DEVNAME(sc));
ngbe_stop(sc);
splx(s);
return;
}
if (ngbe_initialize_receive_unit(sc)) {
ngbe_stop(sc);
splx(s);
return;
}
ngbe_get_hw_control(hw);
ngbe_setup_gpie(hw);
ngbe_configure_ivars(sc);
if (ngbe_non_sfp_link_config(sc)) {
ngbe_stop(sc);
splx(s);
return;
}
NGBE_WRITE_REG(hw, NGBE_MAC_TX_CFG,
(NGBE_READ_REG(hw, NGBE_MAC_TX_CFG) & ~NGBE_MAC_TX_CFG_SPEED_MASK) |
NGBE_MAC_TX_CFG_SPEED_1G);
NGBE_READ_REG(hw, NGBE_PX_IC);
NGBE_READ_REG(hw, NGBE_PX_MISC_IC);
ngbe_enable_intr(sc);
switch (hw->bus.lan_id) {
case 0:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN0_UP, NGBE_MIS_PRB_CTL_LAN0_UP);
break;
case 1:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN1_UP, NGBE_MIS_PRB_CTL_LAN1_UP);
break;
case 2:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN2_UP, NGBE_MIS_PRB_CTL_LAN2_UP);
break;
case 3:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN3_UP, NGBE_MIS_PRB_CTL_LAN3_UP);
break;
}
NGBE_WRITE_REG_MASK(hw, NGBE_CFG_PORT_CTL, NGBE_CFG_PORT_CTL_PFRSTD,
NGBE_CFG_PORT_CTL_PFRSTD);
ifp->if_flags |= IFF_RUNNING;
for (i = 0; i < sc->sc_nqueues; i++)
ifq_clr_oactive(ifp->if_ifqs[i]);
splx(s);
}
int
ngbe_ioctl(struct ifnet * ifp, u_long cmd, caddr_t data)
{
struct ngbe_softc *sc = ifp->if_softc;
struct ifreq *ifr = (struct ifreq *)data;
int s, error = 0;
s = splnet();
switch (cmd) {
case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
if (!(ifp->if_flags & IFF_RUNNING))
ngbe_init(sc);
break;
case SIOCSIFFLAGS:
if (ifp->if_flags & IFF_UP) {
if (ifp->if_flags & IFF_RUNNING)
error = ENETRESET;
else
ngbe_init(sc);
} else {
if (ifp->if_flags & IFF_RUNNING)
ngbe_stop(sc);
}
break;
case SIOCSIFMEDIA:
case SIOCGIFMEDIA:
error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
break;
case SIOCGIFRXR:
error = ngbe_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_RUNNING) {
ngbe_disable_intr(sc);
ngbe_iff(sc);
ngbe_enable_intr(sc);
}
error = 0;
}
splx(s);
return error;
}
int
ngbe_media_change(struct ifnet *ifp)
{
struct ngbe_softc *sc = ifp->if_softc;
struct ngbe_hw *hw = &sc->hw;
struct ifmedia *ifm = &sc->sc_media;
uint32_t advertised = 0;
if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
return EINVAL;
switch (IFM_SUBTYPE(ifm->ifm_media)) {
case IFM_AUTO:
case IFM_1000_T:
advertised |= NGBE_LINK_SPEED_AUTONEG;
break;
case IFM_100_TX:
advertised |= NGBE_LINK_SPEED_100_FULL;
break;
case IFM_10_T:
advertised |= NGBE_LINK_SPEED_10_FULL;
break;
default:
return EINVAL;
}
hw->mac.autotry_restart = true;
hw->mac.ops.setup_link(sc, advertised, 1);
return 0;
}
void
ngbe_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
{
struct ngbe_softc *sc = ifp->if_softc;
ifmr->ifm_status = IFM_AVALID;
ifmr->ifm_active = IFM_ETHER;
ngbe_update_link_status(sc);
if (!LINK_STATE_IS_UP(ifp->if_link_state))
return;
ifmr->ifm_status |= IFM_ACTIVE;
switch (sc->link_speed) {
case NGBE_LINK_SPEED_1GB_FULL:
ifmr->ifm_active |= IFM_1000_T | IFM_FDX;
break;
case NGBE_LINK_SPEED_100_FULL:
ifmr->ifm_active |= IFM_100_TX | IFM_FDX;
break;
case NGBE_LINK_SPEED_10_FULL:
ifmr->ifm_active |= IFM_10_T | IFM_FDX;
break;
}
switch (sc->hw.fc.current_mode) {
case ngbe_fc_tx_pause:
ifmr->ifm_active |= IFM_FLOW | IFM_ETH_TXPAUSE;
break;
case ngbe_fc_rx_pause:
ifmr->ifm_active |= IFM_FLOW | IFM_ETH_RXPAUSE;
break;
case ngbe_fc_full:
ifmr->ifm_active |= IFM_FLOW | IFM_ETH_RXPAUSE |
IFM_ETH_TXPAUSE;
break;
default:
ifmr->ifm_active &= ~(IFM_FLOW | IFM_ETH_RXPAUSE |
IFM_ETH_TXPAUSE);
break;
}
}
int
ngbe_rxfill(struct rx_ring *rxr)
{
struct ngbe_softc *sc = rxr->sc;
int i, post = 0;
u_int slots;
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map, 0,
rxr->rxdma.dma_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
i = rxr->last_desc_filled;
for (slots = if_rxr_get(&rxr->rx_ring, sc->num_rx_desc); slots > 0;
slots--) {
if (++i == sc->num_rx_desc)
i = 0;
if (ngbe_get_buf(rxr, i) != 0)
break;
rxr->last_desc_filled = i;
post = 1;
}
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map, 0,
rxr->rxdma.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
if_rxr_put(&rxr->rx_ring, slots);
return post;
}
int
ngbe_rxrinfo(struct ngbe_softc *sc, struct if_rxrinfo *ifri)
{
struct if_rxring_info *ifr;
struct rx_ring *rxr;
int error, i, n = 0;
if ((ifr = mallocarray(sc->sc_nqueues, sizeof(*ifr), M_DEVBUF,
M_WAITOK | M_CANFAIL | M_ZERO)) == NULL)
return ENOMEM;
for (i = 0; i < sc->sc_nqueues; i++) {
rxr = &sc->rx_rings[i];
ifr[n].ifr_size = MCLBYTES;
snprintf(ifr[n].ifr_name, sizeof(ifr[n].ifr_name), "%d", i);
ifr[n].ifr_info = rxr->rx_ring;
n++;
}
error = if_rxr_info_ioctl(ifri, sc->sc_nqueues, ifr);
free(ifr, M_DEVBUF, sc->sc_nqueues * sizeof(*ifr));
return error;
}
void
ngbe_start(struct ifqueue *ifq)
{
struct ifnet *ifp = ifq->ifq_if;
struct ngbe_softc *sc = ifp->if_softc;
struct tx_ring *txr = ifq->ifq_softc;
struct mbuf *m;
unsigned int prod, free, used;
int post = 0;
if (!sc->link_up)
return;
prod = txr->next_avail_desc;
free = txr->next_to_clean;
if (free <= prod)
free += sc->num_tx_desc;
free -= prod;
bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map, 0,
txr->txdma.dma_map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
for (;;) {
if (free <= NGBE_MAX_SCATTER + 2) {
ifq_set_oactive(ifq);
break;
}
m = ifq_dequeue(ifq);
if (m == NULL)
break;
used = ngbe_encap(txr, m);
if (used == 0) {
m_freem(m);
continue;
}
free -= used;
#if NBPFILTER > 0
if (ifp->if_bpf)
bpf_mtap_ether(ifp->if_bpf, m, BPF_DIRECTION_OUT);
#endif
txr->watchdog_timer = NGBE_TX_TIMEOUT;
ifp->if_timer = NGBE_TX_TIMEOUT;
post = 1;
}
bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map, 0,
txr->txdma.dma_map->dm_mapsize, BUS_DMASYNC_PREWRITE);
if (post)
NGBE_WRITE_REG(&sc->hw, NGBE_PX_TR_WP(txr->me),
txr->next_avail_desc);
}
void
ngbe_stop(struct ngbe_softc *sc)
{
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct ngbe_hw *hw = &sc->hw;
uint32_t rxdctl;
int i, wait_loop = NGBE_MAX_RX_DESC_POLL;
ifp->if_flags &= ~IFF_RUNNING;
ifp->if_timer = 0;
ngbe_disable_pcie_master(sc);
hw->mac.ops.disable_rx(hw);
for (i = 0; i < sc->sc_nqueues; i++) {
NGBE_WRITE_REG_MASK(hw, NGBE_PX_RR_CFG(i),
NGBE_PX_RR_CFG_RR_EN, 0);
do {
DELAY(10);
rxdctl = NGBE_READ_REG(hw, NGBE_PX_RR_CFG(i));
} while (--wait_loop && (rxdctl & NGBE_PX_RR_CFG_RR_EN));
if (!wait_loop) {
printf("%s: Rx queue %d not cleared within "
"the polling period\n", DEVNAME(sc), i);
return;
}
}
ngbe_disable_intr(sc);
switch (hw->bus.lan_id) {
case 0:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN0_UP, 0);
break;
case 1:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN1_UP, 0);
break;
case 2:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN2_UP, 0);
break;
case 3:
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_PRB_CTL,
NGBE_MIS_PRB_CTL_LAN3_UP, 0);
break;
}
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_TX_CFG, NGBE_MAC_TX_CFG_TE, 0);
for (i = 0; i < sc->sc_nqueues; i++)
NGBE_WRITE_REG(hw, NGBE_PX_TR_CFG(i), NGBE_PX_TR_CFG_SWFLSH);
NGBE_WRITE_REG_MASK(hw, NGBE_TDM_CTL, NGBE_TDM_CTL_TE, 0);
ngbe_reset(sc);
hw->mac.ops.set_rar(sc, 0, hw->mac.addr, 0, NGBE_PSR_MAC_SWC_AD_H_AV);
intr_barrier(sc->tag);
for (i = 0; i < sc->sc_nqueues; i++) {
struct ifqueue *ifq = ifp->if_ifqs[i];
ifq_barrier(ifq);
ifq_clr_oactive(ifq);
if (sc->queues[i].tag != NULL)
intr_barrier(sc->queues[i].tag);
timeout_del(&sc->rx_rings[i].rx_refill);
}
ngbe_free_transmit_structures(sc);
ngbe_free_receive_structures(sc);
ngbe_update_link_status(sc);
}
void
ngbe_update_link_status(struct ngbe_softc *sc)
{
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct ngbe_hw *hw = &sc->hw;
uint32_t reg, speed = 0;
int link_state = LINK_STATE_DOWN;
hw->mac.ops.check_link(hw, &sc->link_speed, &sc->link_up, 0);
ifp->if_baudrate = 0;
if (sc->link_up) {
link_state = LINK_STATE_FULL_DUPLEX;
switch (sc->link_speed) {
case NGBE_LINK_SPEED_UNKNOWN:
ifp->if_baudrate = 0;
break;
case NGBE_LINK_SPEED_1GB_FULL:
ifp->if_baudrate = IF_Gbps(1);
speed = 2;
break;
case NGBE_LINK_SPEED_100_FULL:
ifp->if_baudrate = IF_Mbps(100);
speed = 1;
break;
case NGBE_LINK_SPEED_10_FULL:
ifp->if_baudrate = IF_Mbps(10);
break;
}
NGBE_WRITE_REG_MASK(hw, NGBE_CFG_LAN_SPEED, 0x3, speed);
hw->mac.ops.fc_enable(sc);
ngbe_set_rx_drop_en(sc);
if (sc->link_speed & (NGBE_LINK_SPEED_1GB_FULL |
NGBE_LINK_SPEED_100_FULL | NGBE_LINK_SPEED_10_FULL)) {
NGBE_WRITE_REG(hw, NGBE_MAC_TX_CFG,
(NGBE_READ_REG(hw, NGBE_MAC_TX_CFG) &
~NGBE_MAC_TX_CFG_SPEED_MASK) | NGBE_MAC_TX_CFG_TE |
NGBE_MAC_TX_CFG_SPEED_1G);
}
reg = NGBE_READ_REG(hw, NGBE_MAC_RX_CFG);
NGBE_WRITE_REG(hw, NGBE_MAC_RX_CFG, reg);
NGBE_WRITE_REG(hw, NGBE_MAC_PKT_FLT, NGBE_MAC_PKT_FLT_PR);
reg = NGBE_READ_REG(hw, NGBE_MAC_WDG_TIMEOUT);
NGBE_WRITE_REG(hw, NGBE_MAC_WDG_TIMEOUT, reg);
}
if (ifp->if_link_state != link_state) {
ifp->if_link_state = link_state;
if_link_state_change(ifp);
}
}
void
ngbe_watchdog(struct ifnet *ifp)
{
struct ngbe_softc *sc = ifp->if_softc;
struct tx_ring *txr = sc->tx_rings;
int i, tx_hang = 0;
for (i = 0; i < sc->sc_nqueues; i++, txr++) {
if (txr->watchdog_timer == 0 || --txr->watchdog_timer)
continue;
else {
tx_hang = 1;
break;
}
}
if (!tx_hang)
return;
printf("%s: watchdog timeout\n", DEVNAME(sc));
ifp->if_oerrors++;
ifp->if_flags &= ~IFF_RUNNING;
ngbe_init(sc);
}
int
ngbe_allocate_pci_resources(struct ngbe_softc *sc)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
pcireg_t memtype;
memtype = PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_64BIT;
if (pci_mapreg_map(pa, NGBE_PCIREG, memtype, 0, &os->os_memt,
&os->os_memh, &os->os_membase, &os->os_memsize, 0)) {
printf(": unable to map registers\n");
return ENXIO;
}
sc->hw.back = os;
if (ngbe_setup_msix(sc))
return EINVAL;
return 0;
}
void
ngbe_free_pci_resources(struct ngbe_softc *sc)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
if (sc->tag)
pci_intr_disestablish(pa->pa_pc, sc->tag);
sc->tag = NULL;
if (os->os_membase)
bus_space_unmap(os->os_memt, os->os_memh, os->os_memsize);
os->os_membase = 0;
}
int
ngbe_allocate_msix(struct ngbe_softc *sc)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
struct ngbe_queue *nq;
pci_intr_handle_t ih;
int i, error = 0;
for (i = 0, nq = sc->queues; i < sc->sc_nqueues; i++, nq++) {
if (pci_intr_map_msix(pa, i, &ih)) {
printf(": unable to map msi-x vector %d", i);
error = ENXIO;
goto fail;
}
nq->tag = pci_intr_establish_cpu(pa->pa_pc, ih,
IPL_NET | IPL_MPSAFE, intrmap_cpu(sc->sc_intrmap, i),
ngbe_intr_queue, nq, nq->name);
if (nq->tag == NULL) {
printf(": unable to establish interrupt %d\n", i);
error = ENXIO;
goto fail;
}
nq->msix = i;
}
if (pci_intr_map_msix(pa, i, &ih)) {
printf(": unable to map link vector\n");
error = ENXIO;
goto fail;
}
sc->tag = pci_intr_establish(pa->pa_pc, ih, IPL_NET | IPL_MPSAFE,
ngbe_intr_link, sc, sc->sc_dev.dv_xname);
if (sc->tag == NULL) {
printf(": unable to establish link interrupt\n");
error = ENXIO;
goto fail;
}
sc->linkvec = i;
printf(", %s, %d queue%s", pci_intr_string(pa->pa_pc, ih), i,
(i > 1) ? "s" : "");
return 0;
fail:
for (nq = sc->queues; i > 0; i--, nq++) {
if (nq->tag == NULL)
continue;
pci_intr_disestablish(pa->pa_pc, nq->tag);
nq->tag = NULL;
}
return error;
}
void
ngbe_setup_interface(struct ngbe_softc *sc)
{
struct ifnet *ifp = &sc->sc_ac.ac_if;
int i;
strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_xflags = IFXF_MPSAFE;
ifp->if_ioctl = ngbe_ioctl;
ifp->if_qstart = ngbe_start;
ifp->if_watchdog = ngbe_watchdog;
ifp->if_hardmtu = NGBE_MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN -
ETHER_CRC_LEN;
ifq_init_maxlen(&ifp->if_snd, sc->num_tx_desc - 1);
ifp->if_capabilities = IFCAP_VLAN_MTU;
#if NVLAN > 0
ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING;
#endif
ifmedia_init(&sc->sc_media, IFM_IMASK, ngbe_media_change,
ngbe_media_status);
ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL);
ifmedia_add(&sc->sc_media, IFM_ETHER | IFM_AUTO, 0, NULL);
ifmedia_set(&sc->sc_media, IFM_ETHER | IFM_AUTO);
sc->sc_media.ifm_media = sc->sc_media.ifm_cur->ifm_media;
if_attach(ifp);
ether_ifattach(ifp);
if_attach_queues(ifp, sc->sc_nqueues);
if_attach_iqueues(ifp, sc->sc_nqueues);
for (i = 0; i < sc->sc_nqueues; i++) {
struct ifqueue *ifq = ifp->if_ifqs[i];
struct ifiqueue *ifiq = ifp->if_iqs[i];
struct tx_ring *txr = &sc->tx_rings[i];
struct rx_ring *rxr = &sc->rx_rings[i];
ifq->ifq_softc = txr;
txr->ifq = ifq;
ifiq->ifiq_softc = rxr;
rxr->ifiq = ifiq;
}
}
int
ngbe_setup_msix(struct ngbe_softc *sc)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
int nmsix;
nmsix = pci_intr_msix_count(pa);
if (nmsix <= 1) {
printf(": not enough msi-x vectors\n");
return EINVAL;
}
nmsix--;
sc->sc_intrmap = intrmap_create(&sc->sc_dev, nmsix,
MIN(NGBE_MAX_VECTORS, IF_MAX_VECTORS), INTRMAP_POWEROF2);
sc->sc_nqueues = intrmap_count(sc->sc_intrmap);
return 0;
}
int
ngbe_dma_malloc(struct ngbe_softc *sc, bus_size_t size,
struct ngbe_dma_alloc *dma)
{
struct ngbe_osdep *os = &sc->osdep;
dma->dma_tag = os->os_pa.pa_dmat;
if (bus_dmamap_create(dma->dma_tag, size, 1, size, 0, BUS_DMA_NOWAIT,
&dma->dma_map))
return 1;
if (bus_dmamem_alloc(dma->dma_tag, size, PAGE_SIZE, 0, &dma->dma_seg,
1, &dma->dma_nseg, BUS_DMA_NOWAIT))
goto destroy;
if (bus_dmamem_map(dma->dma_tag, &dma->dma_seg, dma->dma_nseg, size,
&dma->dma_vaddr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT))
goto free;
if (bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, size,
NULL, BUS_DMA_NOWAIT))
goto unmap;
dma->dma_size = size;
return 0;
unmap:
bus_dmamem_unmap(dma->dma_tag, dma->dma_vaddr, size);
free:
bus_dmamem_free(dma->dma_tag, &dma->dma_seg, dma->dma_nseg);
destroy:
bus_dmamap_destroy(dma->dma_tag, dma->dma_map);
dma->dma_map = NULL;
dma->dma_tag = NULL;
return 1;
}
void
ngbe_dma_free(struct ngbe_softc *sc, struct ngbe_dma_alloc *dma)
{
if (dma->dma_tag == NULL)
return;
if (dma->dma_map != NULL) {
bus_dmamap_sync(dma->dma_tag, dma->dma_map, 0,
dma->dma_map->dm_mapsize,
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(dma->dma_tag, dma->dma_map);
bus_dmamem_unmap(dma->dma_tag, dma->dma_vaddr, dma->dma_size);
bus_dmamem_free(dma->dma_tag, &dma->dma_seg, dma->dma_nseg);
bus_dmamap_destroy(dma->dma_tag, dma->dma_map);
dma->dma_map = NULL;
}
}
int
ngbe_allocate_isb(struct ngbe_softc *sc)
{
int isize;
isize = sizeof(uint32_t) * NGBE_ISB_MAX;
if (ngbe_dma_malloc(sc, isize, &sc->isbdma)) {
printf("%s: unable to allocate interrupt status resources\n",
DEVNAME(sc));
return ENOMEM;
}
sc->isb_base = (uint32_t *)sc->isbdma.dma_vaddr;
bzero((void *)sc->isb_base, isize);
return 0;
}
void
ngbe_free_isb(struct ngbe_softc *sc)
{
ngbe_dma_free(sc, &sc->isbdma);
}
int
ngbe_allocate_queues(struct ngbe_softc *sc)
{
struct ngbe_queue *nq;
struct tx_ring *txr;
struct rx_ring *rxr;
int i, rsize, rxconf, tsize, txconf;
sc->queues = mallocarray(sc->sc_nqueues, sizeof(struct ngbe_queue),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->queues == NULL) {
printf("%s: unable to allocate queue\n", DEVNAME(sc));
goto fail;
}
sc->tx_rings = mallocarray(sc->sc_nqueues, sizeof(struct tx_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->tx_rings == NULL) {
printf("%s: unable to allocate Tx ring\n", DEVNAME(sc));
goto fail;
}
sc->rx_rings = mallocarray(sc->sc_nqueues, sizeof(struct rx_ring),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (sc->rx_rings == NULL) {
printf("%s: unable to allocate Rx ring\n", DEVNAME(sc));
goto rx_fail;
}
txconf = rxconf = 0;
tsize = roundup2(sc->num_tx_desc * sizeof(union ngbe_tx_desc),
PAGE_SIZE);
for (i = 0; i < sc->sc_nqueues; i++, txconf++) {
txr = &sc->tx_rings[i];
txr->sc = sc;
txr->me = i;
if (ngbe_dma_malloc(sc, tsize, &txr->txdma)) {
printf("%s: unable to allocate Tx descriptor\n",
DEVNAME(sc));
goto err_tx_desc;
}
txr->tx_base = (union ngbe_tx_desc *)txr->txdma.dma_vaddr;
bzero((void *)txr->tx_base, tsize);
}
rsize = roundup2(sc->num_rx_desc * sizeof(union ngbe_rx_desc),
PAGE_SIZE);
for (i = 0; i < sc->sc_nqueues; i++, rxconf++) {
rxr = &sc->rx_rings[i];
rxr->sc = sc;
rxr->me = i;
timeout_set(&rxr->rx_refill, ngbe_rxrefill, rxr);
if (ngbe_dma_malloc(sc, rsize, &rxr->rxdma)) {
printf("%s: unable to allocate Rx descriptor\n",
DEVNAME(sc));
goto err_rx_desc;
}
rxr->rx_base = (union ngbe_rx_desc *)rxr->rxdma.dma_vaddr;
bzero((void *)rxr->rx_base, rsize);
}
for (i = 0; i < sc->sc_nqueues; i++) {
nq = &sc->queues[i];
nq->sc = sc;
nq->txr = &sc->tx_rings[i];
nq->rxr = &sc->rx_rings[i];
snprintf(nq->name, sizeof(nq->name), "%s:%d", DEVNAME(sc), i);
}
return 0;
err_rx_desc:
for (rxr = sc->rx_rings; rxconf > 0; rxr++, rxconf--)
ngbe_dma_free(sc, &rxr->rxdma);
err_tx_desc:
for (txr = sc->tx_rings; txconf > 0; txr++, txconf--)
ngbe_dma_free(sc, &txr->txdma);
free(sc->rx_rings, M_DEVBUF, sc->sc_nqueues * sizeof(struct rx_ring));
sc->rx_rings = NULL;
rx_fail:
free(sc->tx_rings, M_DEVBUF, sc->sc_nqueues * sizeof(struct tx_ring));
sc->tx_rings = NULL;
fail:
return ENOMEM;
}
void
ngbe_free_receive_structures(struct ngbe_softc *sc)
{
struct rx_ring *rxr;
int i;
for (i = 0, rxr = sc->rx_rings; i < sc->sc_nqueues; i++, rxr++)
if_rxr_init(&rxr->rx_ring, 0, 0);
for (i = 0, rxr = sc->rx_rings; i < sc->sc_nqueues; i++, rxr++)
ngbe_free_receive_buffers(rxr);
}
void
ngbe_free_receive_buffers(struct rx_ring *rxr)
{
struct ngbe_softc *sc;
struct ngbe_rx_buf *rxbuf;
int i;
sc = rxr->sc;
if (rxr->rx_buffers != NULL) {
for (i = 0; i < sc->num_rx_desc; i++) {
rxbuf = &rxr->rx_buffers[i];
if (rxbuf->buf != NULL) {
bus_dmamap_sync(rxr->rxdma.dma_tag, rxbuf->map,
0, rxbuf->map->dm_mapsize,
BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(rxr->rxdma.dma_tag,
rxbuf->map);
m_freem(rxbuf->buf);
rxbuf->buf = NULL;
}
bus_dmamap_destroy(rxr->rxdma.dma_tag, rxbuf->map);
rxbuf->map = NULL;
}
free(rxr->rx_buffers, M_DEVBUF,
sc->num_rx_desc * sizeof(struct ngbe_rx_buf));
rxr->rx_buffers = NULL;
}
}
void
ngbe_free_transmit_structures(struct ngbe_softc *sc)
{
struct tx_ring *txr = sc->tx_rings;
int i;
for (i = 0; i < sc->sc_nqueues; i++, txr++)
ngbe_free_transmit_buffers(txr);
}
void
ngbe_free_transmit_buffers(struct tx_ring *txr)
{
struct ngbe_softc *sc = txr->sc;
struct ngbe_tx_buf *tx_buffer;
int i;
if (txr->tx_buffers == NULL)
return;
tx_buffer = txr->tx_buffers;
for (i = 0; i < sc->num_tx_desc; i++, tx_buffer++) {
if (tx_buffer->map != NULL && tx_buffer->map->dm_nsegs > 0) {
bus_dmamap_sync(txr->txdma.dma_tag, tx_buffer->map,
0, tx_buffer->map->dm_mapsize,
BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(txr->txdma.dma_tag, tx_buffer->map);
}
if (tx_buffer->m_head != NULL) {
m_freem(tx_buffer->m_head);
tx_buffer->m_head = NULL;
}
if (tx_buffer->map != NULL) {
bus_dmamap_destroy(txr->txdma.dma_tag, tx_buffer->map);
tx_buffer->map = NULL;
}
}
if (txr->tx_buffers != NULL)
free(txr->tx_buffers, M_DEVBUF,
sc->num_tx_desc * sizeof(struct ngbe_tx_buf));
txr->tx_buffers = NULL;
txr->txtag = NULL;
}
int
ngbe_allocate_receive_buffers(struct rx_ring *rxr)
{
struct ngbe_softc *sc = rxr->sc;
struct ngbe_rx_buf *rxbuf;
int i, error;
rxr->rx_buffers = mallocarray(sc->num_rx_desc,
sizeof(struct ngbe_rx_buf), M_DEVBUF, M_NOWAIT | M_ZERO);
if (rxr->rx_buffers == NULL) {
printf("%s: unable to allocate rx_buffer memory\n",
DEVNAME(sc));
error = ENOMEM;
goto fail;
}
rxbuf = rxr->rx_buffers;
for (i = 0; i < sc->num_rx_desc; i++, rxbuf++) {
error = bus_dmamap_create(rxr->rxdma.dma_tag,
NGBE_MAX_JUMBO_FRAME_SIZE, 1, NGBE_MAX_JUMBO_FRAME_SIZE, 0,
BUS_DMA_NOWAIT, &rxbuf->map);
if (error) {
printf("%s: unable to create RX DMA map\n",
DEVNAME(sc));
goto fail;
}
}
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map, 0,
rxr->rxdma.dma_map->dm_mapsize,
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
return 0;
fail:
return error;
}
int
ngbe_allocate_transmit_buffers(struct tx_ring *txr)
{
struct ngbe_softc *sc = txr->sc;
struct ngbe_tx_buf *txbuf;
int error, i;
txr->tx_buffers = mallocarray(sc->num_tx_desc,
sizeof(struct ngbe_tx_buf), M_DEVBUF, M_NOWAIT | M_ZERO);
if (txr->tx_buffers == NULL) {
printf("%s: unable to allocate tx_buffer memory\n",
DEVNAME(sc));
error = ENOMEM;
goto fail;
}
txr->txtag = txr->txdma.dma_tag;
for (i = 0; i < sc->num_tx_desc; i++) {
txbuf = &txr->tx_buffers[i];
error = bus_dmamap_create(txr->txdma.dma_tag, NGBE_TSO_SIZE,
NGBE_MAX_SCATTER, PAGE_SIZE, 0, BUS_DMA_NOWAIT,
&txbuf->map);
if (error != 0) {
printf("%s: unable to create TX DMA map\n",
DEVNAME(sc));
goto fail;
}
}
return 0;
fail:
return error;
}
int
ngbe_setup_receive_ring(struct rx_ring *rxr)
{
struct ngbe_softc *sc = rxr->sc;
struct ifnet *ifp = &sc->sc_ac.ac_if;
int rsize;
rsize = roundup2(sc->num_rx_desc * sizeof(union ngbe_rx_desc),
PAGE_SIZE);
bzero((void *)rxr->rx_base, rsize);
if (ngbe_allocate_receive_buffers(rxr))
return ENOMEM;
rxr->next_to_check = 0;
rxr->last_desc_filled = sc->num_rx_desc - 1;
if_rxr_init(&rxr->rx_ring, 2 * ((ifp->if_hardmtu / MCLBYTES) + 1),
sc->num_rx_desc - 1);
ngbe_rxfill(rxr);
if (if_rxr_inuse(&rxr->rx_ring) == 0) {
printf("%s: unable to fill any rx descriptors\n", DEVNAME(sc));
return ENOBUFS;
}
return 0;
}
int
ngbe_setup_transmit_ring(struct tx_ring *txr)
{
struct ngbe_softc *sc = txr->sc;
if (ngbe_allocate_transmit_buffers(txr))
return ENOMEM;
bzero((void *)txr->tx_base,
(sizeof(union ngbe_tx_desc)) * sc->num_tx_desc);
txr->next_avail_desc = 0;
txr->next_to_clean = 0;
bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map, 0,
txr->txdma.dma_map->dm_mapsize,
BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
return 0;
}
int
ngbe_setup_receive_structures(struct ngbe_softc *sc)
{
struct rx_ring *rxr = sc->rx_rings;
int i;
for (i = 0; i < sc->sc_nqueues; i++, rxr++) {
if (ngbe_setup_receive_ring(rxr))
goto fail;
}
return 0;
fail:
ngbe_free_receive_structures(sc);
return ENOBUFS;
}
int
ngbe_setup_transmit_structures(struct ngbe_softc *sc)
{
struct tx_ring *txr = sc->tx_rings;
int i;
for (i = 0; i < sc->sc_nqueues; i++, txr++) {
if (ngbe_setup_transmit_ring(txr))
goto fail;
}
return 0;
fail:
ngbe_free_transmit_structures(sc);
return ENOBUFS;
}
uint8_t *
ngbe_addr_list_itr(struct ngbe_hw *hw, uint8_t **mc_addr_ptr, uint32_t *vmdq)
{
uint8_t *addr = *mc_addr_ptr;
uint8_t *newptr;
*vmdq = 0;
newptr = addr + ETHER_ADDR_LEN;
*mc_addr_ptr = newptr;
return addr;
}
void
ngbe_iff(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct arpcom *ac = &sc->sc_ac;
struct ether_multi *enm;
struct ether_multistep step;
uint32_t fctrl, vlanctrl;
uint8_t *mta, *update_ptr;
int mcnt = 0;
mta = sc->mta;
bzero(mta, sizeof(uint8_t) * ETHER_ADDR_LEN * NGBE_SP_RAR_ENTRIES);
fctrl = NGBE_READ_REG_MASK(hw, NGBE_PSR_CTL,
~(NGBE_PSR_CTL_UPE | NGBE_PSR_CTL_MPE));
vlanctrl = NGBE_READ_REG_MASK(hw, NGBE_PSR_VLAN_CTL,
~(NGBE_PSR_VLAN_CTL_VFE | NGBE_PSR_VLAN_CTL_CFIEN));
ifp->if_flags &= ~IFF_ALLMULTI;
fctrl |= NGBE_PSR_CTL_BAM | NGBE_PSR_CTL_MFE;
vlanctrl |= NGBE_PSR_VLAN_CTL_VFE;
hw->addr_ctrl.user_set_promisc = 0;
if (ifp->if_flags & IFF_PROMISC || ac->ac_multirangecnt > 0 ||
ac->ac_multicnt > NGBE_SP_RAR_ENTRIES) {
ifp->if_flags |= IFF_ALLMULTI;
fctrl |= NGBE_PSR_CTL_MPE;
if (ifp->if_flags & IFF_PROMISC) {
fctrl |= NGBE_PSR_CTL_UPE;
vlanctrl &= ~NGBE_PSR_VLAN_CTL_VFE;
}
} else {
ETHER_FIRST_MULTI(step, ac, enm);
while (enm != NULL) {
bcopy(enm->enm_addrlo, &mta[mcnt * ETHER_ADDR_LEN],
ETHER_ADDR_LEN);
mcnt++;
ETHER_NEXT_MULTI(step, enm);
}
update_ptr = mta;
hw->mac.ops.update_mc_addr_list(hw, update_ptr, mcnt,
ngbe_addr_list_itr, 1);
}
NGBE_WRITE_REG(hw, NGBE_PSR_VLAN_CTL, vlanctrl);
NGBE_WRITE_REG(hw, NGBE_PSR_CTL, fctrl);
}
int
ngbe_initialize_receive_unit(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
struct rx_ring *rxr = sc->rx_rings;
uint32_t bufsz, mhadd, rxctrl, rxdctl, srrctl;
int i, wait_loop = NGBE_MAX_RX_DESC_POLL;
int error = 0;
hw->mac.ops.disable_rx(hw);
ngbe_setup_psrtype(hw);
NGBE_WRITE_REG_MASK(hw, NGBE_RSEC_CTL, NGBE_RSEC_CTL_CRC_STRIP,
NGBE_RSEC_CTL_CRC_STRIP);
if (sc->sc_nqueues > 1) {
NGBE_WRITE_REG_MASK(hw, NGBE_PSR_CTL, NGBE_PSR_CTL_PCSD,
NGBE_PSR_CTL_PCSD);
ngbe_initialize_rss_mapping(sc);
}
mhadd = NGBE_READ_REG(hw, NGBE_PSR_MAX_SZ);
if (mhadd != NGBE_MAX_JUMBO_FRAME_SIZE)
NGBE_WRITE_REG(hw, NGBE_PSR_MAX_SZ, NGBE_MAX_JUMBO_FRAME_SIZE);
bufsz = MCLBYTES >> NGBE_PX_RR_CFG_BSIZEPKT_SHIFT;
for (i = 0; i < sc->sc_nqueues; i++, rxr++) {
uint64_t rdba = rxr->rxdma.dma_map->dm_segs[0].ds_addr;
NGBE_WRITE_REG_MASK(hw, NGBE_PX_RR_CFG(i),
NGBE_PX_RR_CFG_RR_EN, 0);
do {
DELAY(10);
rxdctl = NGBE_READ_REG(hw, NGBE_PX_RR_CFG(i));
} while (--wait_loop && (rxdctl & NGBE_PX_RR_CFG_RR_EN));
if (!wait_loop) {
printf("%s: Rx queue %d not cleared within "
"the polling period\n", DEVNAME(sc), i);
error = ETIMEDOUT;
goto out;
}
NGBE_WRITE_REG(hw, NGBE_PX_RR_BAL(i),
(rdba & 0x00000000ffffffffULL));
NGBE_WRITE_REG(hw, NGBE_PX_RR_BAH(i), (rdba >> 32));
rxdctl = NGBE_READ_REG(hw, NGBE_PX_RR_CFG(i));
rxdctl |=
(sc->num_rx_desc / 128) << NGBE_PX_RR_CFG_RR_SIZE_SHIFT;
rxdctl |= 0x1 << NGBE_PX_RR_CFG_RR_THER_SHIFT;
NGBE_WRITE_REG(hw, NGBE_PX_RR_CFG(i), rxdctl);
NGBE_WRITE_REG(hw, NGBE_PX_RR_RP(i), 0);
NGBE_WRITE_REG(hw, NGBE_PX_RR_WP(i), 0);
srrctl = NGBE_READ_REG_MASK(hw, NGBE_PX_RR_CFG(i),
~(NGBE_PX_RR_CFG_RR_HDR_SZ | NGBE_PX_RR_CFG_RR_BUF_SZ |
NGBE_PX_RR_CFG_SPLIT_MODE));
srrctl |= bufsz;
NGBE_WRITE_REG(hw, NGBE_PX_RR_CFG(i), srrctl);
NGBE_WRITE_REG_MASK(hw, NGBE_PX_RR_CFG(i),
NGBE_PX_RR_CFG_RR_EN, NGBE_PX_RR_CFG_RR_EN);
do {
msec_delay(1);
rxdctl = NGBE_READ_REG(hw, NGBE_PX_RR_CFG(i));
} while (--wait_loop && !(rxdctl & NGBE_PX_RR_CFG_RR_EN));
if (!wait_loop) {
printf("%s: Rx queue %d not set within "
"the polling period\n", DEVNAME(sc), i);
error = ETIMEDOUT;
goto out;
}
NGBE_WRITE_REG(hw, NGBE_PX_RR_WP(i), rxr->last_desc_filled);
}
rxctrl = NGBE_READ_REG(hw, NGBE_RDB_PB_CTL);
rxctrl |= NGBE_RDB_PB_CTL_PBEN;
hw->mac.ops.enable_rx_dma(hw, rxctrl);
out:
return error;
}
void
ngbe_initialize_rss_mapping(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t reta = 0, rss_field, rss_key[10];
int i, j, queue_id;
for (i = 0, j = 0; i < 128; i++, j++) {
if (j == sc->sc_nqueues)
j = 0;
queue_id = j;
reta = reta >> 8;
reta = reta | (((uint32_t)queue_id) << 24);
if ((i & 3) == 3) {
NGBE_WRITE_REG(hw, NGBE_RDB_RSSTBL(i >> 2), reta);
reta = 0;
}
}
stoeplitz_to_key(&rss_key, sizeof(rss_key));
for (i = 0; i < 10; i++)
NGBE_WRITE_REG(hw, NGBE_RDB_RSSRK(i), rss_key[i]);
rss_field = NGBE_RDB_RA_CTL_RSS_EN | NGBE_RDB_RA_CTL_RSS_IPV4 |
NGBE_RDB_RA_CTL_RSS_IPV4_TCP | NGBE_RDB_RA_CTL_RSS_IPV6 |
NGBE_RDB_RA_CTL_RSS_IPV6_TCP;
NGBE_WRITE_REG(hw, NGBE_RDB_RA_CTL, rss_field);
}
int
ngbe_initialize_transmit_unit(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct tx_ring *txr;
uint64_t tdba;
uint32_t txdctl;
int i, wait_loop = NGBE_MAX_RX_DESC_POLL;
int error = 0;
NGBE_WRITE_REG_MASK(hw, NGBE_TDM_CTL, NGBE_TDM_CTL_TE,
NGBE_TDM_CTL_TE);
for (i = 0; i < sc->sc_nqueues; i++) {
txr = &sc->tx_rings[i];
tdba = txr->txdma.dma_map->dm_segs[0].ds_addr;
NGBE_WRITE_REG(hw, NGBE_PX_TR_CFG(i), NGBE_PX_TR_CFG_SWFLSH);
NGBE_WRITE_FLUSH(hw);
NGBE_WRITE_REG(hw, NGBE_PX_TR_BAL(i),
(tdba & 0x00000000ffffffffULL));
NGBE_WRITE_REG(hw, NGBE_PX_TR_BAH(i), (tdba >> 32));
NGBE_WRITE_REG(hw, NGBE_PX_TR_RP(i), 0);
NGBE_WRITE_REG(hw, NGBE_PX_TR_WP(i), 0);
txr->watchdog_timer = 0;
txdctl = NGBE_PX_TR_CFG_ENABLE;
txdctl |= 4 << NGBE_PX_TR_CFG_TR_SIZE_SHIFT;
txdctl |= 0x20 << NGBE_PX_TR_CFG_WTHRESH_SHIFT;
NGBE_WRITE_REG(hw, NGBE_PX_TR_CFG(i), txdctl);
do {
msec_delay(1);
txdctl = NGBE_READ_REG(hw, NGBE_PX_TR_CFG(i));
} while (--wait_loop && !(txdctl & NGBE_PX_TR_CFG_ENABLE));
if (!wait_loop) {
printf("%s: Tx queue %d not set within "
"the polling period\n", DEVNAME(sc), i);
error = ETIMEDOUT;
goto out;
}
}
ifp->if_timer = 0;
NGBE_WRITE_REG_MASK(hw, NGBE_TSEC_BUF_AE, 0x3ff, 0x10);
NGBE_WRITE_REG_MASK(hw, NGBE_TSEC_CTL, 0x2, 0);
NGBE_WRITE_REG_MASK(hw, NGBE_TSEC_CTL, 0x1, 1);
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_TX_CFG, NGBE_MAC_TX_CFG_TE,
NGBE_MAC_TX_CFG_TE);
out:
return error;
}
int
ngbe_intr_link(void *arg)
{
struct ngbe_softc *sc = (struct ngbe_softc *)arg;
uint32_t eicr;
eicr = ngbe_misc_isb(sc, NGBE_ISB_MISC);
if (eicr & (NGBE_PX_MISC_IC_PHY | NGBE_PX_MISC_IC_GPIO)) {
KERNEL_LOCK();
ngbe_handle_phy_event(sc);
ngbe_update_link_status(sc);
KERNEL_UNLOCK();
}
ngbe_enable_queue(sc, sc->linkvec);
return 1;
}
int
ngbe_intr_queue(void *arg)
{
struct ngbe_queue *nq = arg;
struct ngbe_softc *sc = nq->sc;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct rx_ring *rxr = nq->rxr;
struct tx_ring *txr = nq->txr;
if (ISSET(ifp->if_flags, IFF_RUNNING)) {
ngbe_rxeof(rxr);
ngbe_txeof(txr);
ngbe_rxrefill(rxr);
}
ngbe_enable_queue(sc, nq->msix);
return 1;
}
void
ngbe_init_eeprom_params(struct ngbe_hw *hw)
{
struct ngbe_eeprom_info *eeprom = &hw->eeprom;
if (eeprom->type == ngbe_eeprom_uninitialized) {
eeprom->type = ngbe_eeprom_none;
if (!(NGBE_READ_REG(hw, NGBE_SPI_STATUS) &
NGBE_SPI_STATUS_FLASH_BYPASS))
eeprom->type = ngbe_flash;
}
eeprom->sw_region_offset = 0x80;
}
int
ngbe_init_hw(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int status;
status = hw->mac.ops.reset_hw(sc);
if (!status)
status = hw->mac.ops.start_hw(sc);
return status;
}
void
ngbe_init_ops(struct ngbe_hw *hw)
{
struct ngbe_mac_info *mac = &hw->mac;
struct ngbe_phy_info *phy = &hw->phy;
struct ngbe_eeprom_info *eeprom = &hw->eeprom;
phy->ops.reset = ngbe_phy_reset;
phy->ops.read_reg = ngbe_phy_read_reg;
phy->ops.write_reg = ngbe_phy_write_reg;
phy->ops.setup_link = ngbe_phy_setup_link;
phy->ops.phy_led_ctrl = ngbe_phy_led_ctrl;
phy->ops.check_overtemp = ngbe_phy_check_overtemp;
phy->ops.identify = ngbe_phy_identify;
phy->ops.init = ngbe_phy_init;
phy->ops.check_event = ngbe_phy_check_event;
phy->ops.get_adv_pause = ngbe_phy_get_advertised_pause;
phy->ops.get_lp_adv_pause = ngbe_phy_get_lp_advertised_pause;
phy->ops.set_adv_pause = ngbe_phy_set_pause_advertisement;
phy->ops.setup_once = ngbe_phy_setup;
mac->ops.init_hw = ngbe_init_hw;
mac->ops.clear_hw_cntrs = ngbe_clear_hw_cntrs;
mac->ops.get_mac_addr = ngbe_get_mac_addr;
mac->ops.stop_adapter = ngbe_stop_adapter;
mac->ops.get_bus_info = ngbe_get_bus_info;
mac->ops.set_lan_id = ngbe_set_lan_id_multi_port_pcie;
mac->ops.acquire_swfw_sync = ngbe_acquire_swfw_sync;
mac->ops.release_swfw_sync = ngbe_release_swfw_sync;
mac->ops.reset_hw = ngbe_reset_hw;
mac->ops.get_media_type = ngbe_get_media_type;
mac->ops.disable_sec_rx_path = ngbe_disable_sec_rx_path;
mac->ops.enable_sec_rx_path = ngbe_enable_sec_rx_path;
mac->ops.enable_rx_dma = ngbe_enable_rx_dma;
mac->ops.start_hw = ngbe_start_hw;
mac->ops.set_rar = ngbe_set_rar;
mac->ops.init_rx_addrs = ngbe_init_rx_addrs;
mac->ops.update_mc_addr_list = ngbe_update_mc_addr_list;
mac->ops.enable_rx = ngbe_enable_rx;
mac->ops.disable_rx = ngbe_disable_rx;
mac->ops.clear_vfta = ngbe_clear_vfta;
mac->ops.init_uta_tables = ngbe_init_uta_tables;
mac->ops.fc_enable = ngbe_fc_enable;
mac->ops.setup_fc = ngbe_setup_fc;
mac->ops.check_link = ngbe_check_mac_link;
mac->ops.setup_rxpba = ngbe_set_rxpba;
mac->mcft_size = NGBE_SP_MC_TBL_SIZE;
mac->vft_size = NGBE_SP_VFT_TBL_SIZE;
mac->num_rar_entries = NGBE_SP_RAR_ENTRIES;
mac->rx_pb_size = NGBE_SP_RX_PB_SIZE;
mac->max_rx_queues = NGBE_SP_MAX_RX_QUEUES;
mac->max_tx_queues = NGBE_SP_MAX_TX_QUEUES;
eeprom->ops.init_params = ngbe_init_eeprom_params;
eeprom->ops.eeprom_chksum_cap_st = ngbe_eepromcheck_cap;
eeprom->ops.phy_led_oem_chk = ngbe_phy_led_oem_chk;
mac->ops.set_fw_drv_ver = ngbe_set_fw_drv_ver;
mac->ops.init_thermal_sensor_thresh = ngbe_init_thermal_sensor_thresh;
}
void
ngbe_init_rx_addrs(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t rar_entries = hw->mac.num_rar_entries;
uint32_t i, psrctl;
if (ngbe_validate_mac_addr(hw->mac.addr)) {
hw->mac.ops.get_mac_addr(hw, hw->mac.addr);
}
hw->addr_ctrl.overflow_promisc = 0;
hw->addr_ctrl.rar_used_count = 1;
for (i = 1; i < rar_entries; i++) {
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_IDX, i);
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_AD_L, 0);
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_AD_H, 0);
}
hw->addr_ctrl.mta_in_use = 0;
psrctl = NGBE_READ_REG(hw, NGBE_PSR_CTL);
psrctl &= ~(NGBE_PSR_CTL_MO | NGBE_PSR_CTL_MFE);
psrctl |= hw->mac.mc_filter_type << NGBE_PSR_CTL_MO_SHIFT;
NGBE_WRITE_REG(hw, NGBE_PSR_CTL, psrctl);
for (i = 0; i < hw->mac.mcft_size; i++)
NGBE_WRITE_REG(hw, NGBE_PSR_MC_TBL(i), 0);
hw->mac.ops.init_uta_tables(hw);
}
void
ngbe_init_shared_code(struct ngbe_softc *sc)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
struct ngbe_hw *hw = &sc->hw;
hw->subsystem_device_id = PCI_PRODUCT(pci_conf_read(pa->pa_pc,
pa->pa_tag, PCI_SUBSYS_ID_REG));
hw->phy.type = ngbe_phy_internal;
NGBE_WRITE_REG(hw, NGBE_MDIO_CLAUSE_SELECT, 0xf);
ngbe_init_ops(hw);
hw->fc.requested_mode = ngbe_fc_full;
hw->fc.current_mode = ngbe_fc_full;
hw->fc.pause_time = NGBE_DEFAULT_FCPAUSE;
hw->fc.disable_fc_autoneg = 0;
}
void
ngbe_init_thermal_sensor_thresh(struct ngbe_hw *hw)
{
if (hw->bus.lan_id)
return;
NGBE_WRITE_REG(hw, NGBE_TS_INT_EN, NGBE_TS_INT_EN_DALARM_INT_EN |
NGBE_TS_INT_EN_ALARM_INT_EN);
NGBE_WRITE_REG(hw, NGBE_TS_EN, NGBE_TS_EN_ENA);
NGBE_WRITE_REG(hw, NGBE_TS_ALARM_THRE, 0x344);
NGBE_WRITE_REG(hw, NGBE_TS_DALARM_THRE, 0x330);
}
void
ngbe_init_uta_tables(struct ngbe_hw *hw)
{
int i;
for (i = 0; i < 128; i++)
NGBE_WRITE_REG(hw, NGBE_PSR_UC_TBL(i), 0);
}
void
ngbe_fc_autoneg(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t speed;
int link_up;
int error = EINVAL;
if (hw->fc.disable_fc_autoneg) {
printf("%s: flow control autoneg is disabled\n", DEVNAME(sc));
goto out;
}
hw->mac.ops.check_link(hw, &speed, &link_up, 0);
if (!link_up)
goto out;
switch (hw->phy.media_type) {
case ngbe_media_type_fiber:
break;
case ngbe_media_type_copper:
error = ngbe_fc_autoneg_copper(sc);
break;
default:
break;
}
out:
if (error) {
hw->fc.fc_was_autonegged = 0;
hw->fc.current_mode = hw->fc.requested_mode;
} else
hw->fc.fc_was_autonegged = 1;
}
int
ngbe_fc_autoneg_copper(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint8_t technology_ability_reg, lp_technology_ability_reg;
technology_ability_reg = lp_technology_ability_reg = 0;
if (!((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA)) {
hw->phy.ops.get_adv_pause(hw, &technology_ability_reg);
hw->phy.ops.get_lp_adv_pause(hw, &lp_technology_ability_reg);
}
return ngbe_negotiate_fc(sc, (uint32_t)technology_ability_reg,
(uint32_t)lp_technology_ability_reg, NGBE_TAF_SYM_PAUSE,
NGBE_TAF_ASM_PAUSE, NGBE_TAF_SYM_PAUSE, NGBE_TAF_ASM_PAUSE);
}
int
ngbe_fc_enable(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t mflcn, fccfg;
uint32_t fcrtl, fcrth;
uint32_t reg;
int error = 0;
if (!hw->fc.pause_time) {
error = EINVAL;
goto out;
}
if ((hw->fc.current_mode & ngbe_fc_tx_pause) && hw->fc.high_water) {
if (!hw->fc.low_water ||
hw->fc.low_water >= hw->fc.high_water) {
printf("%s: invalid water mark configuration\n",
DEVNAME(sc));
error = EINVAL;
goto out;
}
}
ngbe_fc_autoneg(sc);
mflcn = NGBE_READ_REG(hw, NGBE_MAC_RX_FLOW_CTRL);
mflcn &= ~NGBE_MAC_RX_FLOW_CTRL_RFE;
fccfg = NGBE_READ_REG(hw, NGBE_RDB_RFCC);
fccfg &= ~NGBE_RDB_RFCC_RFCE_802_3X;
switch (hw->fc.current_mode) {
case ngbe_fc_none:
break;
case ngbe_fc_rx_pause:
mflcn |= NGBE_MAC_RX_FLOW_CTRL_RFE;
break;
case ngbe_fc_tx_pause:
fccfg |= NGBE_RDB_RFCC_RFCE_802_3X;
break;
case ngbe_fc_full:
mflcn |= NGBE_MAC_RX_FLOW_CTRL_RFE;
fccfg |= NGBE_RDB_RFCC_RFCE_802_3X;
break;
default:
printf("%s: flow control param set incorrectly\n", DEVNAME(sc));
error = EINVAL;
goto out;
}
NGBE_WRITE_REG(hw, NGBE_MAC_RX_FLOW_CTRL, mflcn);
NGBE_WRITE_REG(hw, NGBE_RDB_RFCC, fccfg);
if ((hw->fc.current_mode & ngbe_fc_tx_pause) && hw->fc.high_water) {
fcrtl = (hw->fc.low_water << 10) | NGBE_RDB_RFCL_XONE;
NGBE_WRITE_REG(hw, NGBE_RDB_RFCL, fcrtl);
fcrth = (hw->fc.high_water << 10) | NGBE_RDB_RFCH_XOFFE;
} else {
NGBE_WRITE_REG(hw, NGBE_RDB_RFCL, 0);
fcrth = NGBE_READ_REG(hw, NGBE_RDB_PB_SZ) - 24576;
}
NGBE_WRITE_REG(hw, NGBE_RDB_RFCH, fcrth);
reg = hw->fc.pause_time * 0x00010000;
NGBE_WRITE_REG(hw, NGBE_RDB_RFCV, reg);
NGBE_WRITE_REG(hw, NGBE_RDB_RFCRT, hw->fc.pause_time / 2);
out:
return error;
}
int
ngbe_fmgr_cmd_op(struct ngbe_hw *hw, uint32_t cmd, uint32_t cmd_addr)
{
uint32_t val;
int timeout = 0;
val = (cmd << SPI_CLK_CMD_OFFSET) | cmd_addr |
(SPI_CLK_DIV << SPI_CLK_DIV_OFFSET);
NGBE_WRITE_REG(hw, NGBE_SPI_CMD, val);
for (;;) {
if (NGBE_READ_REG(hw, NGBE_SPI_STATUS) & 0x1)
break;
if (timeout == SPI_TIME_OUT_VALUE)
return ETIMEDOUT;
timeout++;
DELAY(10);
}
return 0;
}
uint32_t
ngbe_flash_read_dword(struct ngbe_hw *hw, uint32_t addr)
{
int status = ngbe_fmgr_cmd_op(hw, SPI_CMD_READ_DWORD, addr);
if (status)
return status;
return NGBE_READ_REG(hw, NGBE_SPI_DATA);
}
uint8_t
ngbe_calculate_checksum(uint8_t *buffer, uint32_t length)
{
uint32_t i;
uint8_t sum = 0;
if (!buffer)
return 0;
for (i = 0; i < length; i++)
sum += buffer[i];
return (uint8_t)(0 - sum);
}
int
ngbe_check_flash_load(struct ngbe_softc *sc, uint32_t check_bit)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t reg = 0;
int i, error = 0;
if (!(NGBE_READ_REG(hw, NGBE_SPI_STATUS) &
NGBE_SPI_STATUS_FLASH_BYPASS)) {
for (i = 0; i < NGBE_MAX_FLASH_LOAD_POLL_TIME; i++) {
reg = NGBE_READ_REG(hw, NGBE_SPI_ILDR_STATUS);
if (!(reg & check_bit))
break;
msec_delay(200);
}
if (i == NGBE_MAX_FLASH_LOAD_POLL_TIME) {
error = ETIMEDOUT;
printf("%s: hardware loading flash failed\n",
DEVNAME(sc));
}
}
return error;
}
int
ngbe_check_internal_phy_id(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t phy_id, phy_id_high, phy_id_low;
ngbe_gphy_wait_mdio_access_on(hw);
ngbe_phy_read_reg(hw, NGBE_MDI_PHY_ID1_OFFSET, 0, &phy_id_high);
phy_id = phy_id_high << 6;
ngbe_phy_read_reg(hw, NGBE_MDI_PHY_ID2_OFFSET, 0, &phy_id_low);
phy_id |= (phy_id_low & NGBE_MDI_PHY_ID_MASK) >> 10;
if (NGBE_INTERNAL_PHY_ID != phy_id) {
printf("%s: internal phy id 0x%x not supported\n",
DEVNAME(sc), phy_id);
return ENOTSUP;
} else
hw->phy.id = (uint32_t)phy_id;
return 0;
}
int
ngbe_check_mac_link(struct ngbe_hw *hw, uint32_t *speed, int *link_up,
int link_up_wait_to_complete)
{
uint32_t status = 0;
uint16_t speed_sta, value = 0;
int i;
if ((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA) {
*link_up = 1;
*speed = NGBE_LINK_SPEED_1GB_FULL;
return status;
}
if (link_up_wait_to_complete) {
for (i = 0; i < NGBE_LINK_UP_TIME; i++) {
status = hw->phy.ops.read_reg(hw,
NGBE_MDIO_AUTO_NEG_STATUS,
NGBE_INTERNAL_PHY_PAGE_OFFSET, &value);
if (!status && (value & 0x4)) {
*link_up = 1;
break;
} else
*link_up = 0;
msec_delay(100);
}
} else {
status = hw->phy.ops.read_reg(hw, NGBE_MDIO_AUTO_NEG_STATUS,
NGBE_INTERNAL_PHY_PAGE_OFFSET, &value);
if (!status && (value & 0x4))
*link_up = 1;
else
*link_up = 0;
}
speed_sta = value & 0x38;
if (*link_up) {
if (speed_sta == 0x28)
*speed = NGBE_LINK_SPEED_1GB_FULL;
else if (speed_sta == 0x18)
*speed = NGBE_LINK_SPEED_100_FULL;
else if (speed_sta == 0x8)
*speed = NGBE_LINK_SPEED_10_FULL;
} else
*speed = NGBE_LINK_SPEED_UNKNOWN;
return status;
}
int
ngbe_check_mng_access(struct ngbe_hw *hw)
{
if (!ngbe_mng_present(hw))
return 0;
return 1;
}
int
ngbe_check_reset_blocked(struct ngbe_softc *sc)
{
uint32_t mmngc;
mmngc = NGBE_READ_REG(&sc->hw, NGBE_MIS_ST);
if (mmngc & NGBE_MIS_ST_MNG_VETO) {
printf("%s: MNG_VETO bit detected\n", DEVNAME(sc));
return 1;
}
return 0;
}
void
ngbe_clear_hw_cntrs(struct ngbe_hw *hw)
{
uint16_t i;
NGBE_READ_REG(hw, NGBE_RX_CRC_ERROR_FRAMES_LOW);
NGBE_READ_REG(hw, NGBE_RX_LEN_ERROR_FRAMES_LOW);
NGBE_READ_REG(hw, NGBE_RDB_LXONTXC);
NGBE_READ_REG(hw, NGBE_RDB_LXOFFTXC);
NGBE_READ_REG(hw, NGBE_MAC_LXOFFRXC);
for (i = 0; i < 8; i++) {
NGBE_WRITE_REG_MASK(hw, NGBE_MMC_CONTROL, NGBE_MMC_CONTROL_UP,
i << 16);
NGBE_READ_REG(hw, NGBE_MAC_PXOFFRXC);
}
NGBE_READ_REG(hw, NGBE_PX_GPRC);
NGBE_READ_REG(hw, NGBE_PX_GPTC);
NGBE_READ_REG(hw, NGBE_PX_GORC_MSB);
NGBE_READ_REG(hw, NGBE_PX_GOTC_MSB);
NGBE_READ_REG(hw, NGBE_RX_BC_FRAMES_GOOD_LOW);
NGBE_READ_REG(hw, NGBE_RX_UNDERSIZE_FRAMES_GOOD);
NGBE_READ_REG(hw, NGBE_RX_OVERSIZE_FRAMES_GOOD);
NGBE_READ_REG(hw, NGBE_RX_FRAME_CNT_GOOD_BAD_LOW);
NGBE_READ_REG(hw, NGBE_TX_FRAME_CNT_GOOD_BAD_LOW);
NGBE_READ_REG(hw, NGBE_TX_MC_FRAMES_GOOD_LOW);
NGBE_READ_REG(hw, NGBE_TX_BC_FRAMES_GOOD_LOW);
NGBE_READ_REG(hw, NGBE_RDM_DRP_PKT);
}
void
ngbe_clear_vfta(struct ngbe_hw *hw)
{
uint32_t offset;
for (offset = 0; offset < hw->mac.vft_size; offset++) {
NGBE_WRITE_REG(hw, NGBE_PSR_VLAN_TBL(offset), 0);
hw->mac.vft_shadow[offset] = 0;
}
for (offset = 0; offset < NGBE_PSR_VLAN_SWC_ENTRIES; offset++) {
NGBE_WRITE_REG(hw, NGBE_PSR_VLAN_SWC_IDX, offset);
NGBE_WRITE_REG(hw, NGBE_PSR_VLAN_SWC, 0);
NGBE_WRITE_REG(hw, NGBE_PSR_VLAN_SWC_VM_L, 0);
}
}
void
ngbe_configure_ivars(struct ngbe_softc *sc)
{
struct ngbe_queue *nq = sc->queues;
uint32_t newitr;
int i;
NGBE_WRITE_REG(&sc->hw, NGBE_PX_ITRSEL, 0);
newitr = (4000000 / NGBE_MAX_INTS_PER_SEC) & NGBE_MAX_EITR;
newitr |= NGBE_PX_ITR_CNT_WDIS;
for (i = 0; i < sc->sc_nqueues; i++, nq++) {
ngbe_set_ivar(sc, i, nq->msix, 0);
ngbe_set_ivar(sc, i, nq->msix, 1);
NGBE_WRITE_REG(&sc->hw, NGBE_PX_ITR(nq->msix), newitr);
}
ngbe_set_ivar(sc, 0, sc->linkvec, -1);
NGBE_WRITE_REG(&sc->hw, NGBE_PX_ITR(sc->linkvec), 1950);
}
void
ngbe_configure_pb(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
hw->mac.ops.setup_rxpba(hw, 0, 0, PBA_STRATEGY_EQUAL);
ngbe_pbthresh_setup(sc);
}
void
ngbe_disable_intr(struct ngbe_softc *sc)
{
struct ngbe_queue *nq;
int i;
NGBE_WRITE_REG(&sc->hw, NGBE_PX_MISC_IEN, 0);
for (i = 0, nq = sc->queues; i < sc->sc_nqueues; i++, nq++)
ngbe_disable_queue(sc, nq->msix);
NGBE_WRITE_FLUSH(&sc->hw);
}
int
ngbe_disable_pcie_master(struct ngbe_softc *sc)
{
int i, error = 0;
if (!(NGBE_READ_REG(&sc->hw, NGBE_PX_TRANSACTION_PENDING)))
goto out;
for (i = 0; i < NGBE_PCI_MASTER_DISABLE_TIMEOUT; i++) {
DELAY(100);
if (!(NGBE_READ_REG(&sc->hw, NGBE_PX_TRANSACTION_PENDING)))
goto out;
}
printf("%s: PCIe transaction pending bit did not clear\n",
DEVNAME(sc));
error = ETIMEDOUT;
out:
return error;
}
void
ngbe_disable_queue(struct ngbe_softc *sc, uint32_t vector)
{
uint64_t queue = 1ULL << vector;
uint32_t mask;
mask = (queue & 0xffffffff);
if (mask)
NGBE_WRITE_REG(&sc->hw, NGBE_PX_IMS, mask);
}
void
ngbe_disable_rx(struct ngbe_hw *hw)
{
uint32_t rxctrl, psrctrl;
rxctrl = NGBE_READ_REG(hw, NGBE_RDB_PB_CTL);
if (rxctrl & NGBE_RDB_PB_CTL_PBEN) {
psrctrl = NGBE_READ_REG(hw, NGBE_PSR_CTL);
if (psrctrl & NGBE_PSR_CTL_SW_EN) {
psrctrl &= ~NGBE_PSR_CTL_SW_EN;
NGBE_WRITE_REG(hw, NGBE_PSR_CTL, psrctrl);
hw->mac.set_lben = 1;
} else
hw->mac.set_lben = 0;
rxctrl &= ~NGBE_RDB_PB_CTL_PBEN;
NGBE_WRITE_REG(hw, NGBE_RDB_PB_CTL, rxctrl);
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_RX_CFG, NGBE_MAC_RX_CFG_RE,
0);
}
}
void
ngbe_disable_sec_rx_path(struct ngbe_hw *hw)
{
uint32_t secrxreg;
int i;
NGBE_WRITE_REG_MASK(hw, NGBE_RSEC_CTL, NGBE_RSEC_CTL_RX_DIS,
NGBE_RSEC_CTL_RX_DIS);
for (i = 0; i < 40; i++) {
secrxreg = NGBE_READ_REG(hw, NGBE_RSEC_ST);
if (secrxreg & NGBE_RSEC_ST_RSEC_RDY)
break;
else
DELAY(1000);
}
}
int
ngbe_eepromcheck_cap(struct ngbe_softc *sc, uint16_t offset, uint32_t *data)
{
struct ngbe_hw *hw = &sc->hw;
struct ngbe_hic_read_shadow_ram buffer;
uint32_t tmp;
int status;
buffer.hdr.req.cmd = FW_EEPROM_CHECK_STATUS;
buffer.hdr.req.buf_lenh = 0;
buffer.hdr.req.buf_lenl = 0;
buffer.hdr.req.checksum = FW_DEFAULT_CHECKSUM;
buffer.address = 0;
buffer.length = 0;
status = ngbe_host_interface_command(sc, (uint32_t *)&buffer,
sizeof(buffer), NGBE_HI_COMMAND_TIMEOUT, 0);
if (status)
return status;
if (ngbe_check_mng_access(hw)) {
tmp = NGBE_READ_REG_ARRAY(hw, NGBE_MNG_MBOX, 1);
if (tmp == NGBE_CHECKSUM_CAP_ST_PASS)
status = 0;
else
status = EINVAL;
} else
status = EINVAL;
return status;
}
void
ngbe_enable_intr(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
struct ngbe_queue *nq;
uint32_t mask;
int i;
mask = NGBE_PX_MISC_IEN_MASK;
mask |= NGBE_PX_MISC_IEN_OVER_HEAT;
NGBE_WRITE_REG(hw, NGBE_GPIO_DDR, 0x1);
NGBE_WRITE_REG(hw, NGBE_GPIO_INTEN, 0x3);
NGBE_WRITE_REG(hw, NGBE_GPIO_INTTYPE_LEVEL, 0x0);
NGBE_WRITE_REG(hw, NGBE_GPIO_POLARITY, 0x3);
NGBE_WRITE_REG(hw, NGBE_PX_MISC_IEN, mask);
for (i = 0, nq = sc->queues; i < sc->sc_nqueues; i++, nq++)
ngbe_enable_queue(sc, nq->msix);
NGBE_WRITE_FLUSH(hw);
ngbe_enable_queue(sc, sc->linkvec);
}
void
ngbe_enable_queue(struct ngbe_softc *sc, uint32_t vector)
{
uint64_t queue = 1ULL << vector;
uint32_t mask;
mask = (queue & 0xffffffff);
if (mask)
NGBE_WRITE_REG(&sc->hw, NGBE_PX_IMC, mask);
}
void
ngbe_enable_rx(struct ngbe_hw *hw)
{
uint32_t val;
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_RX_CFG, NGBE_MAC_RX_CFG_RE,
NGBE_MAC_RX_CFG_RE);
NGBE_WRITE_REG_MASK(hw, NGBE_RSEC_CTL, 0x2, 0);
NGBE_WRITE_REG_MASK(hw, NGBE_RDB_PB_CTL, NGBE_RDB_PB_CTL_PBEN,
NGBE_RDB_PB_CTL_PBEN);
if (hw->mac.set_lben) {
val = NGBE_READ_REG(hw, NGBE_PSR_CTL);
val |= NGBE_PSR_CTL_SW_EN;
NGBE_WRITE_REG(hw, NGBE_PSR_CTL, val);
hw->mac.set_lben = 0;
}
}
void
ngbe_enable_rx_dma(struct ngbe_hw *hw, uint32_t reg)
{
hw->mac.ops.disable_sec_rx_path(hw);
if (reg & NGBE_RDB_PB_CTL_PBEN)
hw->mac.ops.enable_rx(hw);
else
hw->mac.ops.disable_rx(hw);
hw->mac.ops.enable_sec_rx_path(hw);
}
void
ngbe_enable_sec_rx_path(struct ngbe_hw *hw)
{
NGBE_WRITE_REG_MASK(hw, NGBE_RSEC_CTL, NGBE_RSEC_CTL_RX_DIS, 0);
NGBE_WRITE_FLUSH(hw);
}
int
ngbe_encap(struct tx_ring *txr, struct mbuf *m)
{
struct ngbe_softc *sc = txr->sc;
uint32_t olinfo_status = 0, cmd_type_len;
int i, j, ntxc;
int first, last = 0;
bus_dmamap_t map;
struct ngbe_tx_buf *txbuf;
union ngbe_tx_desc *txd = NULL;
cmd_type_len = NGBE_TXD_DTYP_DATA | NGBE_TXD_IFCS;
first = txr->next_avail_desc;
txbuf = &txr->tx_buffers[first];
map = txbuf->map;
ntxc = ngbe_tx_ctx_setup(txr, m, &cmd_type_len, &olinfo_status);
if (ntxc == -1)
goto fail;
switch (bus_dmamap_load_mbuf(txr->txdma.dma_tag, map, m,
BUS_DMA_NOWAIT)) {
case 0:
break;
case EFBIG:
if (m_defrag(m, M_NOWAIT) == 0 &&
bus_dmamap_load_mbuf(txr->txdma.dma_tag, map, m,
BUS_DMA_NOWAIT) == 0)
break;
default:
return 0;
}
i = txr->next_avail_desc + ntxc;
if (i >= sc->num_tx_desc)
i -= sc->num_tx_desc;
for (j = 0; j < map->dm_nsegs; j++) {
txd = &txr->tx_base[i];
txd->read.buffer_addr = htole64(map->dm_segs[j].ds_addr);
txd->read.cmd_type_len =
htole32(cmd_type_len | map->dm_segs[j].ds_len);
txd->read.olinfo_status = htole32(olinfo_status);
last = i;
if (++i == sc->num_tx_desc)
i = 0;
}
txd->read.cmd_type_len |= htole32(NGBE_TXD_EOP | NGBE_TXD_RS);
bus_dmamap_sync(txr->txdma.dma_tag, map, 0, map->dm_mapsize,
BUS_DMASYNC_PREWRITE);
txbuf->m_head = m;
txbuf->eop_index = last;
txr->next_avail_desc = i;
return ntxc + j;
fail:
bus_dmamap_unload(txr->txdma.dma_tag, txbuf->map);
return 0;
}
int
ngbe_get_buf(struct rx_ring *rxr, int i)
{
struct ngbe_softc *sc = rxr->sc;
struct ngbe_rx_buf *rxbuf;
struct mbuf *m;
union ngbe_rx_desc *rxdesc;
int error;
rxbuf = &rxr->rx_buffers[i];
rxdesc = &rxr->rx_base[i];
if (rxbuf->buf) {
printf("%s: slot %d already has an mbuf\n", DEVNAME(sc), i);
return ENOBUFS;
}
m = MCLGETL(NULL, M_DONTWAIT, MCLBYTES + ETHER_ALIGN);
if (!m)
return ENOBUFS;
m->m_data += (m->m_ext.ext_size - (MCLBYTES + ETHER_ALIGN));
m->m_len = m->m_pkthdr.len = MCLBYTES + ETHER_ALIGN;
error = bus_dmamap_load_mbuf(rxr->rxdma.dma_tag, rxbuf->map, m,
BUS_DMA_NOWAIT);
if (error) {
m_freem(m);
return error;
}
bus_dmamap_sync(rxr->rxdma.dma_tag, rxbuf->map, 0,
rxbuf->map->dm_mapsize, BUS_DMASYNC_PREREAD);
rxbuf->buf = m;
rxdesc->read.pkt_addr = htole64(rxbuf->map->dm_segs[0].ds_addr);
return 0;
}
void
ngbe_get_bus_info(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t link_status;
link_status = ngbe_read_pci_cfg_word(sc, NGBE_PCI_LINK_STATUS);
ngbe_set_pci_config_data(hw, link_status);
}
void
ngbe_get_copper_link_capabilities(struct ngbe_hw *hw, uint32_t *speed,
int *autoneg)
{
*speed = 0;
if (hw->mac.autoneg)
*autoneg = 1;
else
*autoneg = 0;
*speed = NGBE_LINK_SPEED_10_FULL | NGBE_LINK_SPEED_100_FULL |
NGBE_LINK_SPEED_1GB_FULL;
}
int
ngbe_get_eeprom_semaphore(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t swsm;
int i, timeout = 2000;
int status = ETIMEDOUT;
for (i = 0; i < timeout; i++) {
swsm = NGBE_READ_REG(hw, NGBE_MIS_SWSM);
if (!(swsm & NGBE_MIS_SWSM_SMBI)) {
status = 0;
break;
}
DELAY(50);
}
if (i == timeout) {
printf("%s: cannot access the eeprom - SMBI semaphore not "
"granted\n", DEVNAME(sc));
ngbe_release_eeprom_semaphore(hw);
DELAY(50);
swsm = NGBE_READ_REG(hw, NGBE_MIS_SWSM);
if (!(swsm & NGBE_MIS_SWSM_SMBI))
status = 0;
}
return status;
}
void
ngbe_get_hw_control(struct ngbe_hw *hw)
{
NGBE_WRITE_REG_MASK(hw, NGBE_CFG_PORT_CTL,
NGBE_CFG_PORT_CTL_DRV_LOAD, NGBE_CFG_PORT_CTL_DRV_LOAD);
}
void
ngbe_release_hw_control(struct ngbe_softc *sc)
{
NGBE_WRITE_REG_MASK(&sc->hw, NGBE_CFG_PORT_CTL,
NGBE_CFG_PORT_CTL_DRV_LOAD, 0);
}
void
ngbe_get_mac_addr(struct ngbe_hw *hw, uint8_t *mac_addr)
{
uint32_t rar_high, rar_low;
int i;
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_IDX, 0);
rar_high = NGBE_READ_REG(hw, NGBE_PSR_MAC_SWC_AD_H);
rar_low = NGBE_READ_REG(hw, NGBE_PSR_MAC_SWC_AD_L);
for (i = 0; i < 2; i++)
mac_addr[i] = (uint8_t)(rar_high >> (1 - i) * 8);
for (i = 0; i < 4; i++)
mac_addr[i + 2] = (uint8_t)(rar_low >> (3 - i) * 8);
}
enum ngbe_media_type
ngbe_get_media_type(struct ngbe_hw *hw)
{
enum ngbe_media_type media_type = ngbe_media_type_copper;
return media_type;
}
void
ngbe_gphy_dis_eee(struct ngbe_hw *hw)
{
uint16_t val = 0;
hw->phy.ops.write_reg(hw, 0x11, 0xa4b, 0x1110);
hw->phy.ops.write_reg(hw, MII_MMDACR, 0x0, MMDACR_FN_ADDRESS | 0x07);
hw->phy.ops.write_reg(hw, MII_MMDAADR, 0x0, 0x003c);
hw->phy.ops.write_reg(hw, MII_MMDACR, 0x0, MMDACR_FN_DATANPI | 0x07);
hw->phy.ops.write_reg(hw, MII_MMDAADR, 0x0, 0);
msec_delay(100);
hw->phy.ops.read_reg(hw, MII_ANAR, 0, &val);
val &= ~(ANAR_TX | ANAR_10);
hw->phy.ops.write_reg(hw, MII_ANAR, 0x0, val);
}
void
ngbe_gphy_efuse_calibration(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t efuse[2];
ngbe_gphy_wait_mdio_access_on(hw);
efuse[0] = sc->gphy_efuse[0];
efuse[1] = sc->gphy_efuse[1];
if (!efuse[0] && !efuse[1])
efuse[0] = efuse[1] = 0xffffffff;
efuse[0] |= 0xf0000100;
efuse[1] |= 0xff807fff;
ngbe_phy_write_reg(hw, 16, 0xa46, (efuse[0] >> 0) & 0xffff);
ngbe_phy_write_reg(hw, 17, 0xa46, (efuse[0] >> 16) & 0xffff);
ngbe_phy_write_reg(hw, 18, 0xa46, (efuse[1] >> 0) & 0xffff);
ngbe_phy_write_reg(hw, 19, 0xa46, (efuse[1] >> 16) & 0xffff);
ngbe_phy_write_reg(hw, 20, 0xa46, 0x01);
ngbe_gphy_wait_mdio_access_on(hw);
ngbe_phy_write_reg(hw, 27, NGBE_INTERNAL_PHY_PAGE_OFFSET, 0x8011);
ngbe_phy_write_reg(hw, 28, NGBE_INTERNAL_PHY_PAGE_OFFSET, 0x5737);
ngbe_gphy_dis_eee(hw);
}
void
ngbe_gphy_wait_mdio_access_on(struct ngbe_hw *hw)
{
uint16_t val = 0;
int i;
for (i = 0; i < 100; i++) {
ngbe_phy_read_reg(hw, 29, NGBE_INTERNAL_PHY_PAGE_OFFSET, &val);
if (val & 0x20)
break;
DELAY(1000);
}
}
void
ngbe_handle_phy_event(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t reg;
reg = NGBE_READ_REG(hw, NGBE_GPIO_INTSTATUS);
NGBE_WRITE_REG(hw, NGBE_GPIO_EOI, reg);
if (!((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA))
hw->phy.ops.check_event(sc);
}
int
ngbe_host_interface_command(struct ngbe_softc *sc, uint32_t *buffer,
uint32_t length, uint32_t timeout, int return_data)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t hicr, i, bi, dword_len;
uint32_t hdr_size = sizeof(struct ngbe_hic_hdr);
uint32_t buf[64] = {};
uint16_t buf_len;
int status = 0;
if (length == 0 || length > NGBE_HI_MAX_BLOCK_BYTE_LENGTH) {
printf("%s: buffer length failure\n", DEVNAME(sc));
return EINVAL;
}
if (hw->mac.ops.acquire_swfw_sync(sc, NGBE_MNG_SWFW_SYNC_SW_MB))
return EINVAL;
if ((length % (sizeof(uint32_t))) != 0) {
printf("%s: buffer length failure, not aligned to dword\n",
DEVNAME(sc));
status = EINVAL;
goto rel_out;
}
if (ngbe_check_mng_access(hw)) {
hicr = NGBE_READ_REG(hw, NGBE_MNG_MBOX_CTL);
if ((hicr & NGBE_MNG_MBOX_CTL_FWRDY))
printf("%s: fwrdy is set before command\n",
DEVNAME(sc));
}
dword_len = length >> 2;
for (i = 0; i < dword_len; i++) {
if (ngbe_check_mng_access(hw)) {
NGBE_WRITE_REG_ARRAY(hw, NGBE_MNG_MBOX, i,
htole32(buffer[i]));
} else {
status = EINVAL;
goto rel_out;
}
}
if (ngbe_check_mng_access(hw)) {
NGBE_WRITE_REG_MASK(hw, NGBE_MNG_MBOX_CTL,
NGBE_MNG_MBOX_CTL_SWRDY, NGBE_MNG_MBOX_CTL_SWRDY);
} else {
status = EINVAL;
goto rel_out;
}
for (i = 0; i < timeout; i++) {
if (ngbe_check_mng_access(hw)) {
hicr = NGBE_READ_REG(hw, NGBE_MNG_MBOX_CTL);
if ((hicr & NGBE_MNG_MBOX_CTL_FWRDY))
break;
}
msec_delay(1);
}
buf[0] = NGBE_READ_REG(hw, NGBE_MNG_MBOX);
if (timeout != 0 && i == timeout) {
printf("%s: command has failed with no status valid\n",
DEVNAME(sc));
if ((buffer[0] & 0xff) != (~buf[0] >> 24)) {
status = EINVAL;
goto rel_out;
}
}
if (!return_data)
goto rel_out;
dword_len = hdr_size >> 2;
for (bi = 0; bi < dword_len; bi++) {
if (ngbe_check_mng_access(hw)) {
buffer[bi] = NGBE_READ_REG_ARRAY(hw, NGBE_MNG_MBOX, bi);
le32_to_cpus(&buffer[bi]);
} else {
status = EINVAL;
goto rel_out;
}
}
buf_len = ((struct ngbe_hic_hdr *)buffer)->buf_len;
if (buf_len == 0)
goto rel_out;
if (length < buf_len + hdr_size) {
printf("%s: buffer not large enough for reply message\n",
DEVNAME(sc));
status = EINVAL;
goto rel_out;
}
dword_len = (buf_len + 3) >> 2;
for (; bi <= dword_len; bi++) {
if (ngbe_check_mng_access(hw)) {
buffer[bi] = NGBE_READ_REG_ARRAY(hw, NGBE_MNG_MBOX, bi);
le32_to_cpus(&buffer[bi]);
} else {
status = EINVAL;
goto rel_out;
}
}
rel_out:
hw->mac.ops.release_swfw_sync(sc, NGBE_MNG_SWFW_SYNC_SW_MB);
return status;
}
int
ngbe_hpbthresh(struct ngbe_softc *sc)
{
uint32_t dv_id, rx_pba;
int kb, link, marker, tc;
tc = link = sc->sc_ac.ac_if.if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN +
NGBE_ETH_FRAMING;
dv_id = NGBE_DV(link, tc);
kb = NGBE_BT2KB(dv_id);
rx_pba = NGBE_READ_REG(&sc->hw, NGBE_RDB_PB_SZ) >> NGBE_RDB_PB_SZ_SHIFT;
marker = rx_pba - kb;
return marker;
}
int
ngbe_lpbthresh(struct ngbe_softc *sc)
{
uint32_t dv_id;
int tc;
tc = sc->sc_ac.ac_if.if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
dv_id = NGBE_LOW_DV(tc);
return NGBE_BT2KB(dv_id);
}
int
ngbe_mng_present(struct ngbe_hw *hw)
{
uint32_t fwsm;
fwsm = NGBE_READ_REG(hw, NGBE_MIS_ST);
return fwsm & NGBE_MIS_ST_MNG_INIT_DN;
}
int
ngbe_mta_vector(struct ngbe_hw *hw, uint8_t *mc_addr)
{
uint32_t vector = 0;
int rshift;
vector = mc_addr[4] | (((uint16_t)mc_addr[5]) << 8);
switch (hw->mac.mc_filter_type) {
case 0:
case 1:
case 2:
rshift = 4 - hw->mac.mc_filter_type;
break;
case 3:
rshift = 0;
break;
default:
vector = rshift = 0;
break;
}
vector = (vector >> rshift) & 0x0fff;
return vector;
}
int
ngbe_negotiate_fc(struct ngbe_softc *sc, uint32_t adv_reg, uint32_t lp_reg,
uint32_t adv_sym, uint32_t adv_asm, uint32_t lp_sym, uint32_t lp_asm)
{
struct ngbe_hw *hw = &sc->hw;
if ((!(adv_reg)) || (!(lp_reg)))
return EINVAL;
if ((adv_reg & adv_sym) && (lp_reg & lp_sym)) {
if (hw->fc.requested_mode == ngbe_fc_full)
hw->fc.current_mode = ngbe_fc_full;
else
hw->fc.current_mode = ngbe_fc_rx_pause;
} else if (!(adv_reg & adv_sym) && (adv_reg & adv_asm) &&
(lp_reg & lp_sym) && (lp_reg & lp_asm))
hw->fc.current_mode = ngbe_fc_tx_pause;
else if ((adv_reg & adv_sym) && (adv_reg & adv_asm) &&
!(lp_reg & lp_sym) && (lp_reg & lp_asm))
hw->fc.current_mode = ngbe_fc_rx_pause;
else
hw->fc.current_mode = ngbe_fc_none;
return 0;
}
int
ngbe_non_sfp_link_config(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t speed;
int error;
if (hw->mac.autoneg)
speed = hw->phy.autoneg_advertised;
else
speed = hw->phy.force_speed;
msec_delay(50);
if (hw->phy.type == ngbe_phy_internal) {
error = hw->phy.ops.setup_once(sc);
if (error)
return error;
}
error = hw->mac.ops.setup_link(sc, speed, 0);
return error;
}
void
ngbe_pbthresh_setup(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
hw->fc.high_water = ngbe_hpbthresh(sc);
hw->fc.low_water = ngbe_lpbthresh(sc);
if (hw->fc.low_water > hw->fc.high_water)
hw->fc.low_water = 0;
}
void
ngbe_phy_check_event(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value = 0;
hw->phy.ops.read_reg(hw, NGBE_MDIO_AUTO_NEG_LSC,
NGBE_INTERNAL_PHY_PAGE_OFFSET, &value);
}
int
ngbe_phy_check_overtemp(struct ngbe_hw *hw)
{
uint32_t ts_state;
int status = 0;
ts_state = NGBE_READ_REG(hw, NGBE_TS_ALARM_ST);
if (ts_state & NGBE_TS_ALARM_ST_ALARM)
status = 1;
return status;
}
void
ngbe_phy_get_advertised_pause(struct ngbe_hw *hw, uint8_t *pause_bit)
{
uint16_t value;
hw->phy.ops.read_reg(hw, 4, 0, &value);
*pause_bit = (uint8_t)((value >> 10) & 0x3);
}
void
ngbe_phy_get_lp_advertised_pause(struct ngbe_hw *hw, uint8_t *pause_bit)
{
uint16_t value;
hw->phy.ops.read_reg(hw, NGBE_MDIO_AUTO_NEG_LSC,
NGBE_INTERNAL_PHY_PAGE_OFFSET, &value);
hw->phy.ops.read_reg(hw, MII_BMSR, 0, &value);
value = (value & BMSR_ACOMP) ? 1 : 0;
hw->phy.ops.read_reg(hw, MII_ANLPAR, 0, &value);
*pause_bit = (uint8_t)((value >> 10) & 0x3);
}
int
ngbe_phy_identify(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int error;
switch(hw->phy.type) {
case ngbe_phy_internal:
error = ngbe_check_internal_phy_id(sc);
break;
default:
error = ENOTSUP;
}
return error;
}
int
ngbe_phy_init(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value;
uint8_t lan_id = hw->bus.lan_id;
int error;
if (!hw->phy.phy_semaphore_mask)
hw->phy.phy_semaphore_mask = NGBE_MNG_SWFW_SYNC_SW_PHY;
hw->phy.addr = 0;
error = hw->phy.ops.identify(sc);
if (error == ENOTSUP)
return error;
if (hw->phy.type == ngbe_phy_internal) {
value = NGBE_INTPHY_INT_LSC | NGBE_INTPHY_INT_ANC;
hw->phy.ops.write_reg(hw, 0x12, 0xa42, value);
sc->gphy_efuse[0] =
ngbe_flash_read_dword(hw, 0xfe010 + lan_id * 8);
sc->gphy_efuse[1] =
ngbe_flash_read_dword(hw, 0xfe010 + lan_id * 8 + 4);
}
return error;
}
void
ngbe_phy_led_ctrl(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value;
if (sc->led_conf != -1)
value = sc->led_conf & 0xffff;
else
value = 0x205b;
hw->phy.ops.write_reg(hw, 16, 0xd04, value);
hw->phy.ops.write_reg(hw, 17, 0xd04, 0);
hw->phy.ops.read_reg(hw, 18, 0xd04, &value);
if (sc->led_conf != -1) {
value &= ~0x73;
value |= sc->led_conf >> 16;
} else {
value &= 0xfffc;
value |= 0x2;
}
hw->phy.ops.write_reg(hw, 18, 0xd04, value);
}
int
ngbe_phy_led_oem_chk(struct ngbe_softc *sc, uint32_t *data)
{
struct ngbe_hw *hw = &sc->hw;
struct ngbe_hic_read_shadow_ram buffer;
uint32_t tmp;
int status;
buffer.hdr.req.cmd = FW_PHY_LED_CONF;
buffer.hdr.req.buf_lenh = 0;
buffer.hdr.req.buf_lenl = 0;
buffer.hdr.req.checksum = FW_DEFAULT_CHECKSUM;
buffer.address = 0;
buffer.length = 0;
status = ngbe_host_interface_command(sc, (uint32_t *)&buffer,
sizeof(buffer), NGBE_HI_COMMAND_TIMEOUT, 0);
if (status)
return status;
if (ngbe_check_mng_access(hw)) {
tmp = NGBE_READ_REG_ARRAY(hw, NGBE_MNG_MBOX, 1);
if (tmp == NGBE_CHECKSUM_CAP_ST_PASS) {
tmp = NGBE_READ_REG_ARRAY(hw, NGBE_MNG_MBOX, 2);
*data = tmp;
status = 0;
} else if (tmp == NGBE_CHECKSUM_CAP_ST_FAIL) {
*data = tmp;
status = EINVAL;
} else
status = EINVAL;
} else {
status = EINVAL;
return status;
}
return status;
}
int
ngbe_phy_read_reg(struct ngbe_hw *hw, uint32_t off, uint32_t page,
uint16_t *data)
{
*data = 0;
if (!((page == NGBE_INTERNAL_PHY_PAGE_OFFSET) &&
((off == NGBE_MDIO_AUTO_NEG_STATUS) ||
(off == NGBE_MDIO_AUTO_NEG_LSC)))) {
NGBE_WRITE_REG(hw,
NGBE_PHY_CONFIG(NGBE_INTERNAL_PHY_PAGE_SELECT_OFFSET),
page);
}
*data = NGBE_READ_REG(hw, NGBE_PHY_CONFIG(off)) & 0xffff;
return 0;
}
int
ngbe_phy_write_reg(struct ngbe_hw *hw, uint32_t off, uint32_t page,
uint16_t data)
{
if (!((page == NGBE_INTERNAL_PHY_PAGE_OFFSET) &&
((off == NGBE_MDIO_AUTO_NEG_STATUS) ||
(off == NGBE_MDIO_AUTO_NEG_LSC)))) {
NGBE_WRITE_REG(hw,
NGBE_PHY_CONFIG(NGBE_INTERNAL_PHY_PAGE_SELECT_OFFSET),
page);
}
NGBE_WRITE_REG(hw, NGBE_PHY_CONFIG(off), data);
return 0;
}
int
ngbe_phy_reset(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value;
int i, status;
if (hw->phy.type != ngbe_phy_internal) {
printf("%s: operation not supported\n", DEVNAME(sc));
return EINVAL;
}
if (!hw->phy.reset_if_overtemp && hw->phy.ops.check_overtemp(hw) != 0) {
printf("%s: overtemp! skip phy reset\n", DEVNAME(sc));
return EINVAL;
}
status = ngbe_check_reset_blocked(sc);
if (status)
return status;
value = NGBE_MDI_PHY_RESET;
status = hw->phy.ops.write_reg(hw, 0, 0, value);
for (i = 0; i < NGBE_PHY_RST_WAIT_PERIOD; i++) {
status = hw->phy.ops.read_reg(hw, 0, 0, &value);
if (!(value & NGBE_MDI_PHY_RESET))
break;
msec_delay(1);
}
if (i == NGBE_PHY_RST_WAIT_PERIOD) {
printf("%s: phy mode reset did not complete\n", DEVNAME(sc));
return ETIMEDOUT;
}
return status;
}
int
ngbe_phy_set_pause_advertisement(struct ngbe_hw *hw, uint16_t pause_bit)
{
uint16_t value;
int status;
status = hw->phy.ops.read_reg(hw, MII_ANAR, 0, &value);
value &= ~0xc00;
value |= pause_bit;
status = hw->phy.ops.write_reg(hw, MII_ANAR, 0, value);
return status;
}
int
ngbe_phy_setup(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value = 0;
int i;
for (i = 0; i < 15; i++) {
if (!NGBE_READ_REG_MASK(hw, NGBE_MIS_ST,
NGBE_MIS_ST_GPHY_IN_RST(hw->bus.lan_id)))
break;
msec_delay(1);
}
if (i == 15) {
printf("%s: gphy reset exceeds maximum time\n", DEVNAME(sc));
return ETIMEDOUT;
}
ngbe_gphy_efuse_calibration(sc);
hw->phy.ops.write_reg(hw, 20, 0xa46, 2);
ngbe_gphy_wait_mdio_access_on(hw);
for (i = 0; i < 100; i++) {
hw->phy.ops.read_reg(hw, 16, 0xa42, &value);
if ((value & 0x7) == 3)
break;
DELAY(1000);
}
if (i == 100) {
printf("%s: phy reset exceeds maximum time\n", DEVNAME(sc));
return ETIMEDOUT;
}
return 0;
}
int
ngbe_phy_setup_link(struct ngbe_softc *sc, uint32_t speed, int need_restart)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t value = 0;
int status;
if (!hw->mac.autoneg) {
status = hw->phy.ops.reset(sc);
if (status) {
printf("%s: phy reset failed\n", DEVNAME(sc));
return status;
}
switch (speed) {
case NGBE_LINK_SPEED_1GB_FULL:
value = NGBE_MDI_PHY_SPEED_SELECT1;
break;
case NGBE_LINK_SPEED_100_FULL:
value = NGBE_MDI_PHY_SPEED_SELECT0;
break;
case NGBE_LINK_SPEED_10_FULL:
value = 0;
break;
default:
value = NGBE_MDI_PHY_SPEED_SELECT0 |
NGBE_MDI_PHY_SPEED_SELECT1;
printf("%s: unknown speed = 0x%x\n",
DEVNAME(sc), speed);
break;
}
value |= NGBE_MDI_PHY_DUPLEX;
hw->phy.ops.write_reg(hw, 0, 0, value);
goto skip_an;
}
hw->phy.ops.read_reg(hw, 4, 0, &value);
value &= 0xff5f;
hw->phy.ops.write_reg(hw, 4, 0, value);
hw->phy.ops.read_reg(hw, 9, 0, &value);
if (!(speed & NGBE_LINK_SPEED_1GB_FULL))
value &= 0xfdff;
else
value |= 0x200;
hw->phy.ops.write_reg(hw, 9, 0, value);
hw->phy.ops.read_reg(hw, 4, 0, &value);
if (!(speed & NGBE_LINK_SPEED_100_FULL))
value &= 0xfeff;
else
value |= 0x100;
hw->phy.ops.write_reg(hw, 4, 0, value);
hw->phy.ops.read_reg(hw, 4, 0, &value);
if (!(speed & NGBE_LINK_SPEED_10_FULL))
value &= 0xffbf;
else
value |= 0x40;
hw->phy.ops.write_reg(hw, 4, 0, value);
value = NGBE_MDI_PHY_RESTART_AN | NGBE_MDI_PHY_ANE;
hw->phy.ops.write_reg(hw, 0, 0, value);
skip_an:
hw->phy.ops.phy_led_ctrl(sc);
hw->phy.ops.check_event(sc);
return 0;
}
uint16_t
ngbe_read_pci_cfg_word(struct ngbe_softc *sc, uint32_t reg)
{
struct ngbe_osdep *os = &sc->osdep;
struct pci_attach_args *pa = &os->os_pa;
uint32_t value;
int high = 0;
if (reg & 0x2) {
high = 1;
reg &= ~0x2;
}
value = pci_conf_read(pa->pa_pc, pa->pa_tag, reg);
if (high)
value >>= 16;
return (value & 0xffff);
}
void
ngbe_release_eeprom_semaphore(struct ngbe_hw *hw)
{
if (ngbe_check_mng_access(hw)) {
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_SWSM, NGBE_MIS_SWSM_SMBI, 0);
NGBE_WRITE_FLUSH(hw);
}
}
int
ngbe_acquire_swfw_sync(struct ngbe_softc *sc, uint32_t mask)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t gssr = 0;
uint32_t swmask = mask;
uint32_t fwmask = mask << 16;
int i, timeout = 200;
for (i = 0; i < timeout; i++) {
if (ngbe_get_eeprom_semaphore(sc))
return 1;
if (ngbe_check_mng_access(hw)) {
gssr = NGBE_READ_REG(hw, NGBE_MNG_SWFW_SYNC);
if (!(gssr & (fwmask | swmask))) {
gssr |= swmask;
NGBE_WRITE_REG(hw, NGBE_MNG_SWFW_SYNC, gssr);
ngbe_release_eeprom_semaphore(hw);
return 0;
} else {
ngbe_release_eeprom_semaphore(hw);
msec_delay(5);
}
}
}
printf("%s: semaphore failed\n", DEVNAME(sc));
if (gssr & (fwmask | swmask))
ngbe_release_swfw_sync(sc, gssr & (fwmask | swmask));
msec_delay(5);
return 1;
}
void
ngbe_release_swfw_sync(struct ngbe_softc *sc, uint32_t mask)
{
struct ngbe_hw *hw = &sc->hw;
ngbe_get_eeprom_semaphore(sc);
if (ngbe_check_mng_access(hw))
NGBE_WRITE_REG_MASK(hw, NGBE_MNG_SWFW_SYNC, mask, 0);
ngbe_release_eeprom_semaphore(hw);
}
void
ngbe_reset(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int error;
error = hw->mac.ops.init_hw(sc);
switch (error) {
case 0:
break;
default:
printf("%s: hardware error\n", DEVNAME(sc));
break;
}
}
int
ngbe_reset_hw(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
struct ngbe_mac_info *mac = &hw->mac;
uint32_t i, reset_status, rst_delay;
uint32_t reset = 0;
int status = 0;
status = hw->mac.ops.stop_adapter(sc);
if (status)
goto reset_hw_out;
if (!((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA)) {
status = hw->phy.ops.init(sc);
if (status)
goto reset_hw_out;
}
if (ngbe_get_media_type(hw) == ngbe_media_type_copper) {
mac->ops.setup_link = ngbe_setup_copper_link;
mac->ops.get_link_capabilities =
ngbe_get_copper_link_capabilities;
}
if (hw->force_full_reset) {
rst_delay = (NGBE_READ_REG(hw, NGBE_MIS_RST_ST) &
NGBE_MIS_RST_ST_RST_INIT) >> NGBE_MIS_RST_ST_RST_INI_SHIFT;
if (hw->reset_type == NGBE_SW_RESET) {
for (i = 0; i < rst_delay + 20; i++) {
reset_status =
NGBE_READ_REG(hw, NGBE_MIS_RST_ST);
if (!(reset_status &
NGBE_MIS_RST_ST_DEV_RST_ST_MASK))
break;
msec_delay(100);
}
if (reset_status & NGBE_MIS_RST_ST_DEV_RST_ST_MASK) {
status = ETIMEDOUT;
printf("%s: software reset polling failed to "
"complete\n", DEVNAME(sc));
goto reset_hw_out;
}
status = ngbe_check_flash_load(sc,
NGBE_SPI_ILDR_STATUS_SW_RESET);
if (status)
goto reset_hw_out;
} else if (hw->reset_type == NGBE_GLOBAL_RESET) {
msec_delay(100 * rst_delay + 2000);
}
} else {
if (hw->bus.lan_id == 0)
reset = NGBE_MIS_RST_LAN0_RST;
else if (hw->bus.lan_id == 1)
reset = NGBE_MIS_RST_LAN1_RST;
else if (hw->bus.lan_id == 2)
reset = NGBE_MIS_RST_LAN2_RST;
else if (hw->bus.lan_id == 3)
reset = NGBE_MIS_RST_LAN3_RST;
NGBE_WRITE_REG(hw, NGBE_MIS_RST,
reset | NGBE_READ_REG(hw, NGBE_MIS_RST));
NGBE_WRITE_FLUSH(hw);
msec_delay(15);
}
ngbe_reset_misc(hw);
hw->mac.ops.get_mac_addr(hw, hw->mac.perm_addr);
hw->mac.num_rar_entries = NGBE_SP_RAR_ENTRIES;
hw->mac.ops.init_rx_addrs(sc);
reset_hw_out:
return status;
}
void
ngbe_reset_misc(struct ngbe_hw *hw)
{
int i;
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_RX_CFG, NGBE_MAC_RX_CFG_JE,
NGBE_MAC_RX_CFG_JE);
NGBE_WRITE_REG_MASK(hw, NGBE_MMC_CONTROL, NGBE_MMC_CONTROL_RSTONRD,
NGBE_MMC_CONTROL_RSTONRD);
NGBE_WRITE_REG_MASK(hw, NGBE_MAC_RX_FLOW_CTRL,
NGBE_MAC_RX_FLOW_CTRL_RFE, NGBE_MAC_RX_FLOW_CTRL_RFE);
NGBE_WRITE_REG(hw, NGBE_MAC_PKT_FLT, NGBE_MAC_PKT_FLT_PR);
NGBE_WRITE_REG_MASK(hw, NGBE_MIS_RST_ST, NGBE_MIS_RST_ST_RST_INIT,
0x1e00);
NGBE_WRITE_REG(hw, NGBE_PSR_MNG_FLEX_SEL, 0);
for (i = 0; i < 16; i++) {
NGBE_WRITE_REG(hw, NGBE_PSR_MNG_FLEX_DW_L(i), 0);
NGBE_WRITE_REG(hw, NGBE_PSR_MNG_FLEX_DW_H(i), 0);
NGBE_WRITE_REG(hw, NGBE_PSR_MNG_FLEX_MSK(i), 0);
}
NGBE_WRITE_REG(hw, NGBE_PSR_LAN_FLEX_SEL, 0);
for (i = 0; i < 16; i++) {
NGBE_WRITE_REG(hw, NGBE_PSR_LAN_FLEX_DW_L(i), 0);
NGBE_WRITE_REG(hw, NGBE_PSR_LAN_FLEX_DW_H(i), 0);
NGBE_WRITE_REG(hw, NGBE_PSR_LAN_FLEX_MSK(i), 0);
}
NGBE_WRITE_REG(hw, NGBE_RDB_PFCMACDAL, 0xc2000001);
NGBE_WRITE_REG(hw, NGBE_RDB_PFCMACDAH, 0x0180);
NGBE_WRITE_REG(hw, NGBE_MDIO_CLAUSE_SELECT, 0xf);
ngbe_init_thermal_sensor_thresh(hw);
}
int
ngbe_set_fw_drv_ver(struct ngbe_softc *sc, uint8_t maj, uint8_t min,
uint8_t build, uint8_t sub)
{
struct ngbe_hw *hw = &sc->hw;
struct ngbe_hic_drv_info fw_cmd;
int i, error = 0;
fw_cmd.hdr.cmd = FW_CEM_CMD_DRIVER_INFO;
fw_cmd.hdr.buf_len = FW_CEM_CMD_DRIVER_INFO_LEN;
fw_cmd.hdr.cmd_or_resp.cmd_resv = FW_CEM_CMD_RESERVED;
fw_cmd.port_num = (uint8_t)hw->bus.lan_id;
fw_cmd.ver_maj = maj;
fw_cmd.ver_min = min;
fw_cmd.ver_build = build;
fw_cmd.ver_sub = sub;
fw_cmd.hdr.checksum = 0;
fw_cmd.hdr.checksum = ngbe_calculate_checksum((uint8_t *)&fw_cmd,
(FW_CEM_HDR_LEN + fw_cmd.hdr.buf_len));
fw_cmd.pad = 0;
fw_cmd.pad2 = 0;
DELAY(5000);
for (i = 0; i <= FW_CEM_MAX_RETRIES; i++) {
error = ngbe_host_interface_command(sc, (uint32_t *)&fw_cmd,
sizeof(fw_cmd), NGBE_HI_COMMAND_TIMEOUT, 1);
if (error)
continue;
if (fw_cmd.hdr.cmd_or_resp.ret_status ==
FW_CEM_RESP_STATUS_SUCCESS)
error = 0;
else
error = EINVAL;
break;
}
return error;
}
void
ngbe_set_ivar(struct ngbe_softc *sc, uint16_t entry, uint16_t vector, int8_t
type)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t ivar, index;
vector |= NGBE_PX_IVAR_ALLOC_VAL;
if (type == -1) {
index = 0;
ivar = NGBE_READ_REG(hw, NGBE_PX_MISC_IVAR);
ivar &= ~((uint32_t)0xff << index);
ivar |= ((uint32_t)vector << index);
NGBE_WRITE_REG(hw, NGBE_PX_MISC_IVAR, ivar);
} else {
index = ((16 * (entry & 1)) + (8 * type));
ivar = NGBE_READ_REG(hw, NGBE_PX_IVAR(entry >> 1));
ivar &= ~((uint32_t)0xff << index);
ivar |= ((uint32_t)vector << index);
NGBE_WRITE_REG(hw, NGBE_PX_IVAR(entry >> 1), ivar);
}
}
void
ngbe_set_lan_id_multi_port_pcie(struct ngbe_hw *hw)
{
struct ngbe_bus_info *bus = &hw->bus;
uint32_t reg = 0;
reg = NGBE_READ_REG(hw, NGBE_CFG_PORT_ST);
bus->lan_id = NGBE_CFG_PORT_ST_LAN_ID(reg);
}
void
ngbe_set_mta(struct ngbe_hw *hw, uint8_t *mc_addr)
{
uint32_t vector, vector_bit, vector_reg;
hw->addr_ctrl.mta_in_use++;
vector = ngbe_mta_vector(hw, mc_addr);
vector_reg = (vector >> 5) & 0x7f;
vector_bit = vector & 0x1f;
hw->mac.mta_shadow[vector_reg] |= (1 << vector_bit);
}
void
ngbe_set_pci_config_data(struct ngbe_hw *hw, uint16_t link_status)
{
if (hw->bus.type == ngbe_bus_type_unknown)
hw->bus.type = ngbe_bus_type_pci_express;
switch (link_status & NGBE_PCI_LINK_WIDTH) {
case NGBE_PCI_LINK_WIDTH_1:
hw->bus.width = ngbe_bus_width_pcie_x1;
break;
case NGBE_PCI_LINK_WIDTH_2:
hw->bus.width = ngbe_bus_width_pcie_x2;
break;
case NGBE_PCI_LINK_WIDTH_4:
hw->bus.width = ngbe_bus_width_pcie_x4;
break;
case NGBE_PCI_LINK_WIDTH_8:
hw->bus.width = ngbe_bus_width_pcie_x8;
break;
default:
hw->bus.width = ngbe_bus_width_unknown;
break;
}
switch (link_status & NGBE_PCI_LINK_SPEED) {
case NGBE_PCI_LINK_SPEED_2500:
hw->bus.speed = ngbe_bus_speed_2500;
break;
case NGBE_PCI_LINK_SPEED_5000:
hw->bus.speed = ngbe_bus_speed_5000;
break;
case NGBE_PCI_LINK_SPEED_8000:
hw->bus.speed = ngbe_bus_speed_8000;
break;
default:
hw->bus.speed = ngbe_bus_speed_unknown;
break;
}
}
int
ngbe_set_rar(struct ngbe_softc *sc, uint32_t index, uint8_t *addr,
uint64_t pools, uint32_t enable_addr)
{
struct ngbe_hw *hw = &sc->hw;
uint32_t rar_entries = hw->mac.num_rar_entries;
uint32_t rar_low, rar_high;
if (index >= rar_entries) {
printf("%s: RAR index %d is out of range\n",
DEVNAME(sc), index);
return EINVAL;
}
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_IDX, index);
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_VM, pools & 0xffffffff);
rar_low = ((uint32_t)addr[5] | ((uint32_t)addr[4] << 8) |
((uint32_t)addr[3] << 16) | ((uint32_t)addr[2] << 24));
rar_high = ((uint32_t)addr[1] | ((uint32_t)addr[0] << 8));
if (enable_addr != 0)
rar_high |= NGBE_PSR_MAC_SWC_AD_H_AV;
NGBE_WRITE_REG(hw, NGBE_PSR_MAC_SWC_AD_L, rar_low);
NGBE_WRITE_REG_MASK(hw, NGBE_PSR_MAC_SWC_AD_H,
(NGBE_PSR_MAC_SWC_AD_H_AD(~0) | NGBE_PSR_MAC_SWC_AD_H_ADTYPE(~0) |
NGBE_PSR_MAC_SWC_AD_H_AV), rar_high);
return 0;
}
void
ngbe_set_rx_drop_en(struct ngbe_softc *sc)
{
uint32_t srrctl;
int i;
if ((sc->sc_nqueues > 1) &&
!(sc->hw.fc.current_mode & ngbe_fc_tx_pause)) {
for (i = 0; i < sc->sc_nqueues; i++) {
srrctl = NGBE_READ_REG(&sc->hw, NGBE_PX_RR_CFG(i));
srrctl |= NGBE_PX_RR_CFG_DROP_EN;
NGBE_WRITE_REG(&sc->hw, NGBE_PX_RR_CFG(i), srrctl);
}
} else {
for (i = 0; i < sc->sc_nqueues; i++) {
srrctl = NGBE_READ_REG(&sc->hw, NGBE_PX_RR_CFG(i));
srrctl &= ~NGBE_PX_RR_CFG_DROP_EN;
NGBE_WRITE_REG(&sc->hw, NGBE_PX_RR_CFG(i), srrctl);
}
}
}
void
ngbe_set_rxpba(struct ngbe_hw *hw, int num_pb, uint32_t headroom, int strategy)
{
uint32_t pbsize = hw->mac.rx_pb_size;
uint32_t txpktsize, txpbthresh, rxpktsize = 0;
pbsize -= headroom;
if (!num_pb)
num_pb = 1;
switch (strategy) {
case PBA_STRATEGY_EQUAL:
rxpktsize = (pbsize / num_pb) << NGBE_RDB_PB_SZ_SHIFT;
NGBE_WRITE_REG(hw, NGBE_RDB_PB_SZ, rxpktsize);
break;
default:
break;
}
txpktsize = NGBE_TDB_PB_SZ_MAX / num_pb;
txpbthresh = (txpktsize / 1024) - NGBE_TXPKT_SIZE_MAX;
NGBE_WRITE_REG(hw, NGBE_TDB_PB_SZ, txpktsize);
NGBE_WRITE_REG(hw, NGBE_TDM_PB_THRE, txpbthresh);
}
int
ngbe_setup_copper_link(struct ngbe_softc *sc, uint32_t speed, int need_restart)
{
struct ngbe_hw *hw = &sc->hw;
int status = 0;
if (!((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA))
status = hw->phy.ops.setup_link(sc, speed, need_restart);
return status;
}
int
ngbe_setup_fc(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
uint16_t pcap_backplane = 0;
int error = 0;
if (hw->fc.strict_ieee && hw->fc.requested_mode == ngbe_fc_rx_pause) {
printf("%s: ngbe_fc_rx_pause not valid in strict IEEE mode\n",
DEVNAME(sc));
error = EINVAL;
goto out;
}
if (hw->fc.requested_mode == ngbe_fc_default)
hw->fc.requested_mode = ngbe_fc_full;
switch (hw->fc.requested_mode) {
case ngbe_fc_none:
break;
case ngbe_fc_tx_pause:
pcap_backplane |= NGBE_SR_AN_MMD_ADV_REG1_PAUSE_ASM;
break;
case ngbe_fc_rx_pause:
case ngbe_fc_full:
pcap_backplane |= NGBE_SR_AN_MMD_ADV_REG1_PAUSE_SYM |
NGBE_SR_AN_MMD_ADV_REG1_PAUSE_ASM;
break;
default:
printf("%s: flow control param set incorrectly\n", DEVNAME(sc));
error = EINVAL;
goto out;
}
if ((hw->phy.media_type == ngbe_media_type_copper) &&
!((hw->subsystem_device_id & OEM_MASK) == RGMII_FPGA))
error = hw->phy.ops.set_adv_pause(hw, pcap_backplane);
out:
return error;
}
void
ngbe_setup_gpie(struct ngbe_hw *hw)
{
uint32_t gpie;
gpie = NGBE_PX_GPIE_MODEL;
NGBE_WRITE_REG(hw, NGBE_PX_GPIE, gpie);
}
void
ngbe_setup_isb(struct ngbe_softc *sc)
{
uint64_t idba = sc->isbdma.dma_map->dm_segs[0].ds_addr;
NGBE_WRITE_REG(&sc->hw, NGBE_PX_ISB_ADDR_L,
(idba & 0x00000000ffffffffULL));
NGBE_WRITE_REG(&sc->hw, NGBE_PX_ISB_ADDR_H, (idba >> 32));
}
void
ngbe_setup_psrtype(struct ngbe_hw *hw)
{
uint32_t psrtype;
psrtype = NGBE_RDB_PL_CFG_L4HDR | NGBE_RDB_PL_CFG_L3HDR |
NGBE_RDB_PL_CFG_L2HDR | NGBE_RDB_PL_CFG_TUN_TUNHDR |
NGBE_RDB_PL_CFG_TUN_OUTER_L2HDR;
NGBE_WRITE_REG(hw, NGBE_RDB_PL_CFG(0), psrtype);
}
void
ngbe_setup_vlan_hw_support(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int i;
for (i = 0; i < sc->sc_nqueues; i++) {
NGBE_WRITE_REG_MASK(hw, NGBE_PX_RR_CFG(i),
NGBE_PX_RR_CFG_VLAN, NGBE_PX_RR_CFG_VLAN);
}
}
int
ngbe_start_hw(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int error;
hw->phy.media_type = hw->mac.ops.get_media_type(hw);
hw->mac.ops.clear_vfta(hw);
hw->mac.ops.clear_hw_cntrs(hw);
NGBE_WRITE_FLUSH(hw);
error = hw->mac.ops.setup_fc(sc);
hw->adapter_stopped = 0;
hw->mac.autotry_restart = 1;
return error;
}
int
ngbe_stop_adapter(struct ngbe_softc *sc)
{
struct ngbe_hw *hw = &sc->hw;
int i;
hw->adapter_stopped = 1;
hw->mac.ops.disable_rx(hw);
NGBE_WRITE_REG(hw, NGBE_PX_MISC_IC, 0xffffffff);
NGBE_WRITE_REG(hw, NGBE_BME_CTL, 0x3);
for (i = 0; i < hw->mac.max_tx_queues; i++) {
NGBE_WRITE_REG_MASK(hw, NGBE_PX_TR_CFG(i),
NGBE_PX_TR_CFG_SWFLSH | NGBE_PX_TR_CFG_ENABLE,
NGBE_PX_TR_CFG_SWFLSH);
}
for (i = 0; i < hw->mac.max_rx_queues; i++) {
NGBE_WRITE_REG_MASK(hw, NGBE_PX_RR_CFG(i),
NGBE_PX_RR_CFG_RR_EN, 0);
}
NGBE_WRITE_FLUSH(hw);
msec_delay(2);
return ngbe_disable_pcie_master(sc);
}
void
ngbe_rx_checksum(uint32_t staterr, struct mbuf *m)
{
if (staterr & NGBE_RXD_STAT_IPCS) {
if (!(staterr & NGBE_RXD_ERR_IPE))
m->m_pkthdr.csum_flags = M_IPV4_CSUM_IN_OK;
else
m->m_pkthdr.csum_flags = 0;
}
if (staterr & NGBE_RXD_STAT_L4CS) {
if (!(staterr & NGBE_RXD_ERR_TCPE))
m->m_pkthdr.csum_flags |=
M_TCP_CSUM_IN_OK | M_UDP_CSUM_IN_OK;
}
}
void
ngbe_rxeof(struct rx_ring *rxr)
{
struct ngbe_softc *sc = rxr->sc;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct mbuf_list ml = MBUF_LIST_INITIALIZER();
struct mbuf *mp, *m;
struct ngbe_rx_buf *rxbuf, *nxbuf;
union ngbe_rx_desc *rxdesc;
uint32_t staterr = 0;
uint16_t len, vtag;
uint8_t eop = 0;
int i, nextp;
if (!ISSET(ifp->if_flags, IFF_RUNNING))
return;
i = rxr->next_to_check;
while (if_rxr_inuse(&rxr->rx_ring) > 0) {
uint32_t hash;
uint16_t hashtype;
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
i * sizeof(union ngbe_rx_desc), sizeof(union ngbe_rx_desc),
BUS_DMASYNC_POSTREAD);
rxdesc = &rxr->rx_base[i];
staterr = letoh32(rxdesc->wb.upper.status_error);
if (!ISSET(staterr, NGBE_RXD_STAT_DD)) {
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
i * sizeof(union ngbe_rx_desc),
sizeof(union ngbe_rx_desc), BUS_DMASYNC_PREREAD);
break;
}
rxdesc->wb.upper.status_error = 0;
rxbuf = &rxr->rx_buffers[i];
bus_dmamap_sync(rxr->rxdma.dma_tag, rxbuf->map, 0,
rxbuf->map->dm_mapsize, BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(rxr->rxdma.dma_tag, rxbuf->map);
mp = rxbuf->buf;
len = letoh16(rxdesc->wb.upper.length);
vtag = letoh16(rxdesc->wb.upper.vlan);
eop = ((staterr & NGBE_RXD_STAT_EOP) != 0);
hash = letoh32(rxdesc->wb.lower.hi_dword.rss);
hashtype = le16toh(rxdesc->wb.lower.lo_dword.hs_rss.pkt_info) &
NGBE_RXD_RSSTYPE_MASK;
if (staterr & NGBE_RXD_ERR_RXE) {
if (rxbuf->fmp) {
m_freem(rxbuf->fmp);
rxbuf->fmp = NULL;
}
m_freem(mp);
rxbuf->buf = NULL;
goto next_desc;
}
if (mp == NULL) {
panic("%s: ngbe_rxeof: NULL mbuf in slot %d "
"(nrx %d, filled %d)", DEVNAME(sc), i,
if_rxr_inuse(&rxr->rx_ring), rxr->last_desc_filled);
}
if (!eop) {
nextp = i + 1;
if (nextp == sc->num_rx_desc)
nextp = 0;
nxbuf = &rxr->rx_buffers[nextp];
}
mp->m_len = len;
m = rxbuf->fmp;
rxbuf->buf = rxbuf->fmp = NULL;
if (m != NULL)
m->m_pkthdr.len += mp->m_len;
else {
m = mp;
m->m_pkthdr.len = mp->m_len;
#if NVLAN > 0
if (staterr & NGBE_RXD_STAT_VP) {
m->m_pkthdr.ether_vtag = vtag;
m->m_flags |= M_VLANTAG;
}
#endif
}
if (eop == 0) {
nxbuf->fmp = m;
m = NULL;
mp->m_next = nxbuf->buf;
} else {
ngbe_rx_checksum(staterr, m);
if (hashtype != NGBE_RXD_RSSTYPE_NONE) {
m->m_pkthdr.ph_flowid = hash;
SET(m->m_pkthdr.csum_flags, M_FLOWID);
}
ml_enqueue(&ml, m);
}
next_desc:
if_rxr_put(&rxr->rx_ring, 1);
bus_dmamap_sync(rxr->rxdma.dma_tag, rxr->rxdma.dma_map,
i * sizeof(union ngbe_rx_desc), sizeof(union ngbe_rx_desc),
BUS_DMASYNC_PREREAD);
if (++i == sc->num_rx_desc)
i = 0;
}
rxr->next_to_check = i;
if (ifiq_input(rxr->ifiq, &ml))
if_rxr_livelocked(&rxr->rx_ring);
if (!(staterr & NGBE_RXD_STAT_DD))
return;
}
void
ngbe_rxrefill(void *xrxr)
{
struct rx_ring *rxr = xrxr;
struct ngbe_softc *sc = rxr->sc;
if (ngbe_rxfill(rxr))
NGBE_WRITE_REG(&sc->hw, NGBE_PX_RR_WP(rxr->me),
rxr->last_desc_filled);
else if (if_rxr_inuse(&rxr->rx_ring) == 0)
timeout_add(&rxr->rx_refill, 1);
}
int
ngbe_tx_ctx_setup(struct tx_ring *txr, struct mbuf *m, uint32_t *cmd_type_len,
uint32_t *olinfo_status)
{
struct ngbe_tx_context_desc *txd;
struct ngbe_tx_buf *tx_buffer;
uint32_t vlan_macip_lens = 0, type_tucmd_mlhl = 0;
int ctxd = txr->next_avail_desc;
int offload = 0;
*olinfo_status |= m->m_pkthdr.len << NGBE_TXD_PAYLEN_SHIFT;
#if NVLAN > 0
if (ISSET(m->m_flags, M_VLANTAG)) {
uint32_t vtag = m->m_pkthdr.ether_vtag;
vlan_macip_lens |= (vtag << NGBE_TXD_VLAN_SHIFT);
*cmd_type_len |= NGBE_TXD_VLE;
offload |= 1;
}
#endif
if (!offload)
return 0;
txd = (struct ngbe_tx_context_desc *)&txr->tx_base[ctxd];
tx_buffer = &txr->tx_buffers[ctxd];
type_tucmd_mlhl |= NGBE_TXD_DTYP_CTXT;
txd->vlan_macip_lens = htole32(vlan_macip_lens);
txd->type_tucmd_mlhl = htole32(type_tucmd_mlhl);
txd->seqnum_seed = htole32(0);
txd->mss_l4len_idx = htole32(0);
tx_buffer->m_head = NULL;
tx_buffer->eop_index = -1;
return 1;
}
void
ngbe_txeof(struct tx_ring *txr)
{
struct ngbe_softc *sc = txr->sc;
struct ifqueue *ifq = txr->ifq;
struct ifnet *ifp = &sc->sc_ac.ac_if;
struct ngbe_tx_buf *tx_buffer;
union ngbe_tx_desc *tx_desc;
unsigned int prod, cons, last;
int done = 0;
if (!ISSET(ifp->if_flags, IFF_RUNNING))
return;
prod = txr->next_avail_desc;
cons = txr->next_to_clean;
if (prod == cons)
return;
bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map, 0,
txr->txdma.dma_map->dm_mapsize, BUS_DMASYNC_POSTREAD);
for (;;) {
tx_buffer = &txr->tx_buffers[cons];
last = tx_buffer->eop_index;
tx_desc = (union ngbe_tx_desc *)&txr->tx_base[last];
if (!ISSET(tx_desc->wb.status, NGBE_TXD_STAT_DD))
break;
bus_dmamap_sync(txr->txdma.dma_tag, tx_buffer->map,
0, tx_buffer->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(txr->txdma.dma_tag, tx_buffer->map);
m_freem(tx_buffer->m_head);
done = 1;
tx_buffer->m_head = NULL;
tx_buffer->eop_index = -1;
cons = last + 1;
if (cons == sc->num_tx_desc)
cons = 0;
if (prod == cons) {
ifp->if_timer = 0;
break;
}
}
bus_dmamap_sync(txr->txdma.dma_tag, txr->txdma.dma_map,
0, txr->txdma.dma_map->dm_mapsize, BUS_DMASYNC_PREREAD);
txr->next_to_clean = cons;
if (done && ifq_is_oactive(ifq))
ifq_restart(ifq);
}
void
ngbe_update_mc_addr_list(struct ngbe_hw *hw, uint8_t *mc_addr_list,
uint32_t mc_addr_count, ngbe_mc_addr_itr next, int clear)
{
uint32_t i, psrctl, vmdq;
hw->addr_ctrl.num_mc_addrs = mc_addr_count;
hw->addr_ctrl.mta_in_use = 0;
if (clear)
memset(&hw->mac.mta_shadow, 0, sizeof(hw->mac.mta_shadow));
for (i = 0; i < mc_addr_count; i++)
ngbe_set_mta(hw, next(hw, &mc_addr_list, &vmdq));
for (i = 0; i < hw->mac.mcft_size; i++)
NGBE_WRITE_REG_ARRAY(hw, NGBE_PSR_MC_TBL(0), i,
hw->mac.mta_shadow[i]);
if (hw->addr_ctrl.mta_in_use > 0) {
psrctl = NGBE_READ_REG(hw, NGBE_PSR_CTL);
psrctl &= ~(NGBE_PSR_CTL_MO | NGBE_PSR_CTL_MFE);
psrctl |= NGBE_PSR_CTL_MFE |
(hw->mac.mc_filter_type << NGBE_PSR_CTL_MO_SHIFT);
NGBE_WRITE_REG(hw, NGBE_PSR_CTL, psrctl);
}
}
int
ngbe_validate_mac_addr(uint8_t *mac_addr)
{
uint32_t status = 0;
if (NGBE_IS_MULTICAST(mac_addr))
status = EINVAL;
else if (NGBE_IS_BROADCAST(mac_addr))
status = EINVAL;
else if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0)
status = EINVAL;
return status;
}
