Ticket #12328: 0001-Sync-atheros813x-with-FreeBSD-11-with-extra-pci-ids.patch

File 0001-Sync-atheros813x-with-FreeBSD-11-with-extra-pci-ids.patch, 84.2 KB (added by i80and, 3 years ago)
  • headers/posix/net/if_media.h

    From 3f60d06879eb7e59c8140845c7a4c75de2408986 Mon Sep 17 00:00:00 2001
    From: Andrew Aldridge <i80and@foxquill.com>
    Date: Wed, 18 Jan 2017 00:00:45 +0000
    Subject: [PATCH] Sync atheros813x with FreeBSD 11 with extra pci ids
    
    ---
     headers/posix/net/if_media.h                       |    1 +
     .../drivers/network/atheros813x/dev/alc/if_alc.c   | 1317 ++++++++++++++++----
     .../network/atheros813x/dev/alc/if_alcreg.h        |  313 ++++-
     .../network/atheros813x/dev/alc/if_alcvar.h        |   10 +-
     .../compat/freebsd_network/compat/net/if_media.h   |    3 +
     5 files changed, 1409 insertions(+), 235 deletions(-)
    
    diff --git a/headers/posix/net/if_media.h b/headers/posix/net/if_media.h
    index ca67cf6..b712905 100644
    a b  
    3232#define IFM_1000_T      16          /* 1000Base-T - RJ45 */
    3333#define IFM_1000_SX     18          /* 1000Base-SX - Fiber Optic */
    3434#define IFM_10G_T       22          /* 10GBase-T - RJ45 */
     35#define IFM_UNKNOWN     25          /* media types not defined yet */
    3536
    3637/* General options */
    3738
  • src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alc.c

    diff --git a/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alc.c b/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alc.c
    index 732220f..e3255af 100644
    a b __FBSDID("$FreeBSD$");  
    4949
    5050#include <net/bpf.h>
    5151#include <net/if.h>
     52#include <net/if_var.h>
    5253#include <net/if_arp.h>
    5354#include <net/ethernet.h>
    5455#include <net/if_dl.h>
    static struct alc_ident alc_ident_table[] = {  
    110111        "Atheros AR8152 v1.1 PCIe Fast Ethernet" },
    111112    { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR8152_B2, 6 * 1024,
    112113        "Atheros AR8152 v2.0 PCIe Fast Ethernet" },
     114    { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR8161, 9 * 1024,
     115        "Atheros AR8161 PCIe Gigabit Ethernet" },
     116    { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR8162, 9 * 1024,
     117        "Atheros AR8162 PCIe Fast Ethernet" },
     118    { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR8171, 9 * 1024,
     119        "Atheros AR8171 PCIe Gigabit Ethernet" },
     120    { VENDORID_ATHEROS, DEVICEID_ATHEROS_AR8172, 9 * 1024,
     121        "Atheros AR8172 PCIe Fast Ethernet" },
     122    { VENDORID_ATHEROS, DEVICEID_ATHEROS_E2200, 9 * 1024,
     123        "Killer E2200 Gigabit Ethernet" },
     124    { VENDORID_ATHEROS, DEVICEID_ATHEROS_E2400, 9 * 1024,
     125        "Killer E2400 Gigabit Ethernet" },
     126    { VENDORID_ATHEROS, DEVICEID_ATHEROS_E2500, 9 * 1024,
     127        "Killer E2500 Gigabit Ethernet" },
    113128    { 0, 0, 0, NULL}
    114129};
    115130
    116 static void alc_aspm(struct alc_softc *, int);
     131static void alc_aspm(struct alc_softc *, int, int);
     132static void alc_aspm_813x(struct alc_softc *, int);
     133static void alc_aspm_816x(struct alc_softc *, int);
    117134static int  alc_attach(device_t);
    118135static int  alc_check_boundary(struct alc_softc *);
     136static void alc_config_msi(struct alc_softc *);
    119137static int  alc_detach(device_t);
    120138static void alc_disable_l0s_l1(struct alc_softc *);
    121139static int  alc_dma_alloc(struct alc_softc *);
    122140static void alc_dma_free(struct alc_softc *);
    123141static void alc_dmamap_cb(void *, bus_dma_segment_t *, int, int);
     142static void alc_dsp_fixup(struct alc_softc *, int);
    124143static int  alc_encap(struct alc_softc *, struct mbuf **);
    125144static struct alc_ident *
    126145        alc_find_ident(device_t);
    static struct mbuf *  
    129148        alc_fixup_rx(struct ifnet *, struct mbuf *);
    130149#endif
    131150static void alc_get_macaddr(struct alc_softc *);
     151static void alc_get_macaddr_813x(struct alc_softc *);
     152static void alc_get_macaddr_816x(struct alc_softc *);
     153static void alc_get_macaddr_par(struct alc_softc *);
    132154static void alc_init(void *);
    133155static void alc_init_cmb(struct alc_softc *);
    134156static void alc_init_locked(struct alc_softc *);
    static void alc_int_task(void *, int);  
    140162static int  alc_intr(void *);
    141163static int  alc_ioctl(struct ifnet *, u_long, caddr_t);
    142164static void alc_mac_config(struct alc_softc *);
     165static uint32_t alc_mii_readreg_813x(struct alc_softc *, int, int);
     166static uint32_t alc_mii_readreg_816x(struct alc_softc *, int, int);
     167static uint32_t alc_mii_writereg_813x(struct alc_softc *, int, int, int);
     168static uint32_t alc_mii_writereg_816x(struct alc_softc *, int, int, int);
    143169static int  alc_miibus_readreg(device_t, int, int);
    144170static void alc_miibus_statchg(device_t);
    145171static int  alc_miibus_writereg(device_t, int, int, int);
     172static uint32_t alc_miidbg_readreg(struct alc_softc *, int);
     173static uint32_t alc_miidbg_writereg(struct alc_softc *, int, int);
     174static uint32_t alc_miiext_readreg(struct alc_softc *, int, int);
     175static uint32_t alc_miiext_writereg(struct alc_softc *, int, int, int);
    146176static int  alc_mediachange(struct ifnet *);
     177static int  alc_mediachange_locked(struct alc_softc *);
    147178static void alc_mediastatus(struct ifnet *, struct ifmediareq *);
    148179static int  alc_newbuf(struct alc_softc *, struct alc_rxdesc *);
     180static void alc_osc_reset(struct alc_softc *);
    149181static void alc_phy_down(struct alc_softc *);
    150182static void alc_phy_reset(struct alc_softc *);
     183static void alc_phy_reset_813x(struct alc_softc *);
     184static void alc_phy_reset_816x(struct alc_softc *);
    151185static int  alc_probe(device_t);
    152186static void alc_reset(struct alc_softc *);
    153187static int  alc_resume(device_t);
    static void alc_rxfilter(struct alc_softc *);  
    157191static void alc_rxvlan(struct alc_softc *);
    158192static void alc_setlinkspeed(struct alc_softc *);
    159193static void alc_setwol(struct alc_softc *);
     194static void alc_setwol_813x(struct alc_softc *);
     195static void alc_setwol_816x(struct alc_softc *);
    160196static int  alc_shutdown(device_t);
    161197static void alc_start(struct ifnet *);
    162198static void alc_start_locked(struct ifnet *);
    static int  
    229265alc_miibus_readreg(device_t dev, int phy, int reg)
    230266{
    231267    struct alc_softc *sc;
    232     uint32_t v;
    233     int i;
     268    int v;
    234269
    235270    sc = device_get_softc(dev);
     271    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     272        v = alc_mii_readreg_816x(sc, phy, reg);
     273    else
     274        v = alc_mii_readreg_813x(sc, phy, reg);
     275    return (v);
     276}
     277
     278static uint32_t
     279alc_mii_readreg_813x(struct alc_softc *sc, int phy, int reg)
     280{
     281    uint32_t v;
     282    int i;
    236283
    237284    /*
    238285     * For AR8132 fast ethernet controller, do not report 1000baseT
    alc_miibus_readreg(device_t dev, int phy, int reg)  
    261308    return ((v & MDIO_DATA_MASK) >> MDIO_DATA_SHIFT);
    262309}
    263310
     311static uint32_t
     312alc_mii_readreg_816x(struct alc_softc *sc, int phy, int reg)
     313{
     314    uint32_t clk, v;
     315    int i;
     316
     317    if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
     318        clk = MDIO_CLK_25_128;
     319    else
     320        clk = MDIO_CLK_25_4;
     321    CSR_WRITE_4(sc, ALC_MDIO, MDIO_OP_EXECUTE | MDIO_OP_READ |
     322        MDIO_SUP_PREAMBLE | clk | MDIO_REG_ADDR(reg));
     323    for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
     324        DELAY(5);
     325        v = CSR_READ_4(sc, ALC_MDIO);
     326        if ((v & MDIO_OP_BUSY) == 0)
     327            break;
     328    }
     329
     330    if (i == 0) {
     331        device_printf(sc->alc_dev, "phy read timeout : %d\n", reg);
     332        return (0);
     333    }
     334
     335    return ((v & MDIO_DATA_MASK) >> MDIO_DATA_SHIFT);
     336}
     337
    264338static int
    265339alc_miibus_writereg(device_t dev, int phy, int reg, int val)
    266340{
    267341    struct alc_softc *sc;
    268     uint32_t v;
    269     int i;
     342    int v;
    270343
    271344    sc = device_get_softc(dev);
     345    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     346        v = alc_mii_writereg_816x(sc, phy, reg, val);
     347    else
     348        v = alc_mii_writereg_813x(sc, phy, reg, val);
     349    return (v);
     350}
     351
     352static uint32_t
     353alc_mii_writereg_813x(struct alc_softc *sc, int phy, int reg, int val)
     354{
     355    uint32_t v;
     356    int i;
    272357
    273358    CSR_WRITE_4(sc, ALC_MDIO, MDIO_OP_EXECUTE | MDIO_OP_WRITE |
    274359        (val & MDIO_DATA_MASK) << MDIO_DATA_SHIFT |
    alc_miibus_writereg(device_t dev, int phy, int reg, int val)  
    286371    return (0);
    287372}
    288373
     374static uint32_t
     375alc_mii_writereg_816x(struct alc_softc *sc, int phy, int reg, int val)
     376{
     377    uint32_t clk, v;
     378    int i;
     379
     380    if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
     381        clk = MDIO_CLK_25_128;
     382    else
     383        clk = MDIO_CLK_25_4;
     384    CSR_WRITE_4(sc, ALC_MDIO, MDIO_OP_EXECUTE | MDIO_OP_WRITE |
     385        ((val & MDIO_DATA_MASK) << MDIO_DATA_SHIFT) | MDIO_REG_ADDR(reg) |
     386        MDIO_SUP_PREAMBLE | clk);
     387    for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
     388        DELAY(5);
     389        v = CSR_READ_4(sc, ALC_MDIO);
     390        if ((v & MDIO_OP_BUSY) == 0)
     391            break;
     392    }
     393
     394    if (i == 0)
     395        device_printf(sc->alc_dev, "phy write timeout : %d\n", reg);
     396
     397    return (0);
     398}
     399
    289400static void
    290401alc_miibus_statchg(device_t dev)
    291402{
    alc_miibus_statchg(device_t dev)  
    318429            break;
    319430        }
    320431    }
    321     alc_stop_queue(sc);
    322432    /* Stop Rx/Tx MACs. */
    323433    alc_stop_mac(sc);
    324434
    alc_miibus_statchg(device_t dev)  
    330440        reg = CSR_READ_4(sc, ALC_MAC_CFG);
    331441        reg |= MAC_CFG_TX_ENB | MAC_CFG_RX_ENB;
    332442        CSR_WRITE_4(sc, ALC_MAC_CFG, reg);
    333         alc_aspm(sc, IFM_SUBTYPE(mii->mii_media_active));
     443    }
     444    alc_aspm(sc, 0, IFM_SUBTYPE(mii->mii_media_active));
     445    alc_dsp_fixup(sc, IFM_SUBTYPE(mii->mii_media_active));
     446}
     447
     448static uint32_t
     449alc_miidbg_readreg(struct alc_softc *sc, int reg)
     450{
     451
     452    alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
     453        reg);
     454    return (alc_miibus_readreg(sc->alc_dev, sc->alc_phyaddr,
     455        ALC_MII_DBG_DATA));
     456}
     457
     458static uint32_t
     459alc_miidbg_writereg(struct alc_softc *sc, int reg, int val)
     460{
     461
     462    alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr, ALC_MII_DBG_ADDR,
     463        reg);
     464    return (alc_miibus_writereg(sc->alc_dev, sc->alc_phyaddr,
     465        ALC_MII_DBG_DATA, val));
     466}
     467
     468static uint32_t
     469alc_miiext_readreg(struct alc_softc *sc, int devaddr, int reg)
     470{
     471    uint32_t clk, v;
     472    int i;
     473
     474    CSR_WRITE_4(sc, ALC_EXT_MDIO, EXT_MDIO_REG(reg) |
     475        EXT_MDIO_DEVADDR(devaddr));
     476    if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
     477        clk = MDIO_CLK_25_128;
     478    else
     479        clk = MDIO_CLK_25_4;
     480    CSR_WRITE_4(sc, ALC_MDIO, MDIO_OP_EXECUTE | MDIO_OP_READ |
     481        MDIO_SUP_PREAMBLE | clk | MDIO_MODE_EXT);
     482    for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
     483        DELAY(5);
     484        v = CSR_READ_4(sc, ALC_MDIO);
     485        if ((v & MDIO_OP_BUSY) == 0)
     486            break;
     487    }
     488
     489    if (i == 0) {
     490        device_printf(sc->alc_dev, "phy ext read timeout : %d, %d\n",
     491            devaddr, reg);
     492        return (0);
     493    }
     494
     495    return ((v & MDIO_DATA_MASK) >> MDIO_DATA_SHIFT);
     496}
     497
     498static uint32_t
     499alc_miiext_writereg(struct alc_softc *sc, int devaddr, int reg, int val)
     500{
     501    uint32_t clk, v;
     502    int i;
     503
     504    CSR_WRITE_4(sc, ALC_EXT_MDIO, EXT_MDIO_REG(reg) |
     505        EXT_MDIO_DEVADDR(devaddr));
     506    if ((sc->alc_flags & ALC_FLAG_LINK) != 0)
     507        clk = MDIO_CLK_25_128;
     508    else
     509        clk = MDIO_CLK_25_4;
     510    CSR_WRITE_4(sc, ALC_MDIO, MDIO_OP_EXECUTE | MDIO_OP_WRITE |
     511        ((val & MDIO_DATA_MASK) << MDIO_DATA_SHIFT) |
     512        MDIO_SUP_PREAMBLE | clk | MDIO_MODE_EXT);
     513    for (i = ALC_PHY_TIMEOUT; i > 0; i--) {
     514        DELAY(5);
     515        v = CSR_READ_4(sc, ALC_MDIO);
     516        if ((v & MDIO_OP_BUSY) == 0)
     517            break;
     518    }
     519
     520    if (i == 0)
     521        device_printf(sc->alc_dev, "phy ext write timeout : %d, %d\n",
     522            devaddr, reg);
     523
     524    return (0);
     525}
     526
     527static void
     528alc_dsp_fixup(struct alc_softc *sc, int media)
     529{
     530    uint16_t agc, len, val;
     531
     532    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     533        return;
     534    if (AR816X_REV(sc->alc_rev) >= AR816X_REV_C0)
     535        return;
     536
     537    /*
     538     * Vendor PHY magic.
     539     * 1000BT/AZ, wrong cable length
     540     */
     541    if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
     542        len = alc_miiext_readreg(sc, MII_EXT_PCS, MII_EXT_CLDCTL6);
     543        len = (len >> EXT_CLDCTL6_CAB_LEN_SHIFT) &
     544            EXT_CLDCTL6_CAB_LEN_MASK;
     545        agc = alc_miidbg_readreg(sc, MII_DBG_AGC);
     546        agc = (agc >> DBG_AGC_2_VGA_SHIFT) & DBG_AGC_2_VGA_MASK;
     547        if ((media == IFM_1000_T && len > EXT_CLDCTL6_CAB_LEN_SHORT1G &&
     548            agc > DBG_AGC_LONG1G_LIMT) ||
     549            (media == IFM_100_TX && len > DBG_AGC_LONG100M_LIMT &&
     550            agc > DBG_AGC_LONG1G_LIMT)) {
     551            alc_miidbg_writereg(sc, MII_DBG_AZ_ANADECT,
     552                DBG_AZ_ANADECT_LONG);
     553            val = alc_miiext_readreg(sc, MII_EXT_ANEG,
     554                MII_EXT_ANEG_AFE);
     555            val |= ANEG_AFEE_10BT_100M_TH;
     556            alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_AFE,
     557                val);
     558        } else {
     559            alc_miidbg_writereg(sc, MII_DBG_AZ_ANADECT,
     560                DBG_AZ_ANADECT_DEFAULT);
     561            val = alc_miiext_readreg(sc, MII_EXT_ANEG,
     562                MII_EXT_ANEG_AFE);
     563            val &= ~ANEG_AFEE_10BT_100M_TH;
     564            alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_AFE,
     565                val);
     566        }
     567        if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0 &&
     568            AR816X_REV(sc->alc_rev) == AR816X_REV_B0) {
     569            if (media == IFM_1000_T) {
     570                /*
     571                 * Giga link threshold, raise the tolerance of
     572                 * noise 50%.
     573                 */
     574                val = alc_miidbg_readreg(sc, MII_DBG_MSE20DB);
     575                val &= ~DBG_MSE20DB_TH_MASK;
     576                val |= (DBG_MSE20DB_TH_HI <<
     577                    DBG_MSE20DB_TH_SHIFT);
     578                alc_miidbg_writereg(sc, MII_DBG_MSE20DB, val);
     579            } else if (media == IFM_100_TX)
     580                alc_miidbg_writereg(sc, MII_DBG_MSE16DB,
     581                    DBG_MSE16DB_UP);
     582        }
     583    } else {
     584        val = alc_miiext_readreg(sc, MII_EXT_ANEG, MII_EXT_ANEG_AFE);
     585        val &= ~ANEG_AFEE_10BT_100M_TH;
     586        alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_AFE, val);
     587        if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0 &&
     588            AR816X_REV(sc->alc_rev) == AR816X_REV_B0) {
     589            alc_miidbg_writereg(sc, MII_DBG_MSE16DB,
     590                DBG_MSE16DB_DOWN);
     591            val = alc_miidbg_readreg(sc, MII_DBG_MSE20DB);
     592            val &= ~DBG_MSE20DB_TH_MASK;
     593            val |= (DBG_MSE20DB_TH_DEFAULT << DBG_MSE20DB_TH_SHIFT);
     594            alc_miidbg_writereg(sc, MII_DBG_MSE20DB, val);
     595        }
    334596    }
    335597}
    336598
    static int  
    358620alc_mediachange(struct ifnet *ifp)
    359621{
    360622    struct alc_softc *sc;
    361     struct mii_data *mii;
    362     struct mii_softc *miisc;
    363623    int error;
    364624
    365625    sc = ifp->if_softc;
    366626    ALC_LOCK(sc);
     627    error = alc_mediachange_locked(sc);
     628    ALC_UNLOCK(sc);
     629
     630    return (error);
     631}
     632
     633static int
     634alc_mediachange_locked(struct alc_softc *sc)
     635{
     636    struct mii_data *mii;
     637    struct mii_softc *miisc;
     638    int error;
     639
     640    ALC_LOCK_ASSERT(sc);
     641
    367642    mii = device_get_softc(sc->alc_miibus);
    368643    LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
    369644        PHY_RESET(miisc);
    370645    error = mii_mediachg(mii);
    371     ALC_UNLOCK(sc);
    372646
    373647    return (error);
    374648}
    alc_probe(device_t dev)  
    406680static void
    407681alc_get_macaddr(struct alc_softc *sc)
    408682{
    409     uint32_t ea[2], opt;
     683
     684    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     685        alc_get_macaddr_816x(sc);
     686    else
     687        alc_get_macaddr_813x(sc);
     688}
     689
     690static void
     691alc_get_macaddr_813x(struct alc_softc *sc)
     692{
     693    uint32_t opt;
    410694    uint16_t val;
    411695    int eeprom, i;
    412696
    alc_get_macaddr(struct alc_softc *sc)  
    501785        }
    502786    }
    503787
     788    alc_get_macaddr_par(sc);
     789}
     790
     791static void
     792alc_get_macaddr_816x(struct alc_softc *sc)
     793{
     794    uint32_t reg;
     795    int i, reloaded;
     796
     797    reloaded = 0;
     798    /* Try to reload station address via TWSI. */
     799    for (i = 100; i > 0; i--) {
     800        reg = CSR_READ_4(sc, ALC_SLD);
     801        if ((reg & (SLD_PROGRESS | SLD_START)) == 0)
     802            break;
     803        DELAY(1000);
     804    }
     805    if (i != 0) {
     806        CSR_WRITE_4(sc, ALC_SLD, reg | SLD_START);
     807        for (i = 100; i > 0; i--) {
     808            DELAY(1000);
     809            reg = CSR_READ_4(sc, ALC_SLD);
     810            if ((reg & SLD_START) == 0)
     811                break;
     812        }
     813        if (i != 0)
     814            reloaded++;
     815        else if (bootverbose)
     816            device_printf(sc->alc_dev,
     817                "reloading station address via TWSI timed out!\n");
     818    }
     819
     820    /* Try to reload station address from EEPROM or FLASH. */
     821    if (reloaded == 0) {
     822        reg = CSR_READ_4(sc, ALC_EEPROM_LD);
     823        if ((reg & (EEPROM_LD_EEPROM_EXIST |
     824            EEPROM_LD_FLASH_EXIST)) != 0) {
     825            for (i = 100; i > 0; i--) {
     826                reg = CSR_READ_4(sc, ALC_EEPROM_LD);
     827                if ((reg & (EEPROM_LD_PROGRESS |
     828                    EEPROM_LD_START)) == 0)
     829                    break;
     830                DELAY(1000);
     831            }
     832            if (i != 0) {
     833                CSR_WRITE_4(sc, ALC_EEPROM_LD, reg |
     834                    EEPROM_LD_START);
     835                for (i = 100; i > 0; i--) {
     836                    DELAY(1000);
     837                    reg = CSR_READ_4(sc, ALC_EEPROM_LD);
     838                    if ((reg & EEPROM_LD_START) == 0)
     839                        break;
     840                }
     841            } else if (bootverbose)
     842                device_printf(sc->alc_dev,
     843                    "reloading EEPROM/FLASH timed out!\n");
     844        }
     845    }
     846
     847    alc_get_macaddr_par(sc);
     848}
     849
     850static void
     851alc_get_macaddr_par(struct alc_softc *sc)
     852{
     853    uint32_t ea[2];
     854
    504855    ea[0] = CSR_READ_4(sc, ALC_PAR0);
    505856    ea[1] = CSR_READ_4(sc, ALC_PAR1);
    506857    sc->alc_eaddr[0] = (ea[1] >> 8) & 0xFF;
    alc_disable_l0s_l1(struct alc_softc *sc)  
    516867{
    517868    uint32_t pmcfg;
    518869
    519     /* Another magic from vendor. */
    520     pmcfg = CSR_READ_4(sc, ALC_PM_CFG);
    521     pmcfg &= ~(PM_CFG_L1_ENTRY_TIMER_MASK | PM_CFG_CLK_SWH_L1 |
    522         PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB | PM_CFG_MAC_ASPM_CHK |
    523         PM_CFG_SERDES_PD_EX_L1);
    524     pmcfg |= PM_CFG_SERDES_BUDS_RX_L1_ENB | PM_CFG_SERDES_PLL_L1_ENB |
    525         PM_CFG_SERDES_L1_ENB;
    526     CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
     870    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     871        /* Another magic from vendor. */
     872        pmcfg = CSR_READ_4(sc, ALC_PM_CFG);
     873        pmcfg &= ~(PM_CFG_L1_ENTRY_TIMER_MASK | PM_CFG_CLK_SWH_L1 |
     874            PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB |
     875            PM_CFG_MAC_ASPM_CHK | PM_CFG_SERDES_PD_EX_L1);
     876        pmcfg |= PM_CFG_SERDES_BUDS_RX_L1_ENB |
     877            PM_CFG_SERDES_PLL_L1_ENB | PM_CFG_SERDES_L1_ENB;
     878        CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
     879    }
    527880}
    528881
    529882static void
    530883alc_phy_reset(struct alc_softc *sc)
    531884{
     885
     886    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     887        alc_phy_reset_816x(sc);
     888    else
     889        alc_phy_reset_813x(sc);
     890}
     891
     892static void
     893alc_phy_reset_813x(struct alc_softc *sc)
     894{
    532895    uint16_t data;
    533896
    534897    /* Reset magic from Linux. */
    alc_phy_reset(struct alc_softc *sc)  
    6411004}
    6421005
    6431006static void
     1007alc_phy_reset_816x(struct alc_softc *sc)
     1008{
     1009    uint32_t val;
     1010
     1011    val = CSR_READ_4(sc, ALC_GPHY_CFG);
     1012    val &= ~(GPHY_CFG_EXT_RESET | GPHY_CFG_LED_MODE |
     1013        GPHY_CFG_GATE_25M_ENB | GPHY_CFG_PHY_IDDQ | GPHY_CFG_PHY_PLL_ON |
     1014        GPHY_CFG_PWDOWN_HW | GPHY_CFG_100AB_ENB);
     1015    val |= GPHY_CFG_SEL_ANA_RESET;
     1016#ifdef notyet
     1017    val |= GPHY_CFG_HIB_PULSE | GPHY_CFG_HIB_EN | GPHY_CFG_SEL_ANA_RESET;
     1018#else
     1019    /* Disable PHY hibernation. */
     1020    val &= ~(GPHY_CFG_HIB_PULSE | GPHY_CFG_HIB_EN);
     1021#endif
     1022    CSR_WRITE_4(sc, ALC_GPHY_CFG, val);
     1023    DELAY(10);
     1024    CSR_WRITE_4(sc, ALC_GPHY_CFG, val | GPHY_CFG_EXT_RESET);
     1025    DELAY(800);
     1026
     1027    /* Vendor PHY magic. */
     1028#ifdef notyet
     1029    alc_miidbg_writereg(sc, MII_DBG_LEGCYPS, DBG_LEGCYPS_DEFAULT);
     1030    alc_miidbg_writereg(sc, MII_DBG_SYSMODCTL, DBG_SYSMODCTL_DEFAULT);
     1031    alc_miiext_writereg(sc, MII_EXT_PCS, MII_EXT_VDRVBIAS,
     1032        EXT_VDRVBIAS_DEFAULT);
     1033#else
     1034    /* Disable PHY hibernation. */
     1035    alc_miidbg_writereg(sc, MII_DBG_LEGCYPS,
     1036        DBG_LEGCYPS_DEFAULT & ~DBG_LEGCYPS_ENB);
     1037    alc_miidbg_writereg(sc, MII_DBG_HIBNEG,
     1038        DBG_HIBNEG_DEFAULT & ~(DBG_HIBNEG_PSHIB_EN | DBG_HIBNEG_HIB_PULSE));
     1039    alc_miidbg_writereg(sc, MII_DBG_GREENCFG, DBG_GREENCFG_DEFAULT);
     1040#endif
     1041
     1042    /* XXX Disable EEE. */
     1043    val = CSR_READ_4(sc, ALC_LPI_CTL);
     1044    val &= ~LPI_CTL_ENB;
     1045    CSR_WRITE_4(sc, ALC_LPI_CTL, val);
     1046    alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_LOCAL_EEEADV, 0);
     1047
     1048    /* PHY power saving. */
     1049    alc_miidbg_writereg(sc, MII_DBG_TST10BTCFG, DBG_TST10BTCFG_DEFAULT);
     1050    alc_miidbg_writereg(sc, MII_DBG_SRDSYSMOD, DBG_SRDSYSMOD_DEFAULT);
     1051    alc_miidbg_writereg(sc, MII_DBG_TST100BTCFG, DBG_TST100BTCFG_DEFAULT);
     1052    alc_miidbg_writereg(sc, MII_DBG_ANACTL, DBG_ANACTL_DEFAULT);
     1053    val = alc_miidbg_readreg(sc, MII_DBG_GREENCFG2);
     1054    val &= ~DBG_GREENCFG2_GATE_DFSE_EN;
     1055    alc_miidbg_writereg(sc, MII_DBG_GREENCFG2, val);
     1056
     1057    /* RTL8139C, 120m issue. */
     1058    alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_NLP78,
     1059        ANEG_NLP78_120M_DEFAULT);
     1060    alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_S3DIG10,
     1061        ANEG_S3DIG10_DEFAULT);
     1062
     1063    if ((sc->alc_flags & ALC_FLAG_LINK_WAR) != 0) {
     1064        /* Turn off half amplitude. */
     1065        val = alc_miiext_readreg(sc, MII_EXT_PCS, MII_EXT_CLDCTL3);
     1066        val |= EXT_CLDCTL3_BP_CABLE1TH_DET_GT;
     1067        alc_miiext_writereg(sc, MII_EXT_PCS, MII_EXT_CLDCTL3, val);
     1068        /* Turn off Green feature. */
     1069        val = alc_miidbg_readreg(sc, MII_DBG_GREENCFG2);
     1070        val |= DBG_GREENCFG2_BP_GREEN;
     1071        alc_miidbg_writereg(sc, MII_DBG_GREENCFG2, val);
     1072        /* Turn off half bias. */
     1073        val = alc_miiext_readreg(sc, MII_EXT_PCS, MII_EXT_CLDCTL5);
     1074        val |= EXT_CLDCTL5_BP_VD_HLFBIAS;
     1075        alc_miiext_writereg(sc, MII_EXT_PCS, MII_EXT_CLDCTL5, val);
     1076    }
     1077}
     1078
     1079static void
    6441080alc_phy_down(struct alc_softc *sc)
    6451081{
     1082    uint32_t gphy;
    6461083
    6471084    switch (sc->alc_ident->deviceid) {
     1085    case DEVICEID_ATHEROS_AR8161:
     1086    case DEVICEID_ATHEROS_E2200:
     1087    case DEVICEID_ATHEROS_E2400:
     1088    case DEVICEID_ATHEROS_E2500:
     1089    case DEVICEID_ATHEROS_AR8162:
     1090    case DEVICEID_ATHEROS_AR8171:
     1091    case DEVICEID_ATHEROS_AR8172:
     1092        gphy = CSR_READ_4(sc, ALC_GPHY_CFG);
     1093        gphy &= ~(GPHY_CFG_EXT_RESET | GPHY_CFG_LED_MODE |
     1094            GPHY_CFG_100AB_ENB | GPHY_CFG_PHY_PLL_ON);
     1095        gphy |= GPHY_CFG_HIB_EN | GPHY_CFG_HIB_PULSE |
     1096            GPHY_CFG_SEL_ANA_RESET;
     1097        gphy |= GPHY_CFG_PHY_IDDQ | GPHY_CFG_PWDOWN_HW;
     1098        CSR_WRITE_4(sc, ALC_GPHY_CFG, gphy);
     1099        break;
    6481100    case DEVICEID_ATHEROS_AR8151:
    6491101    case DEVICEID_ATHEROS_AR8151_V2:
     1102    case DEVICEID_ATHEROS_AR8152_B:
     1103    case DEVICEID_ATHEROS_AR8152_B2:
    6501104        /*
    6511105         * GPHY power down caused more problems on AR8151 v2.0.
    6521106         * When driver is reloaded after GPHY power down,
    alc_phy_down(struct alc_softc *sc)  
    6721126}
    6731127
    6741128static void
    675 alc_aspm(struct alc_softc *sc, int media)
     1129alc_aspm(struct alc_softc *sc, int init, int media)
     1130{
     1131
     1132    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     1133        alc_aspm_816x(sc, init);
     1134    else
     1135        alc_aspm_813x(sc, media);
     1136}
     1137
     1138static void
     1139alc_aspm_813x(struct alc_softc *sc, int media)
    6761140{
    6771141    uint32_t pmcfg;
    6781142    uint16_t linkcfg;
    6791143
    680     ALC_LOCK_ASSERT(sc);
     1144    if ((sc->alc_flags & ALC_FLAG_LINK) == 0)
     1145        return;
    6811146
    6821147    pmcfg = CSR_READ_4(sc, ALC_PM_CFG);
    6831148    if ((sc->alc_flags & (ALC_FLAG_APS | ALC_FLAG_PCIE)) ==
    alc_aspm(struct alc_softc *sc, int media)  
    6941159
    6951160    if ((sc->alc_flags & ALC_FLAG_APS) != 0) {
    6961161        /* Disable extended sync except AR8152 B v1.0 */
    697         linkcfg &= ~0x80;
     1162        linkcfg &= ~PCIEM_LINK_CTL_EXTENDED_SYNC;
    6981163        if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B &&
    6991164            sc->alc_rev == ATHEROS_AR8152_B_V10)
    700             linkcfg |= 0x80;
     1165            linkcfg |= PCIEM_LINK_CTL_EXTENDED_SYNC;
    7011166        CSR_WRITE_2(sc, sc->alc_expcap + PCIER_LINK_CTL,
    7021167            linkcfg);
    7031168        pmcfg &= ~(PM_CFG_EN_BUFS_RX_L0S | PM_CFG_SA_DLY_ENB |
    alc_aspm(struct alc_softc *sc, int media)  
    7581223    CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
    7591224}
    7601225
    761 static int
    762 alc_attach(device_t dev)
     1226static void
     1227alc_aspm_816x(struct alc_softc *sc, int init)
    7631228{
    764     struct alc_softc *sc;
    765     struct ifnet *ifp;
    766     char *aspm_state[] = { "L0s/L1", "L0s", "L1", "L0s/L1" };
    767     uint16_t burst;
    768     int base, error, i, msic, msixc, state;
    769     uint32_t cap, ctl, val;
    770 
    771     error = 0;
    772     sc = device_get_softc(dev);
    773     sc->alc_dev = dev;
    774 
    775     mtx_init(&sc->alc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
    776         MTX_DEF);
    777     callout_init_mtx(&sc->alc_tick_ch, &sc->alc_mtx, 0);
    778     TASK_INIT(&sc->alc_int_task, 0, alc_int_task, sc);
    779     sc->alc_ident = alc_find_ident(dev);
     1229    uint32_t pmcfg;
    7801230
    781     /* Map the device. */
    782     pci_enable_busmaster(dev);
    783     sc->alc_res_spec = alc_res_spec_mem;
    784     sc->alc_irq_spec = alc_irq_spec_legacy;
    785     error = bus_alloc_resources(dev, sc->alc_res_spec, sc->alc_res);
    786     if (error != 0) {
    787         device_printf(dev, "cannot allocate memory resources.\n");
    788         goto fail;
     1231    pmcfg = CSR_READ_4(sc, ALC_PM_CFG);
     1232    pmcfg &= ~PM_CFG_L1_ENTRY_TIMER_816X_MASK;
     1233    pmcfg |= PM_CFG_L1_ENTRY_TIMER_816X_DEFAULT;
     1234    pmcfg &= ~PM_CFG_PM_REQ_TIMER_MASK;
     1235    pmcfg |= PM_CFG_PM_REQ_TIMER_816X_DEFAULT;
     1236    pmcfg &= ~PM_CFG_LCKDET_TIMER_MASK;
     1237    pmcfg |= PM_CFG_LCKDET_TIMER_DEFAULT;
     1238    pmcfg |= PM_CFG_SERDES_PD_EX_L1 | PM_CFG_CLK_SWH_L1 | PM_CFG_PCIE_RECV;
     1239    pmcfg &= ~(PM_CFG_RX_L1_AFTER_L0S | PM_CFG_TX_L1_AFTER_L0S |
     1240        PM_CFG_ASPM_L1_ENB | PM_CFG_ASPM_L0S_ENB |
     1241        PM_CFG_SERDES_L1_ENB | PM_CFG_SERDES_PLL_L1_ENB |
     1242        PM_CFG_SERDES_BUDS_RX_L1_ENB | PM_CFG_SA_DLY_ENB |
     1243        PM_CFG_MAC_ASPM_CHK | PM_CFG_HOTRST);
     1244    if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
     1245        (sc->alc_rev & 0x01) != 0)
     1246        pmcfg |= PM_CFG_SERDES_L1_ENB | PM_CFG_SERDES_PLL_L1_ENB;
     1247    if ((sc->alc_flags & ALC_FLAG_LINK) != 0) {
     1248        /* Link up, enable both L0s, L1s. */
     1249        pmcfg |= PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB |
     1250            PM_CFG_MAC_ASPM_CHK;
     1251    } else {
     1252        if (init != 0)
     1253            pmcfg |= PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB |
     1254                PM_CFG_MAC_ASPM_CHK;
     1255        else if ((sc->alc_ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
     1256            pmcfg |= PM_CFG_ASPM_L1_ENB | PM_CFG_MAC_ASPM_CHK;
    7891257    }
     1258    CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
     1259}
    7901260
    791     /* Set PHY address. */
    792     sc->alc_phyaddr = ALC_PHY_ADDR;
     1261static void
     1262alc_init_pcie(struct alc_softc *sc)
     1263{
     1264    const char *aspm_state[] = { "L0s/L1", "L0s", "L1", "L0s/L1" };
     1265    uint32_t cap, ctl, val;
     1266    int state;
    7931267
    794     /* Initialize DMA parameters. */
    795     sc->alc_dma_rd_burst = 0;
    796     sc->alc_dma_wr_burst = 0;
    797     sc->alc_rcb = DMA_CFG_RCB_64;
    798     if (pci_find_cap(dev, PCIY_EXPRESS, &base) == 0) {
    799         sc->alc_flags |= ALC_FLAG_PCIE;
    800         sc->alc_expcap = base;
    801         burst = CSR_READ_2(sc, base + PCIER_DEVICE_CTL);
    802         sc->alc_dma_rd_burst =
    803             (burst & PCIEM_CTL_MAX_READ_REQUEST) >> 12;
    804         sc->alc_dma_wr_burst = (burst & PCIEM_CTL_MAX_PAYLOAD) >> 5;
    805         if (bootverbose) {
    806             device_printf(dev, "Read request size : %u bytes.\n",
    807                 alc_dma_burst[sc->alc_dma_rd_burst]);
    808             device_printf(dev, "TLP payload size : %u bytes.\n",
    809                 alc_dma_burst[sc->alc_dma_wr_burst]);
    810         }
    811         if (alc_dma_burst[sc->alc_dma_rd_burst] > 1024)
    812             sc->alc_dma_rd_burst = 3;
    813         if (alc_dma_burst[sc->alc_dma_wr_burst] > 1024)
    814             sc->alc_dma_wr_burst = 3;
    815         /* Clear data link and flow-control protocol error. */
    816         val = CSR_READ_4(sc, ALC_PEX_UNC_ERR_SEV);
    817         val &= ~(PEX_UNC_ERR_SEV_DLP | PEX_UNC_ERR_SEV_FCP);
    818         CSR_WRITE_4(sc, ALC_PEX_UNC_ERR_SEV, val);
     1268    /* Clear data link and flow-control protocol error. */
     1269    val = CSR_READ_4(sc, ALC_PEX_UNC_ERR_SEV);
     1270    val &= ~(PEX_UNC_ERR_SEV_DLP | PEX_UNC_ERR_SEV_FCP);
     1271    CSR_WRITE_4(sc, ALC_PEX_UNC_ERR_SEV, val);
     1272
     1273    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
    8191274        CSR_WRITE_4(sc, ALC_LTSSM_ID_CFG,
    8201275            CSR_READ_4(sc, ALC_LTSSM_ID_CFG) & ~LTSSM_ID_WRO_ENB);
    8211276        CSR_WRITE_4(sc, ALC_PCIE_PHYMISC,
    8221277            CSR_READ_4(sc, ALC_PCIE_PHYMISC) |
    8231278            PCIE_PHYMISC_FORCE_RCV_DET);
    8241279        if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B &&
    825             pci_get_revid(dev) == ATHEROS_AR8152_B_V10) {
     1280            sc->alc_rev == ATHEROS_AR8152_B_V10) {
    8261281            val = CSR_READ_4(sc, ALC_PCIE_PHYMISC2);
    8271282            val &= ~(PCIE_PHYMISC2_SERDES_CDR_MASK |
    8281283                PCIE_PHYMISC2_SERDES_TH_MASK);
    alc_attach(device_t dev)  
    8311286            CSR_WRITE_4(sc, ALC_PCIE_PHYMISC2, val);
    8321287        }
    8331288        /* Disable ASPM L0S and L1. */
    834         cap = CSR_READ_2(sc, base + PCIER_LINK_CAP);
     1289        cap = CSR_READ_2(sc, sc->alc_expcap + PCIER_LINK_CAP);
    8351290        if ((cap & PCIEM_LINK_CAP_ASPM) != 0) {
    836             ctl = CSR_READ_2(sc, base + PCIER_LINK_CTL);
    837             if ((ctl & 0x08) != 0)
     1291            ctl = CSR_READ_2(sc, sc->alc_expcap + PCIER_LINK_CTL);
     1292            if ((ctl & PCIEM_LINK_CTL_RCB) != 0)
    8381293                sc->alc_rcb = DMA_CFG_RCB_128;
    8391294            if (bootverbose)
    840                 device_printf(dev, "RCB %u bytes\n",
     1295                device_printf(sc->alc_dev, "RCB %u bytes\n",
    8411296                    sc->alc_rcb == DMA_CFG_RCB_64 ? 64 : 128);
    842             state = ctl & 0x03;
    843             if (state & 0x01)
     1297            state = ctl & PCIEM_LINK_CTL_ASPMC;
     1298            if (state & PCIEM_LINK_CTL_ASPMC_L0S)
    8441299                sc->alc_flags |= ALC_FLAG_L0S;
    845             if (state & 0x02)
     1300            if (state & PCIEM_LINK_CTL_ASPMC_L1)
    8461301                sc->alc_flags |= ALC_FLAG_L1S;
    8471302            if (bootverbose)
    8481303                device_printf(sc->alc_dev, "ASPM %s %s\n",
    alc_attach(device_t dev)  
    8541309                device_printf(sc->alc_dev,
    8551310                    "no ASPM support\n");
    8561311        }
     1312    } else {
     1313        val = CSR_READ_4(sc, ALC_PDLL_TRNS1);
     1314        val &= ~PDLL_TRNS1_D3PLLOFF_ENB;
     1315        CSR_WRITE_4(sc, ALC_PDLL_TRNS1, val);
     1316        val = CSR_READ_4(sc, ALC_MASTER_CFG);
     1317        if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
     1318            (sc->alc_rev & 0x01) != 0) {
     1319            if ((val & MASTER_WAKEN_25M) == 0 ||
     1320                (val & MASTER_CLK_SEL_DIS) == 0) {
     1321                val |= MASTER_WAKEN_25M | MASTER_CLK_SEL_DIS;
     1322                CSR_WRITE_4(sc, ALC_MASTER_CFG, val);
     1323            }
     1324        } else {
     1325            if ((val & MASTER_WAKEN_25M) == 0 ||
     1326                (val & MASTER_CLK_SEL_DIS) != 0) {
     1327                val |= MASTER_WAKEN_25M;
     1328                val &= ~MASTER_CLK_SEL_DIS;
     1329                CSR_WRITE_4(sc, ALC_MASTER_CFG, val);
     1330            }
     1331        }
    8571332    }
     1333    alc_aspm(sc, 1, IFM_UNKNOWN);
     1334}
    8581335
    859     /* Reset PHY. */
    860     alc_phy_reset(sc);
     1336static void
     1337alc_config_msi(struct alc_softc *sc)
     1338{
     1339    uint32_t ctl, mod;
    8611340
    862     /* Reset the ethernet controller. */
    863     alc_reset(sc);
     1341    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     1342        /*
     1343         * It seems interrupt moderation is controlled by
     1344         * ALC_MSI_RETRANS_TIMER register if MSI/MSIX is active.
     1345         * Driver uses RX interrupt moderation parameter to
     1346         * program ALC_MSI_RETRANS_TIMER register.
     1347         */
     1348        ctl = CSR_READ_4(sc, ALC_MSI_RETRANS_TIMER);
     1349        ctl &= ~MSI_RETRANS_TIMER_MASK;
     1350        ctl &= ~MSI_RETRANS_MASK_SEL_LINE;
     1351        mod = ALC_USECS(sc->alc_int_rx_mod);
     1352        if (mod == 0)
     1353            mod = 1;
     1354        ctl |= mod;
     1355        if ((sc->alc_flags & ALC_FLAG_MSIX) != 0)
     1356            CSR_WRITE_4(sc, ALC_MSI_RETRANS_TIMER, ctl |
     1357                MSI_RETRANS_MASK_SEL_STD);
     1358        else if ((sc->alc_flags & ALC_FLAG_MSI) != 0)
     1359            CSR_WRITE_4(sc, ALC_MSI_RETRANS_TIMER, ctl |
     1360                MSI_RETRANS_MASK_SEL_LINE);
     1361        else
     1362            CSR_WRITE_4(sc, ALC_MSI_RETRANS_TIMER, 0);
     1363    }
     1364}
     1365
     1366static int
     1367alc_attach(device_t dev)
     1368{
     1369    struct alc_softc *sc;
     1370    struct ifnet *ifp;
     1371    int base, error, i, msic, msixc;
     1372    uint16_t burst;
     1373
     1374    error = 0;
     1375    sc = device_get_softc(dev);
     1376    sc->alc_dev = dev;
     1377    sc->alc_rev = pci_get_revid(dev);
     1378
     1379    mtx_init(&sc->alc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
     1380        MTX_DEF);
     1381    callout_init_mtx(&sc->alc_tick_ch, &sc->alc_mtx, 0);
     1382    TASK_INIT(&sc->alc_int_task, 0, alc_int_task, sc);
     1383    sc->alc_ident = alc_find_ident(dev);
     1384
     1385    /* Map the device. */
     1386    pci_enable_busmaster(dev);
     1387    sc->alc_res_spec = alc_res_spec_mem;
     1388    sc->alc_irq_spec = alc_irq_spec_legacy;
     1389    error = bus_alloc_resources(dev, sc->alc_res_spec, sc->alc_res);
     1390    if (error != 0) {
     1391        device_printf(dev, "cannot allocate memory resources.\n");
     1392        goto fail;
     1393    }
     1394
     1395    /* Set PHY address. */
     1396    sc->alc_phyaddr = ALC_PHY_ADDR;
    8641397
    8651398    /*
    8661399     * One odd thing is AR8132 uses the same PHY hardware(F1
    alc_attach(device_t dev)  
    8701403     * shows the same PHY model/revision number of AR8131.
    8711404     */
    8721405    switch (sc->alc_ident->deviceid) {
     1406    case DEVICEID_ATHEROS_E2200:
     1407    case DEVICEID_ATHEROS_E2400:
     1408    case DEVICEID_ATHEROS_E2500:
     1409        sc->alc_flags |= ALC_FLAG_E2X00;
     1410        /* FALLTHROUGH */
     1411    case DEVICEID_ATHEROS_AR8161:
     1412        if (pci_get_subvendor(dev) == VENDORID_ATHEROS &&
     1413            pci_get_subdevice(dev) == 0x0091 && sc->alc_rev == 0)
     1414            sc->alc_flags |= ALC_FLAG_LINK_WAR;
     1415        /* FALLTHROUGH */
     1416    case DEVICEID_ATHEROS_AR8171:
     1417        sc->alc_flags |= ALC_FLAG_AR816X_FAMILY;
     1418        break;
     1419    case DEVICEID_ATHEROS_AR8162:
     1420    case DEVICEID_ATHEROS_AR8172:
     1421        sc->alc_flags |= ALC_FLAG_FASTETHER | ALC_FLAG_AR816X_FAMILY;
     1422        break;
    8731423    case DEVICEID_ATHEROS_AR8152_B:
    8741424    case DEVICEID_ATHEROS_AR8152_B2:
    8751425        sc->alc_flags |= ALC_FLAG_APS;
    alc_attach(device_t dev)  
    8841434    default:
    8851435        break;
    8861436    }
    887     sc->alc_flags |= ALC_FLAG_ASPM_MON | ALC_FLAG_JUMBO;
     1437    sc->alc_flags |= ALC_FLAG_JUMBO;
    8881438
    8891439    /*
    8901440     * It seems that AR813x/AR815x has silicon bug for SMB. In
    alc_attach(device_t dev)  
    8971447     * Don't use Tx CMB. It is known to have silicon bug.
    8981448     */
    8991449    sc->alc_flags |= ALC_FLAG_CMB_BUG;
    900     sc->alc_rev = pci_get_revid(dev);
    9011450    sc->alc_chip_rev = CSR_READ_4(sc, ALC_MASTER_CFG) >>
    9021451        MASTER_CHIP_REV_SHIFT;
    9031452    if (bootverbose) {
    alc_attach(device_t dev)  
    9051454            sc->alc_rev);
    9061455        device_printf(dev, "Chip id/revision : 0x%04x\n",
    9071456            sc->alc_chip_rev);
     1457        if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     1458            device_printf(dev, "AR816x revision : 0x%x\n",
     1459                AR816X_REV(sc->alc_rev));
    9081460    }
    9091461    device_printf(dev, "%u Tx FIFO, %u Rx FIFO\n",
    9101462        CSR_READ_4(sc, ALC_SRAM_TX_FIFO_LEN) * 8,
    9111463        CSR_READ_4(sc, ALC_SRAM_RX_FIFO_LEN) * 8);
    9121464
     1465    /* Initialize DMA parameters. */
     1466    sc->alc_dma_rd_burst = 0;
     1467    sc->alc_dma_wr_burst = 0;
     1468    sc->alc_rcb = DMA_CFG_RCB_64;
     1469    if (pci_find_cap(dev, PCIY_EXPRESS, &base) == 0) {
     1470        sc->alc_flags |= ALC_FLAG_PCIE;
     1471        sc->alc_expcap = base;
     1472        burst = CSR_READ_2(sc, base + PCIER_DEVICE_CTL);
     1473        sc->alc_dma_rd_burst =
     1474            (burst & PCIEM_CTL_MAX_READ_REQUEST) >> 12;
     1475        sc->alc_dma_wr_burst = (burst & PCIEM_CTL_MAX_PAYLOAD) >> 5;
     1476        if (bootverbose) {
     1477            device_printf(dev, "Read request size : %u bytes.\n",
     1478                alc_dma_burst[sc->alc_dma_rd_burst]);
     1479            device_printf(dev, "TLP payload size : %u bytes.\n",
     1480                alc_dma_burst[sc->alc_dma_wr_burst]);
     1481        }
     1482        if (alc_dma_burst[sc->alc_dma_rd_burst] > 1024)
     1483            sc->alc_dma_rd_burst = 3;
     1484        if (alc_dma_burst[sc->alc_dma_wr_burst] > 1024)
     1485            sc->alc_dma_wr_burst = 3;
     1486
     1487        /*
     1488         * Force maximum payload size to 128 bytes for
     1489         * E2200/E2400/E2500.
     1490         * Otherwise it triggers DMA write error.
     1491         */
     1492        if ((sc->alc_flags & ALC_FLAG_E2X00) != 0)
     1493            sc->alc_dma_wr_burst = 0;
     1494        alc_init_pcie(sc);
     1495    }
     1496
     1497    /* Reset PHY. */
     1498    alc_phy_reset(sc);
     1499
     1500    /* Reset the ethernet controller. */
     1501    alc_stop_mac(sc);
     1502    alc_reset(sc);
     1503
    9131504    /* Allocate IRQ resources. */
    9141505    msixc = pci_msix_count(dev);
    9151506    msic = pci_msi_count(dev);
    alc_attach(device_t dev)  
    9171508        device_printf(dev, "MSIX count : %d\n", msixc);
    9181509        device_printf(dev, "MSI count : %d\n", msic);
    9191510    }
    920     /* Prefer MSIX over MSI. */
     1511    if (msixc > 1)
     1512        msixc = 1;
     1513    if (msic > 1)
     1514        msic = 1;
     1515    /*
     1516     * Prefer MSIX over MSI.
     1517     * AR816x controller has a silicon bug that MSI interrupt
     1518     * does not assert if PCIM_CMD_INTxDIS bit of command
     1519     * register is set.  pci(4) was taught to handle that case.
     1520     */
    9211521    if (msix_disable == 0 || msi_disable == 0) {
    922         if (msix_disable == 0 && msixc == ALC_MSIX_MESSAGES &&
     1522        if (msix_disable == 0 && msixc > 0 &&
    9231523            pci_alloc_msix(dev, &msixc) == 0) {
    924             if (msic == ALC_MSIX_MESSAGES) {
     1524            if (msic == 1) {
    9251525                device_printf(dev,
    9261526                    "Using %d MSIX message(s).\n", msixc);
    9271527                sc->alc_flags |= ALC_FLAG_MSIX;
    alc_attach(device_t dev)  
    9301530                pci_release_msi(dev);
    9311531        }
    9321532        if (msi_disable == 0 && (sc->alc_flags & ALC_FLAG_MSIX) == 0 &&
    933             msic == ALC_MSI_MESSAGES &&
    934             pci_alloc_msi(dev, &msic) == 0) {
    935             if (msic == ALC_MSI_MESSAGES) {
     1533            msic > 0 && pci_alloc_msi(dev, &msic) == 0) {
     1534            if (msic == 1) {
    9361535                device_printf(dev,
    9371536                    "Using %d MSI message(s).\n", msic);
    9381537                sc->alc_flags |= ALC_FLAG_MSI;
    alc_attach(device_t dev)  
    9511550    /* Create device sysctl node. */
    9521551    alc_sysctl_node(sc);
    9531552
    954     if ((error = alc_dma_alloc(sc) != 0))
     1553    if ((error = alc_dma_alloc(sc)) != 0)
    9551554        goto fail;
    9561555
    9571556    /* Load station address. */
    alc_attach(device_t dev)  
    10061605     * sample boards. To safety, don't enable Tx checksum offloading
    10071606     * by default but give chance to users to toggle it if they know
    10081607     * their controllers work without problems.
     1608     * Fortunately, Tx checksum offloading for AR816x family
     1609     * seems to work.
    10091610     */
    1010     ifp->if_capenable &= ~IFCAP_TXCSUM;
    1011     ifp->if_hwassist &= ~ALC_CSUM_FEATURES;
     1611    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     1612        ifp->if_capenable &= ~IFCAP_TXCSUM;
     1613        ifp->if_hwassist &= ~ALC_CSUM_FEATURES;
     1614    }
    10121615
    10131616    /* Tell the upper layer(s) we support long frames. */
    1014     ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
     1617    ifp->if_hdrlen = sizeof(struct ether_vlan_header);
    10151618
    10161619    /* Create local taskq. */
    10171620    sc->alc_tq = taskqueue_create_fast("alc_taskq", M_WAITOK,
    alc_attach(device_t dev)  
    10251628    taskqueue_start_threads(&sc->alc_tq, 1, PI_NET, "%s taskq",
    10261629        device_get_nameunit(sc->alc_dev));
    10271630
     1631    alc_config_msi(sc);
    10281632    if ((sc->alc_flags & ALC_FLAG_MSIX) != 0)
    10291633        msic = ALC_MSIX_MESSAGES;
    10301634    else if ((sc->alc_flags & ALC_FLAG_MSI) != 0)
    alc_sysctl_node(struct alc_softc *sc)  
    12861890        &stats->tx_late_colls, "Late collisions");
    12871891    ALC_SYSCTL_STAT_ADD32(ctx, child, "excess_colls",
    12881892        &stats->tx_excess_colls, "Excessive collisions");
    1289     ALC_SYSCTL_STAT_ADD32(ctx, child, "abort",
    1290         &stats->tx_abort, "Aborted frames due to Excessive collisions");
    12911893    ALC_SYSCTL_STAT_ADD32(ctx, child, "underruns",
    12921894        &stats->tx_underrun, "FIFO underruns");
    12931895    ALC_SYSCTL_STAT_ADD32(ctx, child, "desc_underruns",
    again:  
    15992201
    16002202    /*
    16012203     * Create Tx buffer parent tag.
    1602      * AR813x/AR815x allows 64bit DMA addressing of Tx/Rx buffers
     2204     * AR81[3567]x allows 64bit DMA addressing of Tx/Rx buffers
    16032205     * so it needs separate parent DMA tag as parent DMA address
    16042206     * space could be restricted to be within 32bit address space
    16052207     * by 4GB boundary crossing.
    alc_dma_free(struct alc_softc *sc)  
    17342336    }
    17352337    /* Tx descriptor ring. */
    17362338    if (sc->alc_cdata.alc_tx_ring_tag != NULL) {
    1737         if (sc->alc_cdata.alc_tx_ring_map != NULL)
     2339        if (sc->alc_rdata.alc_tx_ring_paddr != 0)
    17382340            bus_dmamap_unload(sc->alc_cdata.alc_tx_ring_tag,
    17392341                sc->alc_cdata.alc_tx_ring_map);
    1740         if (sc->alc_cdata.alc_tx_ring_map != NULL &&
    1741             sc->alc_rdata.alc_tx_ring != NULL)
     2342        if (sc->alc_rdata.alc_tx_ring != NULL)
    17422343            bus_dmamem_free(sc->alc_cdata.alc_tx_ring_tag,
    17432344                sc->alc_rdata.alc_tx_ring,
    17442345                sc->alc_cdata.alc_tx_ring_map);
     2346        sc->alc_rdata.alc_tx_ring_paddr = 0;
    17452347        sc->alc_rdata.alc_tx_ring = NULL;
    1746         sc->alc_cdata.alc_tx_ring_map = NULL;
    17472348        bus_dma_tag_destroy(sc->alc_cdata.alc_tx_ring_tag);
    17482349        sc->alc_cdata.alc_tx_ring_tag = NULL;
    17492350    }
    17502351    /* Rx ring. */
    17512352    if (sc->alc_cdata.alc_rx_ring_tag != NULL) {
    1752         if (sc->alc_cdata.alc_rx_ring_map != NULL)
     2353        if (sc->alc_rdata.alc_rx_ring_paddr != 0)
    17532354            bus_dmamap_unload(sc->alc_cdata.alc_rx_ring_tag,
    17542355                sc->alc_cdata.alc_rx_ring_map);
    1755         if (sc->alc_cdata.alc_rx_ring_map != NULL &&
    1756             sc->alc_rdata.alc_rx_ring != NULL)
     2356        if (sc->alc_rdata.alc_rx_ring != NULL)
    17572357            bus_dmamem_free(sc->alc_cdata.alc_rx_ring_tag,
    17582358                sc->alc_rdata.alc_rx_ring,
    17592359                sc->alc_cdata.alc_rx_ring_map);
     2360        sc->alc_rdata.alc_rx_ring_paddr = 0;
    17602361        sc->alc_rdata.alc_rx_ring = NULL;
    1761         sc->alc_cdata.alc_rx_ring_map = NULL;
    17622362        bus_dma_tag_destroy(sc->alc_cdata.alc_rx_ring_tag);
    17632363        sc->alc_cdata.alc_rx_ring_tag = NULL;
    17642364    }
    17652365    /* Rx return ring. */
    17662366    if (sc->alc_cdata.alc_rr_ring_tag != NULL) {
    1767         if (sc->alc_cdata.alc_rr_ring_map != NULL)
     2367        if (sc->alc_rdata.alc_rr_ring_paddr != 0)
    17682368            bus_dmamap_unload(sc->alc_cdata.alc_rr_ring_tag,
    17692369                sc->alc_cdata.alc_rr_ring_map);
    1770         if (sc->alc_cdata.alc_rr_ring_map != NULL &&
    1771             sc->alc_rdata.alc_rr_ring != NULL)
     2370        if (sc->alc_rdata.alc_rr_ring != NULL)
    17722371            bus_dmamem_free(sc->alc_cdata.alc_rr_ring_tag,
    17732372                sc->alc_rdata.alc_rr_ring,
    17742373                sc->alc_cdata.alc_rr_ring_map);
     2374        sc->alc_rdata.alc_rr_ring_paddr = 0;
    17752375        sc->alc_rdata.alc_rr_ring = NULL;
    1776         sc->alc_cdata.alc_rr_ring_map = NULL;
    17772376        bus_dma_tag_destroy(sc->alc_cdata.alc_rr_ring_tag);
    17782377        sc->alc_cdata.alc_rr_ring_tag = NULL;
    17792378    }
    17802379    /* CMB block */
    17812380    if (sc->alc_cdata.alc_cmb_tag != NULL) {
    1782         if (sc->alc_cdata.alc_cmb_map != NULL)
     2381        if (sc->alc_rdata.alc_cmb_paddr != 0)
    17832382            bus_dmamap_unload(sc->alc_cdata.alc_cmb_tag,
    17842383                sc->alc_cdata.alc_cmb_map);
    1785         if (sc->alc_cdata.alc_cmb_map != NULL &&
    1786             sc->alc_rdata.alc_cmb != NULL)
     2384        if (sc->alc_rdata.alc_cmb != NULL)
    17872385            bus_dmamem_free(sc->alc_cdata.alc_cmb_tag,
    17882386                sc->alc_rdata.alc_cmb,
    1789                 sc->alc_cdata.alc_cmb_map);
     2387                sc->alc_cdata.alc_cmb_map);     
     2388        sc->alc_rdata.alc_cmb_paddr = 0;
    17902389        sc->alc_rdata.alc_cmb = NULL;
    1791         sc->alc_cdata.alc_cmb_map = NULL;
    17922390        bus_dma_tag_destroy(sc->alc_cdata.alc_cmb_tag);
    17932391        sc->alc_cdata.alc_cmb_tag = NULL;
    17942392    }
    17952393    /* SMB block */
    17962394    if (sc->alc_cdata.alc_smb_tag != NULL) {
    1797         if (sc->alc_cdata.alc_smb_map != NULL)
     2395        if (sc->alc_rdata.alc_smb_paddr != 0)
    17982396            bus_dmamap_unload(sc->alc_cdata.alc_smb_tag,
    17992397                sc->alc_cdata.alc_smb_map);
    1800         if (sc->alc_cdata.alc_smb_map != NULL &&
    1801             sc->alc_rdata.alc_smb != NULL)
     2398        if (sc->alc_rdata.alc_smb != NULL)
    18022399            bus_dmamem_free(sc->alc_cdata.alc_smb_tag,
    18032400                sc->alc_rdata.alc_smb,
    18042401                sc->alc_cdata.alc_smb_map);
     2402        sc->alc_rdata.alc_smb_paddr = 0;
    18052403        sc->alc_rdata.alc_smb = NULL;
    1806         sc->alc_cdata.alc_smb_map = NULL;
    18072404        bus_dma_tag_destroy(sc->alc_cdata.alc_smb_tag);
    18082405        sc->alc_cdata.alc_smb_tag = NULL;
    18092406    }
    alc_setlinkspeed(struct alc_softc *sc)  
    19062503static void
    19072504alc_setwol(struct alc_softc *sc)
    19082505{
     2506
     2507    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     2508        alc_setwol_816x(sc);
     2509    else
     2510        alc_setwol_813x(sc);
     2511}
     2512
     2513static void
     2514alc_setwol_813x(struct alc_softc *sc)
     2515{
    19092516    struct ifnet *ifp;
    19102517    uint32_t reg, pmcs;
    19112518    uint16_t pmstat;
    alc_setwol(struct alc_softc *sc)  
    19662573        sc->alc_pmcap + PCIR_POWER_STATUS, pmstat, 2);
    19672574}
    19682575
     2576static void
     2577alc_setwol_816x(struct alc_softc *sc)
     2578{
     2579    struct ifnet *ifp;
     2580    uint32_t gphy, mac, master, pmcs, reg;
     2581    uint16_t pmstat;
     2582
     2583    ALC_LOCK_ASSERT(sc);
     2584
     2585    ifp = sc->alc_ifp;
     2586    master = CSR_READ_4(sc, ALC_MASTER_CFG);
     2587    master &= ~MASTER_CLK_SEL_DIS;
     2588    gphy = CSR_READ_4(sc, ALC_GPHY_CFG);
     2589    gphy &= ~(GPHY_CFG_EXT_RESET | GPHY_CFG_LED_MODE | GPHY_CFG_100AB_ENB |
     2590        GPHY_CFG_PHY_PLL_ON);
     2591    gphy |= GPHY_CFG_HIB_EN | GPHY_CFG_HIB_PULSE | GPHY_CFG_SEL_ANA_RESET;
     2592    if ((sc->alc_flags & ALC_FLAG_PM) == 0) {
     2593        CSR_WRITE_4(sc, ALC_WOL_CFG, 0);
     2594        gphy |= GPHY_CFG_PHY_IDDQ | GPHY_CFG_PWDOWN_HW;
     2595        mac = CSR_READ_4(sc, ALC_MAC_CFG);
     2596    } else {
     2597        if ((ifp->if_capenable & IFCAP_WOL) != 0) {
     2598            gphy |= GPHY_CFG_EXT_RESET;
     2599            if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0)
     2600                alc_setlinkspeed(sc);
     2601        }
     2602        pmcs = 0;
     2603        if ((ifp->if_capenable & IFCAP_WOL_MAGIC) != 0)
     2604            pmcs |= WOL_CFG_MAGIC | WOL_CFG_MAGIC_ENB;
     2605        CSR_WRITE_4(sc, ALC_WOL_CFG, pmcs);
     2606        mac = CSR_READ_4(sc, ALC_MAC_CFG);
     2607        mac &= ~(MAC_CFG_DBG | MAC_CFG_PROMISC | MAC_CFG_ALLMULTI |
     2608            MAC_CFG_BCAST);
     2609        if ((ifp->if_capenable & IFCAP_WOL_MCAST) != 0)
     2610            mac |= MAC_CFG_ALLMULTI | MAC_CFG_BCAST;
     2611        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     2612            mac |= MAC_CFG_RX_ENB;
     2613        alc_miiext_writereg(sc, MII_EXT_ANEG, MII_EXT_ANEG_S3DIG10,
     2614            ANEG_S3DIG10_SL);
     2615    }
     2616
     2617    /* Enable OSC. */
     2618    reg = CSR_READ_4(sc, ALC_MISC);
     2619    reg &= ~MISC_INTNLOSC_OPEN;
     2620    CSR_WRITE_4(sc, ALC_MISC, reg);
     2621    reg |= MISC_INTNLOSC_OPEN;
     2622    CSR_WRITE_4(sc, ALC_MISC, reg);
     2623    CSR_WRITE_4(sc, ALC_MASTER_CFG, master);
     2624    CSR_WRITE_4(sc, ALC_MAC_CFG, mac);
     2625    CSR_WRITE_4(sc, ALC_GPHY_CFG, gphy);
     2626    reg = CSR_READ_4(sc, ALC_PDLL_TRNS1);
     2627    reg |= PDLL_TRNS1_D3PLLOFF_ENB;
     2628    CSR_WRITE_4(sc, ALC_PDLL_TRNS1, reg);
     2629
     2630    if ((sc->alc_flags & ALC_FLAG_PM) != 0) {
     2631        /* Request PME. */
     2632        pmstat = pci_read_config(sc->alc_dev,
     2633            sc->alc_pmcap + PCIR_POWER_STATUS, 2);
     2634        pmstat &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
     2635        if ((ifp->if_capenable & IFCAP_WOL) != 0)
     2636            pmstat |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
     2637        pci_write_config(sc->alc_dev,
     2638            sc->alc_pmcap + PCIR_POWER_STATUS, pmstat, 2);
     2639    }
     2640}
     2641
    19692642static int
    19702643alc_suspend(device_t dev)
    19712644{
    alc_encap(struct alc_softc *sc, struct mbuf **m_head)  
    20362709    ip_off = poff = 0;
    20372710    if ((m->m_pkthdr.csum_flags & (ALC_CSUM_FEATURES | CSUM_TSO)) != 0) {
    20382711        /*
    2039          * AR813x/AR815x requires offset of TCP/UDP header in its
     2712         * AR81[3567]x requires offset of TCP/UDP header in its
    20402713         * Tx descriptor to perform Tx checksum offloading. TSO
    20412714         * also requires TCP header offset and modification of
    20422715         * IP/TCP header. This kind of operation takes many CPU
    alc_encap(struct alc_softc *sc, struct mbuf **m_head)  
    21742847        cflags |= (poff << TD_TCPHDR_OFFSET_SHIFT) &
    21752848            TD_TCPHDR_OFFSET_MASK;
    21762849        /*
    2177          * AR813x/AR815x requires the first buffer should
     2850         * AR81[3567]x requires the first buffer should
    21782851         * only hold IP/TCP header data. Payload should
    21792852         * be handled in other descriptors.
    21802853         */
    alc_start_locked(struct ifnet *ifp)  
    23052978        bus_dmamap_sync(sc->alc_cdata.alc_tx_ring_tag,
    23062979            sc->alc_cdata.alc_tx_ring_map, BUS_DMASYNC_PREWRITE);
    23072980        /* Kick. Assume we're using normal Tx priority queue. */
    2308         CSR_WRITE_4(sc, ALC_MBOX_TD_PROD_IDX,
    2309             (sc->alc_cdata.alc_tx_prod <<
    2310             MBOX_TD_PROD_LO_IDX_SHIFT) &
    2311             MBOX_TD_PROD_LO_IDX_MASK);
     2981        if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     2982            CSR_WRITE_2(sc, ALC_MBOX_TD_PRI0_PROD_IDX,
     2983                (uint16_t)sc->alc_cdata.alc_tx_prod);
     2984        else
     2985            CSR_WRITE_4(sc, ALC_MBOX_TD_PROD_IDX,
     2986                (sc->alc_cdata.alc_tx_prod <<
     2987                MBOX_TD_PROD_LO_IDX_SHIFT) &
     2988                MBOX_TD_PROD_LO_IDX_MASK);
    23122989        /* Set a timeout in case the chip goes out to lunch. */
    23132990        sc->alc_watchdog_timer = ALC_TX_TIMEOUT;
    23142991    }
    alc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)  
    23623039        else if (ifp->if_mtu != ifr->ifr_mtu) {
    23633040            ALC_LOCK(sc);
    23643041            ifp->if_mtu = ifr->ifr_mtu;
    2365             /* AR813x/AR815x has 13 bits MSS field. */
     3042            /* AR81[3567]x has 13 bits MSS field. */
    23663043            if (ifp->if_mtu > ALC_TSO_MTU &&
    23673044                (ifp->if_capenable & IFCAP_TSO4) != 0) {
    23683045                ifp->if_capenable &= ~IFCAP_TSO4;
    alc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)  
    24133090            (ifp->if_capabilities & IFCAP_TSO4) != 0) {
    24143091            ifp->if_capenable ^= IFCAP_TSO4;
    24153092            if ((ifp->if_capenable & IFCAP_TSO4) != 0) {
    2416                 /* AR813x/AR815x has 13 bits MSS field. */
     3093                /* AR81[3567]x has 13 bits MSS field. */
    24173094                if (ifp->if_mtu > ALC_TSO_MTU) {
    24183095                    ifp->if_capenable &= ~IFCAP_TSO4;
    24193096                    ifp->if_hwassist &= ~CSUM_TSO;
    alc_mac_config(struct alc_softc *sc)  
    24653142    reg = CSR_READ_4(sc, ALC_MAC_CFG);
    24663143    reg &= ~(MAC_CFG_FULL_DUPLEX | MAC_CFG_TX_FC | MAC_CFG_RX_FC |
    24673144        MAC_CFG_SPEED_MASK);
    2468     if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
     3145    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
     3146        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
    24693147        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
    24703148        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2)
    24713149        reg |= MAC_CFG_HASH_ALG_CRC32 | MAC_CFG_SPEED_MODE_SW;
    alc_stats_update(struct alc_softc *sc)  
    26033281    stat->tx_multi_colls += smb->tx_multi_colls;
    26043282    stat->tx_late_colls += smb->tx_late_colls;
    26053283    stat->tx_excess_colls += smb->tx_excess_colls;
    2606     stat->tx_abort += smb->tx_abort;
    26073284    stat->tx_underrun += smb->tx_underrun;
    26083285    stat->tx_desc_underrun += smb->tx_desc_underrun;
    26093286    stat->tx_lenerrs += smb->tx_lenerrs;
    alc_stats_update(struct alc_softc *sc)  
    26163293
    26173294    ifp->if_collisions += smb->tx_single_colls +
    26183295        smb->tx_multi_colls * 2 + smb->tx_late_colls +
    2619         smb->tx_abort * HDPX_CFG_RETRY_DEFAULT;
     3296        smb->tx_excess_colls * HDPX_CFG_RETRY_DEFAULT;
    26203297
    2621     /*
    2622      * XXX
    2623      * tx_pkts_truncated counter looks suspicious. It constantly
    2624      * increments with no sign of Tx errors. This may indicate
    2625      * the counter name is not correct one so I've removed the
    2626      * counter in output errors.
    2627      */
    2628     ifp->if_oerrors += smb->tx_abort + smb->tx_late_colls +
    2629         smb->tx_underrun;
     3298    ifp->if_oerrors += smb->tx_late_colls + smb->tx_excess_colls +
     3299        smb->tx_underrun + smb->tx_pkts_truncated;
    26303300
    26313301    ifp->if_ipackets += smb->rx_frames;
    26323302
    alc_txeof(struct alc_softc *sc)  
    27543424        bus_dmamap_sync(sc->alc_cdata.alc_cmb_tag,
    27553425            sc->alc_cdata.alc_cmb_map, BUS_DMASYNC_POSTREAD);
    27563426        prod = sc->alc_rdata.alc_cmb->cons;
    2757     } else
    2758         prod = CSR_READ_4(sc, ALC_MBOX_TD_CONS_IDX);
    2759     /* Assume we're using normal Tx priority queue. */
    2760     prod = (prod & MBOX_TD_CONS_LO_IDX_MASK) >>
    2761         MBOX_TD_CONS_LO_IDX_SHIFT;
     3427    } else {
     3428        if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     3429            prod = CSR_READ_2(sc, ALC_MBOX_TD_PRI0_CONS_IDX);
     3430        else {
     3431            prod = CSR_READ_4(sc, ALC_MBOX_TD_CONS_IDX);
     3432            /* Assume we're using normal Tx priority queue. */
     3433            prod = (prod & MBOX_TD_CONS_LO_IDX_MASK) >>
     3434                MBOX_TD_CONS_LO_IDX_SHIFT;
     3435        }
     3436    }
    27623437    cons = sc->alc_cdata.alc_tx_cons;
    27633438    /*
    27643439     * Go through our Tx list and free mbufs for those
    alc_rxintr(struct alc_softc *sc, int count)  
    28943569         * it still seems that pre-fetching needs more
    28953570         * experimentation.
    28963571         */
    2897         CSR_WRITE_4(sc, ALC_MBOX_RD0_PROD_IDX,
    2898             sc->alc_cdata.alc_rx_cons);
     3572        if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     3573            CSR_WRITE_2(sc, ALC_MBOX_RD0_PROD_IDX,
     3574                (uint16_t)sc->alc_cdata.alc_rx_cons);
     3575        else
     3576            CSR_WRITE_4(sc, ALC_MBOX_RD0_PROD_IDX,
     3577                sc->alc_cdata.alc_rx_cons);
    28993578    }
    29003579
    29013580    return (count > 0 ? 0 : EAGAIN);
    alc_tick(void *arg)  
    30873766}
    30883767
    30893768static void
    3090 alc_reset(struct alc_softc *sc)
     3769alc_osc_reset(struct alc_softc *sc)
    30913770{
    30923771    uint32_t reg;
     3772
     3773    reg = CSR_READ_4(sc, ALC_MISC3);
     3774    reg &= ~MISC3_25M_BY_SW;
     3775    reg |= MISC3_25M_NOTO_INTNL;
     3776    CSR_WRITE_4(sc, ALC_MISC3, reg);
     3777
     3778    reg = CSR_READ_4(sc, ALC_MISC);
     3779    if (AR816X_REV(sc->alc_rev) >= AR816X_REV_B0) {
     3780        /*
     3781         * Restore over-current protection default value.
     3782         * This value could be reset by MAC reset.
     3783         */
     3784        reg &= ~MISC_PSW_OCP_MASK;
     3785        reg |= (MISC_PSW_OCP_DEFAULT << MISC_PSW_OCP_SHIFT);
     3786        reg &= ~MISC_INTNLOSC_OPEN;
     3787        CSR_WRITE_4(sc, ALC_MISC, reg);
     3788        CSR_WRITE_4(sc, ALC_MISC, reg | MISC_INTNLOSC_OPEN);
     3789        reg = CSR_READ_4(sc, ALC_MISC2);
     3790        reg &= ~MISC2_CALB_START;
     3791        CSR_WRITE_4(sc, ALC_MISC2, reg);
     3792        CSR_WRITE_4(sc, ALC_MISC2, reg | MISC2_CALB_START);
     3793
     3794    } else {
     3795        reg &= ~MISC_INTNLOSC_OPEN;
     3796        /* Disable isolate for revision A devices. */
     3797        if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1)
     3798            reg &= ~MISC_ISO_ENB;
     3799        CSR_WRITE_4(sc, ALC_MISC, reg | MISC_INTNLOSC_OPEN);
     3800        CSR_WRITE_4(sc, ALC_MISC, reg);
     3801    }
     3802
     3803    DELAY(20);
     3804}
     3805
     3806static void
     3807alc_reset(struct alc_softc *sc)
     3808{
     3809    uint32_t pmcfg, reg;
    30933810    int i;
    30943811
    3095     reg = CSR_READ_4(sc, ALC_MASTER_CFG) & 0xFFFF;
     3812    pmcfg = 0;
     3813    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     3814        /* Reset workaround. */
     3815        CSR_WRITE_4(sc, ALC_MBOX_RD0_PROD_IDX, 1);
     3816        if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
     3817            (sc->alc_rev & 0x01) != 0) {
     3818            /* Disable L0s/L1s before reset. */
     3819            pmcfg = CSR_READ_4(sc, ALC_PM_CFG);
     3820            if ((pmcfg & (PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB))
     3821                != 0) {
     3822                pmcfg &= ~(PM_CFG_ASPM_L0S_ENB |
     3823                    PM_CFG_ASPM_L1_ENB);
     3824                CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
     3825            }
     3826        }
     3827    }
     3828    reg = CSR_READ_4(sc, ALC_MASTER_CFG);
    30963829    reg |= MASTER_OOB_DIS_OFF | MASTER_RESET;
    30973830    CSR_WRITE_4(sc, ALC_MASTER_CFG, reg);
     3831
     3832    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     3833        for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
     3834            DELAY(10);
     3835            if (CSR_READ_4(sc, ALC_MBOX_RD0_PROD_IDX) == 0)
     3836                break;
     3837        }
     3838        if (i == 0)
     3839            device_printf(sc->alc_dev, "MAC reset timeout!\n");
     3840    }
    30983841    for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
    30993842        DELAY(10);
    31003843        if ((CSR_READ_4(sc, ALC_MASTER_CFG) & MASTER_RESET) == 0)
    alc_reset(struct alc_softc *sc)  
    31043847        device_printf(sc->alc_dev, "master reset timeout!\n");
    31053848
    31063849    for (i = ALC_RESET_TIMEOUT; i > 0; i--) {
    3107         if ((reg = CSR_READ_4(sc, ALC_IDLE_STATUS)) == 0)
     3850        reg = CSR_READ_4(sc, ALC_IDLE_STATUS);
     3851        if ((reg & (IDLE_STATUS_RXMAC | IDLE_STATUS_TXMAC |
     3852            IDLE_STATUS_RXQ | IDLE_STATUS_TXQ)) == 0)
    31083853            break;
    31093854        DELAY(10);
    31103855    }
    3111 
    31123856    if (i == 0)
    31133857        device_printf(sc->alc_dev, "reset timeout(0x%08x)!\n", reg);
     3858
     3859    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     3860        if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1 &&
     3861            (sc->alc_rev & 0x01) != 0) {
     3862            reg = CSR_READ_4(sc, ALC_MASTER_CFG);
     3863            reg |= MASTER_CLK_SEL_DIS;
     3864            CSR_WRITE_4(sc, ALC_MASTER_CFG, reg);
     3865            /* Restore L0s/L1s config. */
     3866            if ((pmcfg & (PM_CFG_ASPM_L0S_ENB | PM_CFG_ASPM_L1_ENB))
     3867                != 0)
     3868                CSR_WRITE_4(sc, ALC_PM_CFG, pmcfg);
     3869        }
     3870
     3871        alc_osc_reset(sc);
     3872        reg = CSR_READ_4(sc, ALC_MISC3);
     3873        reg &= ~MISC3_25M_BY_SW;
     3874        reg |= MISC3_25M_NOTO_INTNL;
     3875        CSR_WRITE_4(sc, ALC_MISC3, reg);
     3876        reg = CSR_READ_4(sc, ALC_MISC);
     3877        reg &= ~MISC_INTNLOSC_OPEN;
     3878        if (AR816X_REV(sc->alc_rev) <= AR816X_REV_A1)
     3879            reg &= ~MISC_ISO_ENB;
     3880        CSR_WRITE_4(sc, ALC_MISC, reg);
     3881        DELAY(20);
     3882    }
     3883    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
     3884        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B ||
     3885        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2)
     3886        CSR_WRITE_4(sc, ALC_SERDES_LOCK,
     3887            CSR_READ_4(sc, ALC_SERDES_LOCK) | SERDES_MAC_CLK_SLOWDOWN |
     3888            SERDES_PHY_CLK_SLOWDOWN);
    31143889}
    31153890
    31163891static void
    alc_init_locked(struct alc_softc *sc)  
    31613936    alc_init_smb(sc);
    31623937
    31633938    /* Enable all clocks. */
    3164     CSR_WRITE_4(sc, ALC_CLK_GATING_CFG, 0);
     3939    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     3940        CSR_WRITE_4(sc, ALC_CLK_GATING_CFG, CLK_GATING_DMAW_ENB |
     3941            CLK_GATING_DMAR_ENB | CLK_GATING_TXQ_ENB |
     3942            CLK_GATING_RXQ_ENB | CLK_GATING_TXMAC_ENB |
     3943            CLK_GATING_RXMAC_ENB);
     3944        if (AR816X_REV(sc->alc_rev) >= AR816X_REV_B0)
     3945            CSR_WRITE_4(sc, ALC_IDLE_DECISN_TIMER,
     3946                IDLE_DECISN_TIMER_DEFAULT_1MS);
     3947    } else
     3948        CSR_WRITE_4(sc, ALC_CLK_GATING_CFG, 0);
    31653949
    31663950    /* Reprogram the station address. */
    31673951    bcopy(IF_LLADDR(ifp), eaddr, ETHER_ADDR_LEN);
    alc_init_locked(struct alc_softc *sc)  
    31873971    paddr = sc->alc_rdata.alc_rx_ring_paddr;
    31883972    CSR_WRITE_4(sc, ALC_RX_BASE_ADDR_HI, ALC_ADDR_HI(paddr));
    31893973    CSR_WRITE_4(sc, ALC_RD0_HEAD_ADDR_LO, ALC_ADDR_LO(paddr));
    3190     /* We use one Rx ring. */
    3191     CSR_WRITE_4(sc, ALC_RD1_HEAD_ADDR_LO, 0);
    3192     CSR_WRITE_4(sc, ALC_RD2_HEAD_ADDR_LO, 0);
    3193     CSR_WRITE_4(sc, ALC_RD3_HEAD_ADDR_LO, 0);
     3974    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     3975        /* We use one Rx ring. */
     3976        CSR_WRITE_4(sc, ALC_RD1_HEAD_ADDR_LO, 0);
     3977        CSR_WRITE_4(sc, ALC_RD2_HEAD_ADDR_LO, 0);
     3978        CSR_WRITE_4(sc, ALC_RD3_HEAD_ADDR_LO, 0);
     3979    }
    31943980    /* Set Rx descriptor counter. */
    31953981    CSR_WRITE_4(sc, ALC_RD_RING_CNT,
    31963982        (ALC_RX_RING_CNT << RD_RING_CNT_SHIFT) & RD_RING_CNT_MASK);
    alc_init_locked(struct alc_softc *sc)  
    32154001    paddr = sc->alc_rdata.alc_rr_ring_paddr;
    32164002    /* Set Rx return descriptor base addresses. */
    32174003    CSR_WRITE_4(sc, ALC_RRD0_HEAD_ADDR_LO, ALC_ADDR_LO(paddr));
    3218     /* We use one Rx return ring. */
    3219     CSR_WRITE_4(sc, ALC_RRD1_HEAD_ADDR_LO, 0);
    3220     CSR_WRITE_4(sc, ALC_RRD2_HEAD_ADDR_LO, 0);
    3221     CSR_WRITE_4(sc, ALC_RRD3_HEAD_ADDR_LO, 0);
     4004    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     4005        /* We use one Rx return ring. */
     4006        CSR_WRITE_4(sc, ALC_RRD1_HEAD_ADDR_LO, 0);
     4007        CSR_WRITE_4(sc, ALC_RRD2_HEAD_ADDR_LO, 0);
     4008        CSR_WRITE_4(sc, ALC_RRD3_HEAD_ADDR_LO, 0);
     4009    }
    32224010    /* Set Rx return descriptor counter. */
    32234011    CSR_WRITE_4(sc, ALC_RRD_RING_CNT,
    32244012        (ALC_RR_RING_CNT << RRD_RING_CNT_SHIFT) & RRD_RING_CNT_MASK);
    alc_init_locked(struct alc_softc *sc)  
    32454033
    32464034    /* Configure interrupt moderation timer. */
    32474035    reg = ALC_USECS(sc->alc_int_rx_mod) << IM_TIMER_RX_SHIFT;
    3248     reg |= ALC_USECS(sc->alc_int_tx_mod) << IM_TIMER_TX_SHIFT;
     4036    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0)
     4037        reg |= ALC_USECS(sc->alc_int_tx_mod) << IM_TIMER_TX_SHIFT;
    32494038    CSR_WRITE_4(sc, ALC_IM_TIMER, reg);
    32504039    /*
    32514040     * We don't want to automatic interrupt clear as task queue
    32524041     * for the interrupt should know interrupt status.
    32534042     */
    3254     reg = MASTER_SA_TIMER_ENB;
     4043    reg = CSR_READ_4(sc, ALC_MASTER_CFG);
     4044    reg &= ~(MASTER_IM_RX_TIMER_ENB | MASTER_IM_TX_TIMER_ENB);
     4045    reg |= MASTER_SA_TIMER_ENB;
    32554046    if (ALC_USECS(sc->alc_int_rx_mod) != 0)
    32564047        reg |= MASTER_IM_RX_TIMER_ENB;
    3257     if (ALC_USECS(sc->alc_int_tx_mod) != 0)
     4048    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0 &&
     4049        ALC_USECS(sc->alc_int_tx_mod) != 0)
    32584050        reg |= MASTER_IM_TX_TIMER_ENB;
    32594051    CSR_WRITE_4(sc, ALC_MASTER_CFG, reg);
    32604052    /*
    alc_init_locked(struct alc_softc *sc)  
    32634055     */
    32644056    CSR_WRITE_4(sc, ALC_INTR_RETRIG_TIMER, ALC_USECS(0));
    32654057    /* Configure CMB. */
    3266     if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0) {
    3267         CSR_WRITE_4(sc, ALC_CMB_TD_THRESH, 4);
    3268         CSR_WRITE_4(sc, ALC_CMB_TX_TIMER, ALC_USECS(5000));
    3269     } else
    3270         CSR_WRITE_4(sc, ALC_CMB_TX_TIMER, ALC_USECS(0));
     4058    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     4059        CSR_WRITE_4(sc, ALC_CMB_TD_THRESH, ALC_TX_RING_CNT / 3);
     4060        CSR_WRITE_4(sc, ALC_CMB_TX_TIMER,
     4061            ALC_USECS(sc->alc_int_tx_mod));
     4062    } else {
     4063        if ((sc->alc_flags & ALC_FLAG_CMB_BUG) == 0) {
     4064            CSR_WRITE_4(sc, ALC_CMB_TD_THRESH, 4);
     4065            CSR_WRITE_4(sc, ALC_CMB_TX_TIMER, ALC_USECS(5000));
     4066        } else
     4067            CSR_WRITE_4(sc, ALC_CMB_TX_TIMER, ALC_USECS(0));
     4068    }
    32714069    /*
    32724070     * Hardware can be configured to issue SMB interrupt based
    32734071     * on programmed interval. Since there is a callout that is
    alc_init_locked(struct alc_softc *sc)  
    32944092     */
    32954093    CSR_WRITE_4(sc, ALC_FRAME_SIZE, sc->alc_ident->max_framelen);
    32964094
    3297     /* Disable header split(?) */
    3298     CSR_WRITE_4(sc, ALC_HDS_CFG, 0);
    3299 
    3300     /* Configure IPG/IFG parameters. */
    3301     CSR_WRITE_4(sc, ALC_IPG_IFG_CFG,
    3302         ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK) |
    3303         ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
    3304         ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
    3305         ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK));
    3306     /* Set parameters for half-duplex media. */
    3307     CSR_WRITE_4(sc, ALC_HDPX_CFG,
    3308         ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
    3309         HDPX_CFG_LCOL_MASK) |
    3310         ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
    3311         HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
    3312         ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
    3313         HDPX_CFG_ABEBT_MASK) |
    3314         ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
    3315         HDPX_CFG_JAMIPG_MASK));
     4095    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     4096        /* Disable header split(?) */
     4097        CSR_WRITE_4(sc, ALC_HDS_CFG, 0);
     4098
     4099        /* Configure IPG/IFG parameters. */
     4100        CSR_WRITE_4(sc, ALC_IPG_IFG_CFG,
     4101            ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) &
     4102            IPG_IFG_IPGT_MASK) |
     4103            ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) &
     4104            IPG_IFG_MIFG_MASK) |
     4105            ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) &
     4106            IPG_IFG_IPG1_MASK) |
     4107            ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) &
     4108            IPG_IFG_IPG2_MASK));
     4109        /* Set parameters for half-duplex media. */
     4110        CSR_WRITE_4(sc, ALC_HDPX_CFG,
     4111            ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
     4112            HDPX_CFG_LCOL_MASK) |
     4113            ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
     4114            HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
     4115            ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
     4116            HDPX_CFG_ABEBT_MASK) |
     4117            ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
     4118            HDPX_CFG_JAMIPG_MASK));
     4119    }
     4120
    33164121    /*
    33174122     * Set TSO/checksum offload threshold. For frames that is
    33184123     * larger than this threshold, hardware wouldn't do
    33194124     * TSO/checksum offloading.
    33204125     */
    3321     CSR_WRITE_4(sc, ALC_TSO_OFFLOAD_THRESH,
    3322         (sc->alc_ident->max_framelen >> TSO_OFFLOAD_THRESH_UNIT_SHIFT) &
    3323         TSO_OFFLOAD_THRESH_MASK);
     4126    reg = (sc->alc_ident->max_framelen >> TSO_OFFLOAD_THRESH_UNIT_SHIFT) &
     4127        TSO_OFFLOAD_THRESH_MASK;
     4128    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     4129        reg |= TSO_OFFLOAD_ERRLGPKT_DROP_ENB;
     4130    CSR_WRITE_4(sc, ALC_TSO_OFFLOAD_THRESH, reg);
    33244131    /* Configure TxQ. */
    33254132    reg = (alc_dma_burst[sc->alc_dma_rd_burst] <<
    33264133        TXQ_CFG_TX_FIFO_BURST_SHIFT) & TXQ_CFG_TX_FIFO_BURST_MASK;
    alc_init_locked(struct alc_softc *sc)  
    33294136        reg >>= 1;
    33304137    reg |= (TXQ_CFG_TD_BURST_DEFAULT << TXQ_CFG_TD_BURST_SHIFT) &
    33314138        TXQ_CFG_TD_BURST_MASK;
     4139    reg |= TXQ_CFG_IP_OPTION_ENB | TXQ_CFG_8023_ENB;
    33324140    CSR_WRITE_4(sc, ALC_TXQ_CFG, reg | TXQ_CFG_ENHANCED_MODE);
    3333 
    3334     /* Configure Rx free descriptor pre-fetching. */
    3335     CSR_WRITE_4(sc, ALC_RX_RD_FREE_THRESH,
    3336         ((RX_RD_FREE_THRESH_HI_DEFAULT << RX_RD_FREE_THRESH_HI_SHIFT) &
    3337         RX_RD_FREE_THRESH_HI_MASK) |
    3338         ((RX_RD_FREE_THRESH_LO_DEFAULT << RX_RD_FREE_THRESH_LO_SHIFT) &
    3339         RX_RD_FREE_THRESH_LO_MASK));
     4141    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     4142        reg = (TXQ_CFG_TD_BURST_DEFAULT << HQTD_CFG_Q1_BURST_SHIFT |
     4143            TXQ_CFG_TD_BURST_DEFAULT << HQTD_CFG_Q2_BURST_SHIFT |
     4144            TXQ_CFG_TD_BURST_DEFAULT << HQTD_CFG_Q3_BURST_SHIFT |
     4145            HQTD_CFG_BURST_ENB);
     4146        CSR_WRITE_4(sc, ALC_HQTD_CFG, reg);
     4147        reg = WRR_PRI_RESTRICT_NONE;
     4148        reg |= (WRR_PRI_DEFAULT << WRR_PRI0_SHIFT |
     4149            WRR_PRI_DEFAULT << WRR_PRI1_SHIFT |
     4150            WRR_PRI_DEFAULT << WRR_PRI2_SHIFT |
     4151            WRR_PRI_DEFAULT << WRR_PRI3_SHIFT);
     4152        CSR_WRITE_4(sc, ALC_WRR, reg);
     4153    } else {
     4154        /* Configure Rx free descriptor pre-fetching. */
     4155        CSR_WRITE_4(sc, ALC_RX_RD_FREE_THRESH,
     4156            ((RX_RD_FREE_THRESH_HI_DEFAULT <<
     4157            RX_RD_FREE_THRESH_HI_SHIFT) & RX_RD_FREE_THRESH_HI_MASK) |
     4158            ((RX_RD_FREE_THRESH_LO_DEFAULT <<
     4159            RX_RD_FREE_THRESH_LO_SHIFT) & RX_RD_FREE_THRESH_LO_MASK));
     4160    }
    33404161
    33414162    /*
    33424163     * Configure flow control parameters.
    33434164     * XON  : 80% of Rx FIFO
    33444165     * XOFF : 30% of Rx FIFO
    33454166     */
    3346     if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8131 ||
     4167    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     4168        reg = CSR_READ_4(sc, ALC_SRAM_RX_FIFO_LEN);
     4169        reg &= SRAM_RX_FIFO_LEN_MASK;
     4170        reg *= 8;
     4171        if (reg > 8 * 1024)
     4172            reg -= RX_FIFO_PAUSE_816X_RSVD;
     4173        else
     4174            reg -= RX_BUF_SIZE_MAX;
     4175        reg /= 8;
     4176        CSR_WRITE_4(sc, ALC_RX_FIFO_PAUSE_THRESH,
     4177            ((reg << RX_FIFO_PAUSE_THRESH_LO_SHIFT) &
     4178            RX_FIFO_PAUSE_THRESH_LO_MASK) |
     4179            (((RX_FIFO_PAUSE_816X_RSVD / 8) <<
     4180            RX_FIFO_PAUSE_THRESH_HI_SHIFT) &
     4181            RX_FIFO_PAUSE_THRESH_HI_MASK));
     4182    } else if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8131 ||
    33474183        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8132) {
    33484184        reg = CSR_READ_4(sc, ALC_SRAM_RX_FIFO_LEN);
    33494185        rxf_hi = (reg * 8) / 10;
    alc_init_locked(struct alc_softc *sc)  
    33554191             RX_FIFO_PAUSE_THRESH_HI_MASK));
    33564192    }
    33574193
    3358     if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B ||
    3359         sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2)
    3360         CSR_WRITE_4(sc, ALC_SERDES_LOCK,
    3361             CSR_READ_4(sc, ALC_SERDES_LOCK) | SERDES_MAC_CLK_SLOWDOWN |
    3362             SERDES_PHY_CLK_SLOWDOWN);
    3363 
    3364     /* Disable RSS until I understand L1C/L2C's RSS logic. */
    3365     CSR_WRITE_4(sc, ALC_RSS_IDT_TABLE0, 0);
    3366     CSR_WRITE_4(sc, ALC_RSS_CPU, 0);
     4194    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     4195        /* Disable RSS until I understand L1C/L2C's RSS logic. */
     4196        CSR_WRITE_4(sc, ALC_RSS_IDT_TABLE0, 0);
     4197        CSR_WRITE_4(sc, ALC_RSS_CPU, 0);
     4198    }
    33674199
    33684200    /* Configure RxQ. */
    33694201    reg = (RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) &
    33704202        RXQ_CFG_RD_BURST_MASK;
    33714203    reg |= RXQ_CFG_RSS_MODE_DIS;
    3372     if ((sc->alc_flags & ALC_FLAG_ASPM_MON) != 0)
     4204    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0)
     4205        reg |= (RXQ_CFG_816X_IDT_TBL_SIZE_DEFAULT <<
     4206            RXQ_CFG_816X_IDT_TBL_SIZE_SHIFT) &
     4207            RXQ_CFG_816X_IDT_TBL_SIZE_MASK;
     4208    if ((sc->alc_flags & ALC_FLAG_FASTETHER) == 0 &&
     4209        sc->alc_ident->deviceid != DEVICEID_ATHEROS_AR8151_V2)
    33734210        reg |= RXQ_CFG_ASPM_THROUGHPUT_LIMIT_1M;
    33744211    CSR_WRITE_4(sc, ALC_RXQ_CFG, reg);
    33754212
    alc_init_locked(struct alc_softc *sc)  
    33904227        DMA_CFG_RD_DELAY_CNT_MASK;
    33914228    reg |= (DMA_CFG_WR_DELAY_CNT_DEFAULT << DMA_CFG_WR_DELAY_CNT_SHIFT) &
    33924229        DMA_CFG_WR_DELAY_CNT_MASK;
     4230    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0) {
     4231        switch (AR816X_REV(sc->alc_rev)) {
     4232        case AR816X_REV_A0:
     4233        case AR816X_REV_A1:
     4234            reg |= DMA_CFG_RD_CHNL_SEL_1;
     4235            break;
     4236        case AR816X_REV_B0:
     4237            /* FALLTHROUGH */
     4238        default:
     4239            reg |= DMA_CFG_RD_CHNL_SEL_3;
     4240            break;
     4241        }
     4242    }
    33934243    CSR_WRITE_4(sc, ALC_DMA_CFG, reg);
    33944244
    33954245    /*
    alc_init_locked(struct alc_softc *sc)  
    34084258    reg = MAC_CFG_TX_CRC_ENB | MAC_CFG_TX_AUTO_PAD | MAC_CFG_FULL_DUPLEX |
    34094259        ((MAC_CFG_PREAMBLE_DEFAULT << MAC_CFG_PREAMBLE_SHIFT) &
    34104260        MAC_CFG_PREAMBLE_MASK);
    3411     if (sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
     4261    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) != 0 ||
     4262        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151 ||
    34124263        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8151_V2 ||
    34134264        sc->alc_ident->deviceid == DEVICEID_ATHEROS_AR8152_B2)
    34144265        reg |= MAC_CFG_HASH_ALG_CRC32 | MAC_CFG_SPEED_MODE_SW;
    alc_init_locked(struct alc_softc *sc)  
    34274278    CSR_WRITE_4(sc, ALC_INTR_STATUS, 0xFFFFFFFF);
    34284279    CSR_WRITE_4(sc, ALC_INTR_STATUS, 0);
    34294280
     4281    ifp->if_drv_flags |= IFF_DRV_RUNNING;
     4282    ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
     4283
    34304284    sc->alc_flags &= ~ALC_FLAG_LINK;
    34314285    /* Switch to the current media. */
    3432     mii_mediachg(mii);
     4286    alc_mediachange_locked(sc);
    34334287
    34344288    callout_reset(&sc->alc_tick_ch, hz, alc_tick, sc);
    3435 
    3436     ifp->if_drv_flags |= IFF_DRV_RUNNING;
    3437     ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
    34384289}
    34394290
    34404291static void
    alc_stop(struct alc_softc *sc)  
    34594310    /* Disable interrupts. */
    34604311    CSR_WRITE_4(sc, ALC_INTR_MASK, 0);
    34614312    CSR_WRITE_4(sc, ALC_INTR_STATUS, 0xFFFFFFFF);
    3462     alc_stop_queue(sc);
    34634313    /* Disable DMA. */
    34644314    reg = CSR_READ_4(sc, ALC_DMA_CFG);
    34654315    reg &= ~(DMA_CFG_CMB_ENB | DMA_CFG_SMB_ENB);
    alc_stop(struct alc_softc *sc)  
    34704320    alc_stop_mac(sc);
    34714321    /* Disable interrupts which might be touched in taskq handler. */
    34724322    CSR_WRITE_4(sc, ALC_INTR_STATUS, 0xFFFFFFFF);
    3473 
     4323    /* Disable L0s/L1s */
     4324    alc_aspm(sc, 0, IFM_UNKNOWN);
    34744325    /* Reclaim Rx buffers that have been processed. */
    34754326    if (sc->alc_cdata.alc_rxhead != NULL)
    34764327        m_freem(sc->alc_cdata.alc_rxhead);
    alc_stop_mac(struct alc_softc *sc)  
    35084359    uint32_t reg;
    35094360    int i;
    35104361
    3511     ALC_LOCK_ASSERT(sc);
    3512 
     4362    alc_stop_queue(sc);
    35134363    /* Disable Rx/Tx MAC. */
    35144364    reg = CSR_READ_4(sc, ALC_MAC_CFG);
    35154365    if ((reg & (MAC_CFG_TX_ENB | MAC_CFG_RX_ENB)) != 0) {
    alc_stop_mac(struct alc_softc *sc)  
    35184368    }
    35194369    for (i = ALC_TIMEOUT; i > 0; i--) {
    35204370        reg = CSR_READ_4(sc, ALC_IDLE_STATUS);
    3521         if (reg == 0)
     4371        if ((reg & (IDLE_STATUS_RXMAC | IDLE_STATUS_TXMAC)) == 0)
    35224372            break;
    35234373        DELAY(10);
    35244374    }
    alc_start_queue(struct alc_softc *sc)  
    35434393
    35444394    /* Enable RxQ. */
    35454395    cfg = CSR_READ_4(sc, ALC_RXQ_CFG);
    3546     cfg &= ~RXQ_CFG_ENB;
    3547     cfg |= qcfg[1];
     4396    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     4397        cfg &= ~RXQ_CFG_ENB;
     4398        cfg |= qcfg[1];
     4399    } else
     4400        cfg |= RXQ_CFG_QUEUE0_ENB;
    35484401    CSR_WRITE_4(sc, ALC_RXQ_CFG, cfg);
    35494402    /* Enable TxQ. */
    35504403    cfg = CSR_READ_4(sc, ALC_TXQ_CFG);
    alc_stop_queue(struct alc_softc *sc)  
    35584411    uint32_t reg;
    35594412    int i;
    35604413
    3561     ALC_LOCK_ASSERT(sc);
    3562 
    35634414    /* Disable RxQ. */
    35644415    reg = CSR_READ_4(sc, ALC_RXQ_CFG);
    3565     if ((reg & RXQ_CFG_ENB) != 0) {
    3566         reg &= ~RXQ_CFG_ENB;
    3567         CSR_WRITE_4(sc, ALC_RXQ_CFG, reg);
     4416    if ((sc->alc_flags & ALC_FLAG_AR816X_FAMILY) == 0) {
     4417        if ((reg & RXQ_CFG_ENB) != 0) {
     4418            reg &= ~RXQ_CFG_ENB;
     4419            CSR_WRITE_4(sc, ALC_RXQ_CFG, reg);
     4420        }
     4421    } else {
     4422        if ((reg & RXQ_CFG_QUEUE0_ENB) != 0) {
     4423            reg &= ~RXQ_CFG_QUEUE0_ENB;
     4424            CSR_WRITE_4(sc, ALC_RXQ_CFG, reg);
     4425        }
    35684426    }
    35694427    /* Disable TxQ. */
    35704428    reg = CSR_READ_4(sc, ALC_TXQ_CFG);
    alc_stop_queue(struct alc_softc *sc)  
    35724430        reg &= ~TXQ_CFG_ENB;
    35734431        CSR_WRITE_4(sc, ALC_TXQ_CFG, reg);
    35744432    }
     4433    DELAY(40);
    35754434    for (i = ALC_TIMEOUT; i > 0; i--) {
    35764435        reg = CSR_READ_4(sc, ALC_IDLE_STATUS);
    35774436        if ((reg & (IDLE_STATUS_RXQ | IDLE_STATUS_TXQ)) == 0)
  • src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcreg.h

    diff --git a/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcreg.h b/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcreg.h
    index 3011abf..3aaae86 100644
    a b  
    4444#define DEVICEID_ATHEROS_AR8151_V2  0x1083  /* L1D V2.0 */
    4545#define DEVICEID_ATHEROS_AR8152_B   0x2060  /* L2C V1.1 */
    4646#define DEVICEID_ATHEROS_AR8152_B2  0x2062  /* L2C V2.0 */
     47#define DEVICEID_ATHEROS_AR8161     0x1091
     48#define DEVICEID_ATHEROS_E2200      0xE091
     49#define DEVICEID_ATHEROS_E2400      0xE0A1
     50#define DEVICEID_ATHEROS_E2500      0xE0B1
     51#define DEVICEID_ATHEROS_AR8162     0x1090
     52#define DEVICEID_ATHEROS_AR8171     0x10A1
     53#define DEVICEID_ATHEROS_AR8172     0x10A0
    4754
    4855#define ATHEROS_AR8152_B_V10        0xC0
    4956#define ATHEROS_AR8152_B_V11        0xC1
    5057
     58/*
     59 * Atheros AR816x/AR817x revisions
     60 */
     61#define AR816X_REV_A0           0
     62#define AR816X_REV_A1           1
     63#define AR816X_REV_B0           2
     64#define AR816X_REV_C0           3
     65
     66#define AR816X_REV_SHIFT        3
     67#define AR816X_REV(x)           ((x) >> AR816X_REV_SHIFT)
     68
    5169/* 0x0000 - 0x02FF : PCIe configuration space */
    5270
    5371#define ALC_PEX_UNC_ERR_SEV     0x10C
     
    6381#define PEX_UNC_ERR_SEV_ECRC        0x00080000
    6482#define PEX_UNC_ERR_SEV_UR      0x00100000
    6583
     84#define ALC_EEPROM_LD           0x204   /* AR816x */
     85#define EEPROM_LD_START         0x00000001
     86#define EEPROM_LD_IDLE          0x00000010
     87#define EEPROM_LD_DONE          0x00000000
     88#define EEPROM_LD_PROGRESS      0x00000020
     89#define EEPROM_LD_EXIST         0x00000100
     90#define EEPROM_LD_EEPROM_EXIST      0x00000200
     91#define EEPROM_LD_FLASH_EXIST       0x00000400
     92#define EEPROM_LD_FLASH_END_ADDR_MASK   0x03FF0000
     93#define EEPROM_LD_FLASH_END_ADDR_SHIFT  16
     94
    6695#define ALC_TWSI_CFG            0x218
    6796#define TWSI_CFG_SW_LD_START        0x00000800
    6897#define TWSI_CFG_HW_LD_START        0x00001000
    6998#define TWSI_CFG_LD_EXIST       0x00400000
    7099
     100#define ALC_SLD             0x218   /* AR816x */
     101#define SLD_START           0x00000800
     102#define SLD_PROGRESS            0x00001000
     103#define SLD_IDLE            0x00002000
     104#define SLD_SLVADDR_MASK        0x007F0000
     105#define SLD_EXIST           0x00800000
     106#define SLD_FREQ_MASK           0x03000000
     107#define SLD_FREQ_100K           0x00000000
     108#define SLD_FREQ_200K           0x01000000
     109#define SLD_FREQ_300K           0x02000000
     110#define SLD_FREQ_400K           0x03000000
     111
    71112#define ALC_PCIE_PHYMISC        0x1000
    72113#define PCIE_PHYMISC_FORCE_RCV_DET  0x00000004
    73114
     
    77118#define PCIE_PHYMISC2_SERDES_CDR_SHIFT  16
    78119#define PCIE_PHYMISC2_SERDES_TH_SHIFT   18
    79120
     121#define ALC_PDLL_TRNS1          0x1104
     122#define PDLL_TRNS1_D3PLLOFF_ENB     0x00000800
     123
    80124#define ALC_TWSI_DEBUG          0x1108
    81125#define TWSI_DEBUG_DEV_EXIST        0x20000000
    82126
     
    103147#define PM_CFG_SERDES_PD_EX_L1      0x00000040
    104148#define PM_CFG_SERDES_BUDS_RX_L1_ENB    0x00000080
    105149#define PM_CFG_L0S_ENTRY_TIMER_MASK 0x00000F00
     150#define PM_CFG_RX_L1_AFTER_L0S      0x00000800
    106151#define PM_CFG_ASPM_L0S_ENB     0x00001000
    107152#define PM_CFG_CLK_SWH_L1       0x00002000
    108153#define PM_CFG_CLK_PWM_VER1_1       0x00004000
    109154#define PM_CFG_PCIE_RECV        0x00008000
    110155#define PM_CFG_L1_ENTRY_TIMER_MASK  0x000F0000
     156#define PM_CFG_L1_ENTRY_TIMER_816X_MASK 0x00070000
     157#define PM_CFG_TX_L1_AFTER_L0S      0x00080000
    111158#define PM_CFG_PM_REQ_TIMER_MASK    0x00F00000
    112159#define PM_CFG_LCKDET_TIMER_MASK    0x0F000000
    113160#define PM_CFG_EN_BUFS_RX_L0S       0x10000000
     
    121168
    122169#define PM_CFG_L0S_ENTRY_TIMER_DEFAULT  6
    123170#define PM_CFG_L1_ENTRY_TIMER_DEFAULT   1
     171#define PM_CFG_L1_ENTRY_TIMER_816X_DEFAULT  4
    124172#define PM_CFG_LCKDET_TIMER_DEFAULT 12
    125173#define PM_CFG_PM_REQ_TIMER_DEFAULT 12
     174#define PM_CFG_PM_REQ_TIMER_816X_DEFAULT    15
    126175
    127176#define ALC_LTSSM_ID_CFG        0x12FC
    128177#define LTSSM_ID_WRO_ENB        0x00001000
     
    131180#define MASTER_RESET            0x00000001
    132181#define MASTER_TEST_MODE_MASK       0x0000000C
    133182#define MASTER_BERT_START       0x00000010
     183#define MASTER_WAKEN_25M        0x00000020
    134184#define MASTER_OOB_DIS_OFF      0x00000040
    135185#define MASTER_SA_TIMER_ENB     0x00000080
    136186#define MASTER_MTIMER_ENB       0x00000100
     
    171221 */
    172222#define ALC_IM_TX_TIMER_DEFAULT     1000    /* 1ms */
    173223
    174 #define ALC_GPHY_CFG            0x140C  /* 16bits */
     224#define ALC_GPHY_CFG            0x140C  /* 16 bits, 32 bits on AR816x */
    175225#define GPHY_CFG_EXT_RESET      0x0001
    176226#define GPHY_CFG_RTL_MODE       0x0002
    177227#define GPHY_CFG_LED_MODE       0x0004
     
    188238#define GPHY_CFG_PHY_PLL_ON     0x2000
    189239#define GPHY_CFG_PWDOWN_HW      0x4000
    190240#define GPHY_CFG_PHY_PLL_BYPASS     0x8000
     241#define GPHY_CFG_100AB_ENB      0x00020000
    191242
    192243#define ALC_IDLE_STATUS         0x1410
    193244#define IDLE_STATUS_RXMAC       0x00000001
     
    212263#define MDIO_CLK_25_10          0x04000000
    213264#define MDIO_CLK_25_14          0x05000000
    214265#define MDIO_CLK_25_20          0x06000000
    215 #define MDIO_CLK_25_28          0x07000000
     266#define MDIO_CLK_25_128         0x07000000
    216267#define MDIO_OP_BUSY            0x08000000
    217268#define MDIO_AP_ENB         0x10000000
     269#define MDIO_MODE_EXT           0x40000000
    218270#define MDIO_DATA_SHIFT         0
    219271#define MDIO_REG_ADDR_SHIFT     16
    220272
     
    248300#define SERDES_MAC_CLK_SLOWDOWN     0x00020000
    249301#define SERDES_PHY_CLK_SLOWDOWN     0x00040000
    250302
     303#define ALC_LPI_CTL         0x1440
     304#define LPI_CTL_ENB         0x00000001
     305
     306#define ALC_EXT_MDIO            0x1448
     307#define EXT_MDIO_REG_MASK       0x0000FFFF
     308#define EXT_MDIO_DEVADDR_MASK       0x001F0000
     309#define EXT_MDIO_REG_SHIFT      0
     310#define EXT_MDIO_DEVADDR_SHIFT      16
     311
     312#define EXT_MDIO_REG(x)     \
     313    (((x) << EXT_MDIO_REG_SHIFT) & EXT_MDIO_REG_MASK)
     314#define EXT_MDIO_DEVADDR(x) \
     315    (((x) << EXT_MDIO_DEVADDR_SHIFT) & EXT_MDIO_DEVADDR_MASK)
     316
     317#define ALC_IDLE_DECISN_TIMER       0x1474
     318#define IDLE_DECISN_TIMER_DEFAULT_1MS   0x400
     319
    251320#define ALC_MAC_CFG         0x1480
    252321#define MAC_CFG_TX_ENB          0x00000001
    253322#define MAC_CFG_RX_ENB          0x00000002
     
    278347#define MAC_CFG_SINGLE_PAUSE_ENB    0x10000000
    279348#define MAC_CFG_HASH_ALG_CRC32      0x20000000
    280349#define MAC_CFG_SPEED_MODE_SW       0x40000000
     350#define MAC_CFG_FAST_PAUSE      0x80000000
    281351#define MAC_CFG_PREAMBLE_SHIFT      10
    282352#define MAC_CFG_PREAMBLE_DEFAULT    7
    283353
     
    378448
    379449#define ALC_RSS_IDT_TABLE0      0x14E0
    380450
     451#define ALC_TD_PRI2_HEAD_ADDR_LO    0x14E0  /* AR816x */
     452
    381453#define ALC_RSS_IDT_TABLE1      0x14E4
    382454
     455#define ALC_TD_PRI3_HEAD_ADDR_LO    0x14E4  /* AR816x */
     456
    383457#define ALC_RSS_IDT_TABLE2      0x14E8
    384458
    385459#define ALC_RSS_IDT_TABLE3      0x14EC
     
    422496#define ALC_SRAM_RX_FIFO_ADDR       0x1520
    423497
    424498#define ALC_SRAM_RX_FIFO_LEN        0x1524
     499#define SRAM_RX_FIFO_LEN_MASK       0x00000FFF
     500#define SRAM_RX_FIFO_LEN_SHIFT      0
    425501
    426502#define ALC_SRAM_TX_FIFO_ADDR       0x1528
    427503
     
    478554
    479555#define ALC_TDH_HEAD_ADDR_LO        0x157C
    480556
     557#define ALC_TD_PRI1_HEAD_ADDR_LO    0x157C  /* AR816x */
     558
    481559#define ALC_TDL_HEAD_ADDR_LO        0x1580
    482560
     561#define ALC_TD_PRI0_HEAD_ADDR_LO    0x1580  /* AR816x */
     562
    483563#define ALC_TD_RING_CNT         0x1584
    484564#define TD_RING_CNT_MASK        0x0000FFFF
    485565#define TD_RING_CNT_SHIFT       0
     
    499579
    500580#define ALC_TSO_OFFLOAD_THRESH      0x1594  /* 8 bytes unit */
    501581#define TSO_OFFLOAD_THRESH_MASK     0x000007FF
     582#define TSO_OFFLOAD_ERRLGPKT_DROP_ENB   0x00000800
    502583#define TSO_OFFLOAD_THRESH_SHIFT    0
    503584#define TSO_OFFLOAD_THRESH_UNIT     8
    504585#define TSO_OFFLOAD_THRESH_UNIT_SHIFT   3
     
    546627    (RXQ_CFG_QUEUE0_ENB | RXQ_CFG_QUEUE1_ENB |  \
    547628     RXQ_CFG_QUEUE2_ENB | RXQ_CFG_QUEUE3_ENB)
    548629
     630/* AR816x specific bits */
     631#define RXQ_CFG_816X_RSS_HASH_IPV4  0x00000004
     632#define RXQ_CFG_816X_RSS_HASH_IPV4_TCP  0x00000008
     633#define RXQ_CFG_816X_RSS_HASH_IPV6  0x00000010
     634#define RXQ_CFG_816X_RSS_HASH_IPV6_TCP  0x00000020
     635#define RXQ_CFG_816X_RSS_HASH_MASK  0x0000003C
     636#define RXQ_CFG_816X_IPV6_PARSE_ENB 0x00000080
     637#define RXQ_CFG_816X_IDT_TBL_SIZE_MASK  0x0001FF00
     638#define RXQ_CFG_816X_IDT_TBL_SIZE_SHIFT 8
     639#define RXQ_CFG_816X_IDT_TBL_SIZE_DEFAULT   0x100
     640
    549641#define ALC_RX_RD_FREE_THRESH       0x15A4  /* 8 bytes unit. */
    550642#define RX_RD_FREE_THRESH_HI_MASK   0x0000003F
    551643#define RX_RD_FREE_THRESH_LO_MASK   0x00000FC0
     
    559651#define RX_FIFO_PAUSE_THRESH_HI_MASK    0x0FFF0000
    560652#define RX_FIFO_PAUSE_THRESH_LO_SHIFT   0
    561653#define RX_FIFO_PAUSE_THRESH_HI_SHIFT   16
     654/*
     655 * Size = tx-packet(1522) + IPG(12) + SOF(8) + 64(Pause) + IPG(12) + SOF(8) +
     656 *    rx-packet(1522) + delay-of-link(64)
     657 *  = 3212.
     658 */
     659#define RX_FIFO_PAUSE_816X_RSVD     3212
    562660
    563661#define ALC_RD_DMA_CFG          0x15AC
    564662#define RD_DMA_CFG_THRESH_MASK      0x00000FFF  /* 8 bytes unit */
     
    582680#define DMA_CFG_OUT_ORDER       0x00000004
    583681#define DMA_CFG_RCB_64          0x00000000
    584682#define DMA_CFG_RCB_128         0x00000008
     683#define DMA_CFG_PEND_AUTO_RST       0x00000008
    585684#define DMA_CFG_RD_BURST_128        0x00000000
    586685#define DMA_CFG_RD_BURST_256        0x00000010
    587686#define DMA_CFG_RD_BURST_512        0x00000020
     
    601700#define DMA_CFG_SMB_ENB         0x00200000
    602701#define DMA_CFG_CMB_NOW         0x00400000
    603702#define DMA_CFG_SMB_DIS         0x01000000
     703#define DMA_CFG_RD_CHNL_SEL_MASK    0x0C000000
     704#define DMA_CFG_RD_CHNL_SEL_1       0x00000000
     705#define DMA_CFG_RD_CHNL_SEL_2       0x04000000
     706#define DMA_CFG_RD_CHNL_SEL_3       0x08000000
     707#define DMA_CFG_RD_CHNL_SEL_4       0x0C000000
     708#define DMA_CFG_WSRAM_RDCTL     0x10000000
     709#define DMA_CFG_RD_PEND_CLR     0x20000000
     710#define DMA_CFG_WR_PEND_CLR     0x40000000
    604711#define DMA_CFG_SMB_NOW         0x80000000
    605712#define DMA_CFG_RD_BURST_MASK       0x07
    606713#define DMA_CFG_RD_BURST_SHIFT      4
     
    623730#define CMB_TX_TIMER_MASK       0x0000FFFF
    624731#define CMB_TX_TIMER_SHIFT      0
    625732
     733#define ALC_MSI_MAP_TBL1        0x15D0
     734
     735#define ALC_MSI_ID_MAP          0x15D4
     736
     737#define ALC_MSI_MAP_TBL2        0x15D8
     738
    626739#define ALC_MBOX_RD0_PROD_IDX       0x15E0
    627740
    628741#define ALC_MBOX_RD1_PROD_IDX       0x15E4
     
    640753#define MBOX_TD_PROD_HI_IDX_SHIFT   0
    641754#define MBOX_TD_PROD_LO_IDX_SHIFT   16
    642755
     756#define ALC_MBOX_TD_PRI1_PROD_IDX   0x15F0  /* 16 bits AR816x */
     757
     758#define ALC_MBOX_TD_PRI0_PROD_IDX   0x15F2  /* 16 bits AR816x */
     759
    643760#define ALC_MBOX_TD_CONS_IDX        0x15F4
    644761#define MBOX_TD_CONS_HI_IDX_MASK    0x0000FFFF
    645762#define MBOX_TD_CONS_LO_IDX_MASK    0xFFFF0000
    646763#define MBOX_TD_CONS_HI_IDX_SHIFT   0
    647764#define MBOX_TD_CONS_LO_IDX_SHIFT   16
    648765
     766#define ALC_MBOX_TD_PRI1_CONS_IDX   0x15F4  /* 16 bits AR816x */
     767
     768#define ALC_MBOX_TD_PRI0_CONS_IDX   0x15F6  /* 16 bits AR816x */
     769
    649770#define ALC_MBOX_RD01_CONS_IDX      0x15F8
    650771#define MBOX_RD0_CONS_IDX_MASK      0x0000FFFF
    651772#define MBOX_RD1_CONS_IDX_MASK      0xFFFF0000
     
    674795#define INTR_GPHY           0x00001000
    675796#define INTR_GPHY_LOW_PW        0x00002000
    676797#define INTR_TXQ_TO_RST         0x00004000
    677 #define INTR_TX_PKT         0x00008000
     798#define INTR_TX_PKT0            0x00008000
    678799#define INTR_RX_PKT0            0x00010000
    679800#define INTR_RX_PKT1            0x00020000
    680801#define INTR_RX_PKT2            0x00040000
     
    688809#define INTR_PHY_LINK_DOWN      0x04000000
    689810#define INTR_DIS_INT            0x80000000
    690811
     812/* INTR status for AR816x/AR817x  4 TX queues, 8 RX queues */
     813#define INTR_TX_PKT1            0x00000020
     814#define INTR_TX_PKT2            0x00000040
     815#define INTR_TX_PKT3            0x00000080
     816#define INTR_RX_PKT4            0x08000000
     817#define INTR_RX_PKT5            0x10000000
     818#define INTR_RX_PKT6            0x20000000
     819#define INTR_RX_PKT7            0x40000000
     820
    691821/* Interrupt Mask Register */
    692822#define ALC_INTR_MASK           0x1604
    693823
     
    699829    (INTR_RD0_UNDERRUN | INTR_RD1_UNDERRUN |    \
    700830    INTR_RD2_UNDERRUN | INTR_RD3_UNDERRUN)
    701831#else
     832#define INTR_TX_PKT         INTR_TX_PKT0
    702833#define INTR_RX_PKT         INTR_RX_PKT0
    703834#define INTR_RD_UNDERRUN        INTR_RD0_UNDERRUN
    704835#endif
     
    720851#define HDS_CFG_BACKFILLSIZE_SHIFT  8
    721852#define HDS_CFG_MAX_HDRSIZE_SHIFT   20
    722853
     854#define ALC_MBOX_TD_PRI3_PROD_IDX   0x1618  /* 16 bits AR816x */
     855
     856#define ALC_MBOX_TD_PRI2_PROD_IDX   0x161A  /* 16 bits AR816x */
     857
     858#define ALC_MBOX_TD_PRI3_CONS_IDX   0x161C  /* 16 bits AR816x */
     859
     860#define ALC_MBOX_TD_PRI2_CONS_IDX   0x161E  /* 16 bits AR816x */
     861
    723862/* AR813x/AR815x registers for MAC statistics */
    724863#define ALC_RX_MIB_BASE         0x1700
    725864
    726865#define ALC_TX_MIB_BASE         0x1760
    727866
     867#define ALC_DRV             0x1804  /* AR816x */
     868#define DRV_ASPM_SPD10LMT_1M        0x00000000
     869#define DRV_ASPM_SPD10LMT_10M       0x00000001
     870#define DRV_ASPM_SPD10LMT_100M      0x00000002
     871#define DRV_ASPM_SPD10LMT_NO        0x00000003
     872#define DRV_ASPM_SPD10LMT_MASK      0x00000003
     873#define DRV_ASPM_SPD100LMT_1M       0x00000000
     874#define DRV_ASPM_SPD100LMT_10M      0x00000004
     875#define DRV_ASPM_SPD100LMT_100M     0x00000008
     876#define DRV_ASPM_SPD100LMT_NO       0x0000000C
     877#define DRV_ASPM_SPD100LMT_MASK     0x0000000C
     878#define DRV_ASPM_SPD1000LMT_100M    0x00000000
     879#define DRV_ASPM_SPD1000LMT_NO      0x00000010
     880#define DRV_ASPM_SPD1000LMT_1M      0x00000020
     881#define DRV_ASPM_SPD1000LMT_10M     0x00000030
     882#define DRV_ASPM_SPD1000LMT_MASK    0x00000000
     883#define DRV_WOLCAP_BIOS_EN      0x00000100
     884#define DRV_WOLMAGIC_EN         0x00000200
     885#define DRV_WOLLINKUP_EN        0x00000400
     886#define DRV_WOLPATTERN_EN       0x00000800
     887#define DRV_AZ_EN           0x00001000
     888#define DRV_WOLS5_BIOS_EN       0x00010000
     889#define DRV_WOLS5_EN            0x00020000
     890#define DRV_DISABLE         0x00040000
     891#define DRV_PHY_MASK            0x1FE00000
     892#define DRV_PHY_EEE         0x00200000
     893#define DRV_PHY_APAUSE          0x00400000
     894#define DRV_PHY_PAUSE           0x00800000
     895#define DRV_PHY_DUPLEX          0x01000000
     896#define DRV_PHY_10          0x02000000
     897#define DRV_PHY_100         0x04000000
     898#define DRV_PHY_1000            0x08000000
     899#define DRV_PHY_AUTO            0x10000000
     900#define DRV_PHY_SHIFT           21
     901
    728902#define ALC_CLK_GATING_CFG      0x1814
    729903#define CLK_GATING_DMAW_ENB     0x0001
    730904#define CLK_GATING_DMAR_ENB     0x0002
     
    737911
    738912#define ALC_DEBUG_DATA1         0x1904
    739913
     914#define ALC_MSI_RETRANS_TIMER       0x1920
     915#define MSI_RETRANS_TIMER_MASK      0x0000FFFF
     916#define MSI_RETRANS_MASK_SEL_STD    0x00000000
     917#define MSI_RETRANS_MASK_SEL_LINE   0x00010000
     918#define MSI_RETRANS_TIMER_SHIFT     0
     919
     920#define ALC_WRR             0x1938
     921#define WRR_PRI0_MASK           0x0000001F
     922#define WRR_PRI1_MASK           0x00001F00
     923#define WRR_PRI2_MASK           0x001F0000
     924#define WRR_PRI3_MASK           0x1F000000
     925#define WRR_PRI_RESTRICT_MASK       0x60000000
     926#define WRR_PRI_RESTRICT_ALL        0x00000000
     927#define WRR_PRI_RESTRICT_HI     0x20000000
     928#define WRR_PRI_RESTRICT_HI2        0x40000000
     929#define WRR_PRI_RESTRICT_NONE       0x60000000
     930#define WRR_PRI0_SHIFT          0
     931#define WRR_PRI1_SHIFT          8
     932#define WRR_PRI2_SHIFT          16
     933#define WRR_PRI3_SHIFT          24
     934#define WRR_PRI_DEFAULT         4
     935#define WRR_PRI_RESTRICT_SHIFT      29
     936
     937#define ALC_HQTD_CFG            0x193C
     938#define HQTD_CFG_Q1_BURST_MASK      0x0000000F
     939#define HQTD_CFG_Q2_BURST_MASK      0x000000F0
     940#define HQTD_CFG_Q3_BURST_MASK      0x00000F00
     941#define HQTD_CFG_BURST_ENB      0x80000000
     942#define HQTD_CFG_Q1_BURST_SHIFT     0
     943#define HQTD_CFG_Q2_BURST_SHIFT     4
     944#define HQTD_CFG_Q3_BURST_SHIFT     8
     945
     946#define ALC_MISC            0x19C0
     947#define MISC_INTNLOSC_OPEN      0x00000008
     948#define MISC_ISO_ENB            0x00001000
     949#define MISC_PSW_OCP_MASK       0x00E00000
     950#define MISC_PSW_OCP_SHIFT      21
     951#define MISC_PSW_OCP_DEFAULT        7
     952
     953#define ALC_MISC2           0x19C8
     954#define MISC2_CALB_START        0x00000001
     955
     956#define ALC_MISC3           0x19CC
     957#define MISC3_25M_NOTO_INTNL        0x00000001
     958#define MISC3_25M_BY_SW         0x00000002
     959
    740960#define ALC_MII_DBG_ADDR        0x1D
    741961#define ALC_MII_DBG_DATA        0x1E
    742962
     
    756976#define ANA_SEL_CLK125M_DSP     0x8000
    757977#define ANA_MANUL_SWICH_ON_SHIFT    1
    758978
     979#define MII_DBG_ANACTL          0x00
     980#define DBG_ANACTL_DEFAULT      0x02EF
     981
    759982#define MII_ANA_CFG4            0x04
    760983#define ANA_IECHO_ADJ_MASK      0x0F
    761984#define ANA_IECHO_ADJ_3_MASK        0x000F
     
    767990#define ANA_IECHO_ADJ_1_SHIFT       8
    768991#define ANA_IECHO_ADJ_0_SHIFT       12
    769992
     993#define MII_DBG_SYSMODCTL       0x04
     994#define DBG_SYSMODCTL_DEFAULT       0xBB8B
     995
    770996#define MII_ANA_CFG5            0x05
    771997#define ANA_SERDES_CDR_BW_MASK      0x0003
    772998#define ANA_MS_PAD_DBG          0x0004
     
    7831009#define ANA_SERDES_CDR_BW_SHIFT     0
    7841010#define ANA_SERDES_TH_LOS_SHIFT     4
    7851011
     1012#define MII_DBG_SRDSYSMOD       0x05
     1013#define DBG_SRDSYSMOD_DEFAULT       0x2C46
     1014
    7861015#define MII_ANA_CFG11           0x0B
    7871016#define ANA_PS_HIB_EN           0x8000
    7881017
     1018#define MII_DBG_HIBNEG          0x0B
     1019#define DBG_HIBNEG_HIB_PULSE        0x1000
     1020#define DBG_HIBNEG_PSHIB_EN     0x8000
     1021#define DBG_HIBNEG_DEFAULT      0xBC40
     1022
    7891023#define MII_ANA_CFG18           0x12
    7901024#define ANA_TEST_MODE_10BT_01MASK   0x0003
    7911025#define ANA_LOOP_SEL_10BT       0x0004
     
    8001034#define ANA_TRIGGER_SEL_TIMER_SHIFT 12
    8011035#define ANA_INTERVAL_SEL_TIMER_SHIFT    14
    8021036
     1037#define MII_DBG_TST10BTCFG      0x12
     1038#define DBG_TST10BTCFG_DEFAULT      0x4C04
     1039
     1040#define MII_DBG_AZ_ANADECT      0x15
     1041#define DBG_AZ_ANADECT_DEFAULT      0x3220
     1042#define DBG_AZ_ANADECT_LONG     0x3210
     1043
     1044#define MII_DBG_MSE16DB         0x18
     1045#define DBG_MSE16DB_UP          0x05EA
     1046#define DBG_MSE16DB_DOWN        0x02EA
     1047
     1048#define MII_DBG_MSE20DB         0x1C
     1049#define DBG_MSE20DB_TH_MASK     0x01FC
     1050#define DBG_MSE20DB_TH_DEFAULT      0x2E
     1051#define DBG_MSE20DB_TH_HI       0x54
     1052#define DBG_MSE20DB_TH_SHIFT        2
     1053
     1054#define MII_DBG_AGC         0x23
     1055#define DBG_AGC_2_VGA_MASK      0x3F00
     1056#define DBG_AGC_2_VGA_SHIFT     8
     1057#define DBG_AGC_LONG1G_LIMT     40
     1058#define DBG_AGC_LONG100M_LIMT       44
     1059
    8031060#define MII_ANA_CFG41           0x29
    8041061#define ANA_TOP_PS_EN           0x8000
    8051062
     1063#define MII_DBG_LEGCYPS         0x29
     1064#define DBG_LEGCYPS_ENB         0x8000
     1065#define DBG_LEGCYPS_DEFAULT     0x129D
     1066
    8061067#define MII_ANA_CFG54           0x36
    8071068#define ANA_LONG_CABLE_TH_100_MASK  0x003F
    8081069#define ANA_DESERVED            0x0040
     
    8131074#define ANA_LONG_CABLE_TH_100_SHIFT 0
    8141075#define ANA_SHORT_CABLE_TH_100_SHIFT    8
    8151076
     1077#define MII_DBG_TST100BTCFG     0x36
     1078#define DBG_TST100BTCFG_DEFAULT     0xE12C
     1079
     1080#define MII_DBG_GREENCFG        0x3B
     1081#define DBG_GREENCFG_DEFAULT        0x7078
     1082
     1083#define MII_DBG_GREENCFG2       0x3D
     1084#define DBG_GREENCFG2_GATE_DFSE_EN  0x0080
     1085#define DBG_GREENCFG2_BP_GREEN      0x8000
     1086
     1087/* Device addr 3 */
     1088#define MII_EXT_PCS         3
     1089
     1090#define MII_EXT_CLDCTL3         0x8003
     1091#define EXT_CLDCTL3_BP_CABLE1TH_DET_GT  0x8000
     1092
     1093#define MII_EXT_CLDCTL5         0x8005
     1094#define EXT_CLDCTL5_BP_VD_HLFBIAS   0x4000
     1095
     1096#define MII_EXT_CLDCTL6         0x8006
     1097#define EXT_CLDCTL6_CAB_LEN_MASK    0x00FF
     1098#define EXT_CLDCTL6_CAB_LEN_SHIFT   0
     1099#define EXT_CLDCTL6_CAB_LEN_SHORT1G 116
     1100#define EXT_CLDCTL6_CAB_LEN_SHORT100M   152
     1101
     1102#define MII_EXT_VDRVBIAS        0x8062
     1103#define EXT_VDRVBIAS_DEFAULT        3
     1104
     1105/* Device addr 7 */
     1106#define MII_EXT_ANEG            7
     1107
     1108#define MII_EXT_ANEG_LOCAL_EEEADV   0x3C
     1109#define ANEG_LOCA_EEEADV_100BT      0x0002
     1110#define ANEG_LOCA_EEEADV_1000BT     0x0004
     1111
     1112#define MII_EXT_ANEG_AFE        0x801A
     1113#define ANEG_AFEE_10BT_100M_TH      0x0040
     1114
     1115#define MII_EXT_ANEG_S3DIG10        0x8023
     1116#define ANEG_S3DIG10_SL         0x0001
     1117#define ANEG_S3DIG10_DEFAULT        0
     1118
     1119#define MII_EXT_ANEG_NLP78      0x8027
     1120#define ANEG_NLP78_120M_DEFAULT     0x8A05
     1121
    8161122/* Statistics counters collected by the MAC. */
    8171123struct smb {
    8181124    /* Rx stats. */
    struct smb {  
    8601166    uint32_t tx_multi_colls;
    8611167    uint32_t tx_late_colls;
    8621168    uint32_t tx_excess_colls;
    863     uint32_t tx_abort;
    8641169    uint32_t tx_underrun;
    8651170    uint32_t tx_desc_underrun;
    8661171    uint32_t tx_lenerrs;
  • src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcvar.h

    diff --git a/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcvar.h b/src/add-ons/kernel/drivers/network/atheros813x/dev/alc/if_alcvar.h
    index f2d806f..a1c3382 100644
    a b  
    5252/* Water mark to kick reclaiming Tx buffers. */
    5353#define ALC_TX_DESC_HIWAT   ((ALC_TX_RING_CNT * 6) / 10)
    5454
     55/*
     56 * AR816x controllers support up to 16 messages but this driver
     57 * uses single message.
     58 */
    5559#define ALC_MSI_MESSAGES    1
    5660#define ALC_MSIX_MESSAGES   1
    5761
    struct alc_softc {  
    224228#define ALC_FLAG_PM     0x0010
    225229#define ALC_FLAG_FASTETHER  0x0020
    226230#define ALC_FLAG_JUMBO      0x0040
    227 #define ALC_FLAG_ASPM_MON   0x0080
    228231#define ALC_FLAG_CMB_BUG    0x0100
    229232#define ALC_FLAG_SMB_BUG    0x0200
    230233#define ALC_FLAG_L0S        0x0400
    231234#define ALC_FLAG_L1S        0x0800
    232235#define ALC_FLAG_APS        0x1000
    233 #define ALC_FLAG_LINK       0x8000
     236#define ALC_FLAG_AR816X_FAMILY  0x2000
     237#define ALC_FLAG_LINK_WAR   0x4000
     238#define ALC_FLAG_E2X00      0x8000
     239#define ALC_FLAG_LINK       0x10000
    234240
    235241    struct callout      alc_tick_ch;
    236242    struct alc_hw_stats alc_stats;
  • src/libs/compat/freebsd_network/compat/net/if_media.h

    diff --git a/src/libs/compat/freebsd_network/compat/net/if_media.h b/src/libs/compat/freebsd_network/compat/net/if_media.h
    index 4561637..a6ce67a 100644
    a b uint64_t ifmedia_baudrate(int);  
    145145#define IFM_10G_SR  19      /* 10GBase-SR 850nm Multi-mode */
    146146#define IFM_10G_CX4 20      /* 10GBase CX4 copper */
    147147#define IFM_2500_SX 21      /* 2500BaseSX - multi-mode fiber */
     148#define IFM_UNKNOWN 25      /* media types not defined yet */
     149
    148150
    149151/* note 31 is the max! */
    150152
    struct ifmedia_description {  
    352354    { IFM_10G_LR,   "10Gbase-LR" },                 \
    353355    { IFM_10G_SR,   "10Gbase-SR" },                 \
    354356    { IFM_10G_CX4,  "10Gbase-CX4" },                \
     357    { IFM_UNKNOWN,  "Unknown" },                    \
    355358    { IFM_2500_SX,  "2500BaseSX" },                 \
    356359    { 0, NULL },                            \
    357360}