static void
igphy_smartspeed_workaround(struct mii_softc *sc)
{
struct igphy_softc *igsc = (struct igphy_softc *) sc;
uint16_t reg, gtsr, gtcr;
/* This workaround is only for 82541 and 82547 */
switch (igsc->sc_mactype) {
case WM_T_82541:
case WM_T_82541_2:
case WM_T_82547:
case WM_T_82547_2:
break;
default:
/* byebye */
return;
}
if ((PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN) == 0)
return;
/* XXX Assume 1000TX-FDX is advertized if doing autonegotiation. */
reg = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
if ((reg & BMSR_LINK) == 0) {
switch (igsc->sc_smartspeed) {
case 0:
gtsr = PHY_READ(sc, MII_100T2SR);
if (!(gtsr & GTSR_MAN_MS_FLT))
break;
gtsr = PHY_READ(sc, MII_100T2SR);
if (gtsr & GTSR_MAN_MS_FLT) {
gtcr = PHY_READ(sc, MII_100T2CR);
if (gtcr & GTCR_MAN_MS) {
gtcr &= ~GTCR_MAN_MS;
PHY_WRITE(sc, MII_100T2CR,
gtcr);
}
mii_phy_auto(sc, 0);
}
break;
case IGPHY_TICK_DOWNSHIFT:
gtcr = PHY_READ(sc, MII_100T2CR);
gtcr |= GTCR_MAN_MS;
PHY_WRITE(sc, MII_100T2CR, gtcr);
mii_phy_auto(sc, 0);
break;
default:
break;
}
if (igsc->sc_smartspeed++ == IGPHY_TICK_MAX)
igsc->sc_smartspeed = 0;
} else
igsc->sc_smartspeed = 0;
}
static int
tlphy_auto(struct tlphy_softc *sc, int waitfor)
{
int error;
switch ((error = mii_phy_auto(&sc->sc_mii, waitfor))) {
case EIO:
/*
* Just assume we're not in full-duplex mode.
* XXX Check link and try AUI/BNC?
*/
PHY_WRITE(&sc->sc_mii, MII_BMCR, 0);
break;
case EJUSTRETURN:
/* Flag that we need to program when it completes. */
sc->sc_need_acomp = 1;
break;
default:
tlphy_acomp(sc);
}
return (error);
}
/*
* If we negotiate a 10Mbps mode, we need to check for an alternate
* PHY and make sure it's enabled and set correctly.
*/
void
mlphy_status(struct mii_softc *sc)
{
struct mlphy_softc *msc = (struct mlphy_softc *)sc;
struct mii_data *mii = sc->mii_pdata;
struct mii_softc *other = NULL;
/* See if there's another PHY on the bus with us. */
LIST_FOREACH(other, &mii->mii_phys, mii_list)
if (other != sc)
break;
ukphy_status(sc);
if (IFM_SUBTYPE(mii->mii_media_active) != IFM_10_T) {
msc->ml_state = ML_STATE_AUTO_SELF;
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
}
if (IFM_SUBTYPE(mii->mii_media_active) == IFM_10_T) {
msc->ml_state = ML_STATE_AUTO_OTHER;
mlphy_reset(&msc->ml_mii);
PHY_WRITE(&msc->ml_mii, MII_BMCR, BMCR_ISO);
if (other != NULL) {
mii_phy_reset(other);
mii_phy_auto(other, 1);
}
}
}
void
mii_phy_setmedia(struct mii_softc *sc)
{
struct mii_data *mii = sc->mii_pdata;
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int bmcr, anar, gtcr;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
/*
* Force renegotiation if MIIF_DOPAUSE or MIIF_FORCEANEG.
* The former is necessary as we might switch from flow-
* control advertisment being off to on or vice versa.
*/
if ((PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN) == 0 ||
(sc->mii_flags & (MIIF_DOPAUSE | MIIF_FORCEANEG)) != 0)
(void)mii_phy_auto(sc);
return;
}
/*
* Table index is stored in the media entry.
*/
KASSERT(ife->ifm_data >=0 && ife->ifm_data < MII_NMEDIA,
("invalid ife->ifm_data (0x%x) in mii_phy_setmedia",
ife->ifm_data));
anar = mii_media_table[ife->ifm_data].mm_anar;
bmcr = mii_media_table[ife->ifm_data].mm_bmcr;
gtcr = mii_media_table[ife->ifm_data].mm_gtcr;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_1000_T) {
gtcr |= GTCR_MAN_MS;
if ((ife->ifm_media & IFM_ETH_MASTER) != 0)
gtcr |= GTCR_ADV_MS;
}
if ((ife->ifm_media & IFM_GMASK) == (IFM_FDX | IFM_FLOW) ||
(sc->mii_flags & MIIF_FORCEPAUSE) != 0) {
if ((sc->mii_flags & MIIF_IS_1000X) != 0)
anar |= ANAR_X_PAUSE_TOWARDS;
else {
anar |= ANAR_FC;
/* XXX Only 1000BASE-T has PAUSE_ASYM? */
if ((sc->mii_flags & MIIF_HAVE_GTCR) != 0 &&
(sc->mii_extcapabilities &
(EXTSR_1000THDX | EXTSR_1000TFDX)) != 0)
anar |= ANAR_X_PAUSE_ASYM;
}
}
if ((ife->ifm_media & IFM_LOOP) != 0)
bmcr |= BMCR_LOOP;
PHY_WRITE(sc, MII_ANAR, anar);
PHY_WRITE(sc, MII_BMCR, bmcr);
if ((sc->mii_flags & MIIF_HAVE_GTCR) != 0)
PHY_WRITE(sc, MII_100T2CR, gtcr);
}
int
mii_phy_tick(struct mii_softc *sc)
{
struct ifmedia_entry *ife = sc->mii_pdata->mii_media.ifm_cur;
struct ifnet *ifp = sc->mii_pdata->mii_ifp;
int reg;
/* Just bail now if the interface is down. */
if ((ifp->if_flags & IFF_UP) == 0)
return (EJUSTRETURN);
/*
* If we're not doing autonegotiation, we don't need to do
* any extra work here. However, we need to check the link
* status so we can generate an announcement if the status
* changes.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO) {
sc->mii_ticks = 0; /* reset autonegotiation timer. */
return (0);
}
/* Read the status register twice; BMSR_LINK is latch-low. */
reg = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
if (reg & BMSR_LINK) {
sc->mii_ticks = 0; /* reset autonegotiation timer. */
/* See above. */
return (0);
}
/* Announce link loss right after it happens */
if (sc->mii_ticks++ == 0)
return (0);
/* XXX: use default value if phy driver did not set mii_anegticks */
if (sc->mii_anegticks == 0)
sc->mii_anegticks = MII_ANEGTICKS_GIGE;
/* Only retry autonegotiation every mii_anegticks ticks. */
if (sc->mii_ticks <= sc->mii_anegticks)
return (EJUSTRETURN);
sc->mii_ticks = 0;
mii_phy_reset(sc);
mii_phy_auto(sc);
return (0);
}
void
mii_phy_setmedia(struct mii_softc *sc)
{
struct mii_data *mii = sc->mii_pdata;
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int bmcr, anar, gtcr;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
if ((PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN) == 0 ||
(sc->mii_flags & MIIF_FORCEANEG))
(void) mii_phy_auto(sc, 1);
return;
}
/*
* Table index is stored in the media entry.
*/
#ifdef DIAGNOSTIC
if (ife->ifm_data < 0 || ife->ifm_data >= MII_NMEDIA)
panic("mii_phy_setmedia");
#endif
anar = mii_media_table[ife->ifm_data].mm_anar;
bmcr = mii_media_table[ife->ifm_data].mm_bmcr;
gtcr = mii_media_table[ife->ifm_data].mm_gtcr;
if (mii->mii_media.ifm_media & IFM_ETH_MASTER) {
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_1000_T:
gtcr |= GTCR_MAN_MS|GTCR_ADV_MS;
break;
default:
panic("mii_phy_setmedia: MASTER on wrong media");
}
}
if (ife->ifm_media & IFM_LOOP)
bmcr |= BMCR_LOOP;
PHY_WRITE(sc, MII_ANAR, anar);
PHY_WRITE(sc, MII_BMCR, bmcr);
if (sc->mii_flags & MIIF_HAVE_GTCR)
PHY_WRITE(sc, MII_100T2CR, gtcr);
}
/*
* If we negotiate a 10Mbps mode, we need to check for an alternate
* PHY and make sure it's enabled and set correctly.
*/
static void
mlphy_status(struct mii_softc *sc)
{
struct mlphy_softc *msc = (struct mlphy_softc *)sc;
struct mii_data *mii = msc->ml_mii.mii_pdata;
struct mii_softc *other = NULL;
device_t *devlist;
int devs, i;
/* See if there's another PHY on the bus with us. */
device_get_children(msc->ml_mii.mii_dev, &devlist, &devs);
for (i = 0; i < devs; i++) {
if (strcmp(device_get_name(devlist[i]), "mlphy")) {
other = device_get_softc(devlist[i]);
break;
}
}
kfree(devlist, M_TEMP);
if (other == NULL)
return;
ukphy_status(sc);
if (IFM_SUBTYPE(mii->mii_media_active) != IFM_10_T) {
msc->ml_state = ML_STATE_AUTO_SELF;
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
if (IFM_SUBTYPE(mii->mii_media_active) == IFM_10_T) {
msc->ml_state = ML_STATE_AUTO_OTHER;
mlphy_reset(&msc->ml_mii);
PHY_WRITE(&msc->ml_mii, MII_BMCR, BMCR_ISO);
mii_phy_reset(other);
mii_phy_auto(other, 1);
}
}
void
mii_phy_setmedia(struct mii_softc *sc)
{
struct mii_data *mii = sc->mii_pdata;
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int bmcr, anar, gtcr;
int index = -1;
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
/*
* Force renegotiation if MIIF_DOPAUSE or MIIF_FORCEANEG.
* The former is necessary as we might switch from flow-
* control advertisement being off to on or vice versa.
*/
if ((PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN) == 0 ||
(sc->mii_flags & (MIIF_DOPAUSE | MIIF_FORCEANEG)) != 0)
(void)mii_phy_auto(sc);
return;
case IFM_NONE:
index = MII_MEDIA_NONE;
break;
case IFM_HPNA_1:
index = MII_MEDIA_10_T;
break;
case IFM_10_T:
switch (IFM_OPTIONS(ife->ifm_media)) {
case 0:
index = MII_MEDIA_10_T;
break;
case IFM_FDX:
case (IFM_FDX | IFM_FLOW):
index = MII_MEDIA_10_T_FDX;
break;
}
break;
case IFM_100_TX:
case IFM_100_FX:
switch (IFM_OPTIONS(ife->ifm_media)) {
case 0:
index = MII_MEDIA_100_TX;
break;
case IFM_FDX:
case (IFM_FDX | IFM_FLOW):
index = MII_MEDIA_100_TX_FDX;
break;
}
break;
case IFM_100_T4:
index = MII_MEDIA_100_T4;
break;
case IFM_1000_SX:
switch (IFM_OPTIONS(ife->ifm_media)) {
case 0:
index = MII_MEDIA_1000_X;
break;
case IFM_FDX:
case (IFM_FDX | IFM_FLOW):
index = MII_MEDIA_1000_X_FDX;
break;
}
break;
case IFM_1000_T:
switch (IFM_OPTIONS(ife->ifm_media)) {
case 0:
case IFM_ETH_MASTER:
index = MII_MEDIA_1000_T;
break;
case IFM_FDX:
case (IFM_FDX | IFM_ETH_MASTER):
case (IFM_FDX | IFM_FLOW):
case (IFM_FDX | IFM_FLOW | IFM_ETH_MASTER):
index = MII_MEDIA_1000_T_FDX;
break;
}
break;
}
KASSERT(index != -1, ("%s: failed to map media word %d",
__func__, ife->ifm_media));
anar = mii_media_table[index].mm_anar;
bmcr = mii_media_table[index].mm_bmcr;
gtcr = mii_media_table[index].mm_gtcr;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_1000_T) {
gtcr |= GTCR_MAN_MS;
if ((ife->ifm_media & IFM_ETH_MASTER) != 0)
gtcr |= GTCR_ADV_MS;
}
if ((ife->ifm_media & IFM_FDX) != 0 &&
((ife->ifm_media & IFM_FLOW) != 0 ||
(sc->mii_flags & MIIF_FORCEPAUSE) != 0)) {
if ((sc->mii_flags & MIIF_IS_1000X) != 0)
anar |= ANAR_X_PAUSE_TOWARDS;
else {
anar |= ANAR_FC;
/* XXX Only 1000BASE-T has PAUSE_ASYM? */
if ((sc->mii_flags & MIIF_HAVE_GTCR) != 0 &&
(sc->mii_extcapabilities &
(EXTSR_1000THDX | EXTSR_1000TFDX)) != 0)
anar |= ANAR_X_PAUSE_ASYM;
}
}
PHY_WRITE(sc, MII_ANAR, anar);
PHY_WRITE(sc, MII_BMCR, bmcr);
if ((sc->mii_flags & MIIF_HAVE_GTCR) != 0)
PHY_WRITE(sc, MII_100T2CR, gtcr);
}
int
rlphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int rv;
/*
* Can't isolate the RTL8139 phy, so it has to be the only one.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
panic("rlphy_service: attempt to isolate phy");
switch (cmd) {
case MII_POLLSTAT:
break;
case MII_MEDIACHG:
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
/*
* If we're already in auto mode, just return.
*/
if (PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN)
return (0);
(void) mii_phy_auto(sc, 0);
break;
case IFM_100_T4:
/*
* XXX Not supported as a manual setting right now.
*/
return (EINVAL);
default:
/*
* BMCR data is stored in the ifmedia entry.
*/
switch (ife->ifm_media &
(IFM_TMASK|IFM_NMASK|IFM_FDX)) {
case IFM_ETHER|IFM_10_T:
rv = ANAR_10|ANAR_CSMA;
break;
case IFM_ETHER|IFM_10_T|IFM_FDX:
rv = ANAR_10_FD|ANAR_CSMA;
break;
case IFM_ETHER|IFM_100_TX:
rv = ANAR_TX|ANAR_CSMA;
break;
case IFM_ETHER|IFM_100_TX|IFM_FDX:
rv = ANAR_TX_FD|ANAR_CSMA;
break;
case IFM_ETHER|IFM_100_T4:
rv = ANAR_T4|ANAR_CSMA;
break;
default:
rv = 0;
break;
}
PHY_WRITE(sc, MII_ANAR, rv);
PHY_WRITE(sc, MII_BMCR, ife->ifm_data);
}
break;
case MII_TICK:
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* The RealTek PHY's autonegotiation doesn't need to be
* kicked; it continues in the background.
*/
break;
case MII_DOWN:
mii_phy_down(sc);
return (0);
}
/* Update the media status. */
mii_phy_status(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
static int
ruephy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg;
switch (cmd) {
case MII_POLLSTAT:
break;
case MII_MEDIACHG:
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
mii_phy_setmedia(sc);
break;
case MII_TICK:
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the MSR twice in case it's latched.
*/
reg = PHY_READ(sc, RUEPHY_MII_MSR) |
PHY_READ(sc, RUEPHY_MII_MSR);
if (reg & RUEPHY_MSR_LINK)
break;
/* Only retry autonegotiation every mii_anegticks seconds. */
if (sc->mii_ticks <= sc->mii_anegticks)
break;
sc->mii_ticks = 0;
PHY_RESET(sc);
if (mii_phy_auto(sc) == EJUSTRETURN)
return (0);
break;
}
/* Update the media status. */
PHY_STATUS(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
static int
ciphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg, speed, gig;
switch (cmd) {
case MII_POLLSTAT:
break;
case MII_MEDIACHG:
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
ciphy_fixup(sc); /* XXX hardware bug work-around */
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
#ifdef foo
/*
* If we're already in auto mode, just return.
*/
if (PHY_READ(sc, CIPHY_MII_BMCR) & CIPHY_BMCR_AUTOEN)
return (0);
#endif
(void)mii_phy_auto(sc);
break;
case IFM_1000_T:
speed = CIPHY_S1000;
goto setit;
case IFM_100_TX:
speed = CIPHY_S100;
goto setit;
case IFM_10_T:
speed = CIPHY_S10;
setit:
if ((ife->ifm_media & IFM_FDX) != 0) {
speed |= CIPHY_BMCR_FDX;
gig = CIPHY_1000CTL_AFD;
} else
gig = CIPHY_1000CTL_AHD;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_1000_T) {
gig |= CIPHY_1000CTL_MSE;
if ((ife->ifm_media & IFM_ETH_MASTER) != 0)
gig |= CIPHY_1000CTL_MSC;
speed |=
CIPHY_BMCR_AUTOEN | CIPHY_BMCR_STARTNEG;
} else
gig = 0;
PHY_WRITE(sc, CIPHY_MII_1000CTL, gig);
PHY_WRITE(sc, CIPHY_MII_BMCR, speed);
PHY_WRITE(sc, CIPHY_MII_ANAR, CIPHY_SEL_TYPE);
break;
case IFM_NONE:
PHY_WRITE(sc, MII_BMCR, BMCR_ISO | BMCR_PDOWN);
break;
default:
return (EINVAL);
}
break;
case MII_TICK:
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the BMSR twice in case it's latched.
*/
reg = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
if (reg & BMSR_LINK)
break;
/* Announce link loss right after it happens. */
if (++sc->mii_ticks == 0)
break;
/*
* Only retry autonegotiation every mii_anegticks seconds.
*/
if (sc->mii_ticks <= sc->mii_anegticks)
break;
sc->mii_ticks = 0;
mii_phy_auto(sc);
break;
}
/* Update the media status. */
PHY_STATUS(sc);
/*
* Callback if something changed. Note that we need to poke
* apply fixups for certain PHY revs.
*/
if (sc->mii_media_active != mii->mii_media_active ||
sc->mii_media_status != mii->mii_media_status ||
cmd == MII_MEDIACHG) {
ciphy_fixup(sc);
}
mii_phy_update(sc, cmd);
return (0);
}
static int
ruephy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg;
/*
* We can't isolate the RealTek RTL8150 PHY,
* so it has to be the only one!
*/
KASSERT(IFM_INST(ife->ifm_media) == sc->mii_inst,
("ruephy_service: can't isolate RealTek RTL8150 PHY"));
switch (cmd) {
case MII_POLLSTAT:
break;
case MII_MEDIACHG:
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_100_T4) {
/*
* XXX Not supported as a manual setting right now.
*/
return (EINVAL);
}
mii_phy_set_media(sc);
break;
case MII_TICK:
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the MSR twice in case it's latched.
*/
reg = PHY_READ(sc, RUEPHY_MII_MSR) |
PHY_READ(sc, RUEPHY_MII_MSR);
if (reg & RUEPHY_MSR_LINK) {
sc->mii_ticks = 0;
break;
}
/*
* Only retry autonegotiation every 5 seconds.
*/
if (++sc->mii_ticks != 5)
return (0);
sc->mii_ticks = 0;
ruephy_reset(sc);
if (mii_phy_auto(sc, 0) == EJUSTRETURN)
return (0);
break;
}
/* Update the media status. */
ruephy_status(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
static int
ciphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg, speed, gig;
switch (cmd) {
case MII_POLLSTAT:
/*
* If we're not polling our PHY instance, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
break;
case MII_MEDIACHG:
/*
* If the media indicates a different PHY instance,
* isolate ourselves.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst) {
reg = PHY_READ(sc, MII_BMCR);
PHY_WRITE(sc, MII_BMCR, reg | BMCR_ISO);
return (0);
}
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
ciphy_fixup(sc); /* XXX hardware bug work-around */
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
#ifdef foo
/*
* If we're already in auto mode, just return.
*/
if (PHY_READ(sc, CIPHY_MII_BMCR) & CIPHY_BMCR_AUTOEN)
return (0);
#endif
(void) mii_phy_auto(sc);
break;
case IFM_1000_T:
speed = CIPHY_S1000;
goto setit;
case IFM_100_TX:
speed = CIPHY_S100;
goto setit;
case IFM_10_T:
speed = CIPHY_S10;
setit:
if ((ife->ifm_media & IFM_GMASK) == IFM_FDX) {
speed |= CIPHY_BMCR_FDX;
gig = CIPHY_1000CTL_AFD;
} else {
gig = CIPHY_1000CTL_AHD;
}
PHY_WRITE(sc, CIPHY_MII_1000CTL, 0);
PHY_WRITE(sc, CIPHY_MII_BMCR, speed);
PHY_WRITE(sc, CIPHY_MII_ANAR, CIPHY_SEL_TYPE);
if (IFM_SUBTYPE(ife->ifm_media) != IFM_1000_T)
break;
PHY_WRITE(sc, CIPHY_MII_1000CTL, gig);
PHY_WRITE(sc, CIPHY_MII_BMCR,
speed|CIPHY_BMCR_AUTOEN|CIPHY_BMCR_STARTNEG);
/*
* When setting the link manually, one side must
* be the master and the other the slave. However
* ifmedia doesn't give us a good way to specify
* this, so we fake it by using one of the LINK
* flags. If LINK0 is set, we program the PHY to
* be a master, otherwise it's a slave.
*/
if ((mii->mii_ifp->if_flags & IFF_LINK0)) {
PHY_WRITE(sc, CIPHY_MII_1000CTL,
gig|CIPHY_1000CTL_MSE|CIPHY_1000CTL_MSC);
} else {
PHY_WRITE(sc, CIPHY_MII_1000CTL,
gig|CIPHY_1000CTL_MSE);
}
break;
case IFM_NONE:
PHY_WRITE(sc, MII_BMCR, BMCR_ISO|BMCR_PDOWN);
break;
case IFM_100_T4:
default:
return (EINVAL);
}
break;
case MII_TICK:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the BMSR twice in case it's latched.
*/
reg = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
if (reg & BMSR_LINK)
break;
/* Announce link loss right after it happens. */
if (++sc->mii_ticks == 0)
break;
/*
* Only retry autonegotiation every mii_anegticks seconds.
*/
if (sc->mii_ticks <= sc->mii_anegticks)
break;
sc->mii_ticks = 0;
mii_phy_auto(sc);
break;
}
/* Update the media status. */
ciphy_status(sc);
/*
* Callback if something changed. Note that we need to poke
* apply fixups for certain PHY revs.
*/
if (sc->mii_media_active != mii->mii_media_active ||
sc->mii_media_status != mii->mii_media_status ||
cmd == MII_MEDIACHG) {
ciphy_fixup(sc);
}
mii_phy_update(sc, cmd);
return (0);
}
int
urlphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg;
DPRINTF(("%s: %s: enter\n", sc->mii_dev.dv_xname, __func__));
if ((sc->mii_dev.dv_flags & DVF_ACTIVE) == 0)
return (ENXIO);
switch (cmd) {
case MII_POLLSTAT:
/*
* If we're not polling our PHY instance, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
break;
case MII_MEDIACHG:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/* If the interface is not up, don't do anything. */
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
mii_phy_setmedia(sc);
break;
case MII_TICK:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/* Just bail now if the interface is down. */
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* If we're not doing autonegotiation, we don't need to do
* any extra work here. However, we need to check the link
* status so we can generate an announcement if the status
* changes.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
return (0);
/* Read the status register twice; MSR_LINK is latch-low. */
reg = PHY_READ(sc, URLPHY_MSR) | PHY_READ(sc, URLPHY_MSR);
if (reg & URLPHY_MSR_LINK) {
sc->mii_ticks = 0;
break;
}
/*
* Only retry autonegotiation every mii_anegticks seconds.
*/
if (++sc->mii_ticks <= sc->mii_anegticks)
return (0);
sc->mii_ticks = 0;
PHY_RESET(sc);
if (mii_phy_auto(sc, 0) == EJUSTRETURN)
return (0);
break;
case MII_DOWN:
mii_phy_down(sc);
return (0);
}
/* Update the media status. */
mii_phy_status(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
void
mii_phy_setmedia(struct mii_softc *sc)
{
struct mii_data *mii = sc->mii_pdata;
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int bmcr, anar, gtcr;
if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
/*
* Force renegotiation if MIIF_DOPAUSE.
*
* XXX This is only necessary because many NICs don't
* XXX advertise PAUSE capabilities at boot time. Maybe
* XXX we should force this only once?
*/
if ((PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN) == 0 ||
(sc->mii_flags & (MIIF_FORCEANEG|MIIF_DOPAUSE)))
(void) mii_phy_auto(sc, 1);
return;
}
/*
* Table index is stored in the media entry.
*/
#ifdef DIAGNOSTIC
if (/* ife->ifm_data < 0 || */ ife->ifm_data >= MII_NMEDIA)
panic("mii_phy_setmedia");
#endif
anar = mii_media_table[ife->ifm_data].mm_anar;
bmcr = mii_media_table[ife->ifm_data].mm_bmcr;
gtcr = mii_media_table[ife->ifm_data].mm_gtcr;
if (mii->mii_media.ifm_media & IFM_ETH_MASTER) {
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_1000_T:
gtcr |= GTCR_MAN_MS|GTCR_ADV_MS;
break;
default:
panic("mii_phy_setmedia: MASTER on wrong media");
}
}
if (mii->mii_media.ifm_media & IFM_FLOW) {
if (sc->mii_flags & MIIF_IS_1000X)
anar |= ANAR_X_PAUSE_SYM | ANAR_X_PAUSE_ASYM;
else {
anar |= ANAR_FC;
/* XXX Only 1000BASE-T has PAUSE_ASYM? */
if ((sc->mii_flags & MIIF_HAVE_GTCR) &&
(sc->mii_extcapabilities &
(EXTSR_1000THDX|EXTSR_1000TFDX)))
anar |= ANAR_X_PAUSE_ASYM;
}
}
if (ife->ifm_media & IFM_LOOP)
bmcr |= BMCR_LOOP;
PHY_WRITE(sc, MII_ANAR, anar);
PHY_WRITE(sc, MII_BMCR, bmcr);
if (sc->mii_flags & MIIF_HAVE_GTCR)
PHY_WRITE(sc, MII_100T2CR, gtcr);
}
int
mlphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
struct mii_softc *other = NULL;
struct mlphy_softc *msc = (struct mlphy_softc *)sc;
int other_inst, reg;
LIST_FOREACH(other, &mii->mii_phys, mii_list)
if (other != sc)
break;
if ((sc->mii_dev.dv_flags & DVF_ACTIVE) == 0)
return (ENXIO);
switch (cmd) {
case MII_POLLSTAT:
/*
* If we're not polling our PHY instance, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
break;
case MII_MEDIACHG:
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
msc->ml_state = ML_STATE_AUTO_SELF;
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
(void)mii_phy_auto(sc, 0);
msc->ml_linked = 0;
break;
case IFM_10_T:
/*
* For 10baseT modes, reset and program the
* companion PHY (of any), then setup ourselves
* to match. This will put us in pass-through
* mode and let the companion PHY do all the
* work.
* BMCR data is stored in the ifmedia entry.
*/
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, ife->ifm_data);
}
mii_phy_setmedia(sc);
msc->ml_state = 0;
break;
case IFM_100_TX:
/*
* For 100baseTX modes, reset and isolate the
* companion PHY (if any), then setup ourselves
* accordingly.
*
* BMCR data is stored in the ifmedia entry.
*/
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
mii_phy_setmedia(sc);
msc->ml_state = 0;
break;
default:
return (EINVAL);
}
break;
case MII_TICK:
/*
* If interface is not up, don't do anything
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the BMSR twice in case it's latched.
* If we're in a 10Mbps mode, check the link of the
* 10Mbps PHY. Sometimes the Micro Linear PHY's
* linkstat bit will clear while the linkstat bit of
* the companion PHY will remain set.
*/
if (msc->ml_state == ML_STATE_AUTO_OTHER) {
reg = PHY_READ(other, MII_BMSR) |
PHY_READ(other, MII_BMSR);
} else {
reg = PHY_READ(sc, MII_BMSR) |
PHY_READ(sc, MII_BMSR);
}
if (reg & BMSR_LINK) {
if (!msc->ml_linked) {
msc->ml_linked = 1;
mlphy_status(sc);
}
sc->mii_ticks = 0;
break;
}
/*
* Only retry autonegotiation every 5 seconds.
*/
if (++sc->mii_ticks <= MII_ANEGTICKS)
break;
sc->mii_ticks = 0;
msc->ml_linked = 0;
mii->mii_media_active = IFM_NONE;
mii_phy_reset(sc);
msc->ml_state = ML_STATE_AUTO_SELF;
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
mii_phy_auto(sc, 0);
break;
case MII_DOWN:
mii_phy_down(sc);
return (0);
}
/* Update the media status. */
if (msc->ml_state == ML_STATE_AUTO_OTHER && other != NULL) {
other_inst = other->mii_inst;
other->mii_inst = sc->mii_inst;
if (IFM_INST(ife->ifm_media) == other->mii_inst)
(void) PHY_SERVICE(other, mii, MII_POLLSTAT);
other->mii_inst = other_inst;
sc->mii_media_active = other->mii_media_active;
sc->mii_media_status = other->mii_media_status;
} else
ukphy_status(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
static int
mlphy_service(struct mii_softc *xsc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg;
struct mii_softc *other = NULL;
struct mlphy_softc *msc = (struct mlphy_softc *)xsc;
struct mii_softc *sc = &msc->ml_mii;
device_t *devlist;
int devs, i;
const struct mii_media *mm;
/*
* See if there's another PHY on this bus with us.
* If so, we may need it for 10Mbps modes.
*/
device_get_children(msc->ml_mii.mii_dev, &devlist, &devs);
for (i = 0; i < devs; i++) {
if (strcmp(device_get_name(devlist[i]), "mlphy")) {
other = device_get_softc(devlist[i]);
break;
}
}
kfree(devlist, M_TEMP);
KKASSERT(ife->ifm_data >= 0 && ife->ifm_data < MII_NMEDIA);
mm = &mii_media_table[ife->ifm_data];
switch (cmd) {
case MII_POLLSTAT:
/*
* If we're not polling our PHY instance, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
break;
case MII_MEDIACHG:
/*
* If the media indicates a different PHY instance,
* isolate ourselves.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst) {
reg = PHY_READ(sc, MII_BMCR);
PHY_WRITE(sc, MII_BMCR, reg | BMCR_ISO);
return (0);
}
/*
* If the interface is not up, don't do anything.
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
switch (IFM_SUBTYPE(ife->ifm_media)) {
case IFM_AUTO:
/*
* For autonegotiation, reset and isolate the
* companion PHY (if any) and then do NWAY
* autonegotiation ourselves.
*/
msc->ml_state = ML_STATE_AUTO_SELF;
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
mii_phy_auto(sc, 1);
msc->ml_linked = 0;
return(0);
case IFM_10_T:
/*
* For 10baseT modes, reset and program the
* companion PHY (of any), then program ourselves
* to match. This will put us in pass-through
* mode and let the companion PHY do all the
* work.
*/
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, mm->mm_bmcr);
}
PHY_WRITE(sc, MII_ANAR, mm->mm_anar);
PHY_WRITE(sc, MII_BMCR, mm->mm_bmcr);
msc->ml_state = 0;
break;
case IFM_100_TX:
/*
* For 100baseTX modes, reset and isolate the
* companion PHY (if any), then program ourselves
* accordingly.
*/
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
PHY_WRITE(sc, MII_ANAR, mm->mm_anar);
PHY_WRITE(sc, MII_BMCR, mm->mm_bmcr);
msc->ml_state = 0;
break;
case IFM_100_T4:
/*
* XXX Not supported as a manual setting right now.
*/
return (EINVAL);
default:
break;
}
break;
case MII_TICK:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/*
* Is the interface even up?
*/
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* Only used for autonegotiation.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/*
* Check to see if we have link. If we do, we don't
* need to restart the autonegotiation process. Read
* the BMSR twice in case it's latched.
* If we're in a 10Mbps mode, check the link of the
* 10Mbps PHY. Sometimes the Micro Linear PHY's
* linkstat bit will clear while the linkstat bit of
* the companion PHY will remain set.
*/
if (msc->ml_state == ML_STATE_AUTO_OTHER) {
reg = PHY_READ(other, MII_BMSR) |
PHY_READ(other, MII_BMSR);
} else {
reg = PHY_READ(sc, MII_BMSR) |
PHY_READ(sc, MII_BMSR);
}
if (reg & BMSR_LINK) {
if (!msc->ml_linked) {
msc->ml_linked = 1;
mlphy_status(sc);
}
sc->mii_ticks = 0;
break;
}
/*
* Only retry autonegotiation every 5 seconds.
*/
if (++sc->mii_ticks <= sc->mii_anegticks)
return (0);
sc->mii_ticks = 0;
msc->ml_linked = 0;
mii->mii_media_active = IFM_NONE;
mii_phy_reset(sc);
msc->ml_state = ML_STATE_AUTO_SELF;
if (other != NULL) {
mii_phy_reset(other);
PHY_WRITE(other, MII_BMCR, BMCR_ISO);
}
if (mii_phy_auto(sc, 0) == EJUSTRETURN)
return(0);
break;
}
/* Update the media status. */
if (msc->ml_state == ML_STATE_AUTO_OTHER) {
int other_inst;
other_inst = other->mii_inst;
other->mii_inst = sc->mii_inst;
other->mii_service(other, mii, MII_POLLSTAT);
other->mii_inst = other_inst;
sc->mii_media_active = other->mii_media_active;
sc->mii_media_status = other->mii_media_status;
} else {
ukphy_status(sc);
}
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
static int
urlphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
{
struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
int reg;
DPRINTF(("%s: %s: enter\n", device_xname(sc->mii_dev), __func__));
switch (cmd) {
case MII_POLLSTAT:
/*
* If we're not polling our PHY instance, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
break;
case MII_MEDIACHG:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/* If the interface is not up, don't do anything. */
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
break;
mii_phy_setmedia(sc);
break;
case MII_TICK:
/*
* If we're not currently selected, just return.
*/
if (IFM_INST(ife->ifm_media) != sc->mii_inst)
return (0);
/* Just bail now if the interface is down. */
if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
return (0);
/*
* If we're not doing autonegotiation, we don't need to do
* any extra work here. However, we need to check the link
* status so we can generate an announcement if the status
* changes.
*/
if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
break;
/* Read the status register twice; MSR_LINK is latch-low. */
reg = PHY_READ(sc, URLPHY_MSR) | PHY_READ(sc, URLPHY_MSR);
if (reg & URLPHY_MSR_LINK) {
/*
* Reset autonegotiation timer to 0 in case the link
* goes down in the next tick.
*/
sc->mii_ticks = 0;
/* See above. */
break;
}
/*
* mii_ticks == 0 means it's the first tick after changing the
* media or the link became down since the last tick (see
* above), so break to update the status.
*/
if (sc->mii_ticks++ == 0)
break;
/*
* Only retry autonegotiation every N seconds.
*/
KASSERT(sc->mii_anegticks != 0);
if (sc->mii_ticks <= sc->mii_anegticks)
return (0);
PHY_RESET(sc);
if (mii_phy_auto(sc, 0) == EJUSTRETURN)
return (0);
break;
case MII_DOWN:
mii_phy_down(sc);
return (0);
}
/* Update the media status. */
mii_phy_status(sc);
/* Callback if something changed. */
mii_phy_update(sc, cmd);
return (0);
}
