root/dev/mii/ciphy.c

DEFINITIONS

1. ciphymatch
2. ciphyattach
3. ciphy_service
4. ciphy_status
5. ciphy_reset
6. ciphy_fixup

    1 /*      $OpenBSD: ciphy.c,v 1.18 2006/12/31 15:04:33 krw Exp $  */
    2 /*      $FreeBSD: ciphy.c,v 1.1 2004/09/10 20:57:45 wpaul Exp $ */
    3 /*
    4  * Copyright (c) 2004
    5  *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Bill Paul.
   18  * 4. Neither the name of the author nor the names of any co-contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
   26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   32  * THE POSSIBILITY OF SUCH DAMAGE.
   33  */
   35 /*
   36  * Driver for the Cicada CS8201 10/100/1000 copper PHY.
   37  */
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/kernel.h>
   42 #include <sys/device.h>
   43 #include <sys/socket.h>
   44 #include <sys/errno.h>
   46 #include <net/if.h>
   47 #include <net/if_media.h>
   49 #ifdef INET
   50 #include <netinet/in.h>
   51 #include <netinet/if_ether.h>
   52 #endif
   54 #include <dev/pci/pcivar.h>
   56 #include <dev/mii/mii.h>
   57 #include <dev/mii/miivar.h>
   58 #include <dev/mii/miidevs.h>
   60 #include <dev/mii/ciphyreg.h>
   62 #include <machine/bus.h>
   64 int     ciphymatch(struct device *, void *, void *);
   65 void    ciphyattach(struct device *, struct device *, void *);
   67 struct cfattach ciphy_ca = {
   68         sizeof(struct mii_softc),
ciphymatch,
ciphyattach,
mii_phy_detach,
mii_phy_activate
   73 };
   75 struct cfdriver ciphy_cd = {
NULL, "ciphy", DV_DULL
   77 };
   79 int     ciphy_service(struct mii_softc *, struct mii_data *, int);
   80 void    ciphy_status(struct mii_softc *);
   81 void    ciphy_reset(struct mii_softc *);
   82 void    ciphy_fixup(struct mii_softc *);
   84 const struct mii_phy_funcs ciphy_funcs = {
ciphy_service, ciphy_status, ciphy_reset,
   86 };
   88 static const struct mii_phydesc ciphys[] = {
   89         { MII_OUI_CICADA,               MII_MODEL_CICADA_CS8201,
MII_STR_CICADA_CS8201 },
   91         { MII_OUI_CICADA,               MII_MODEL_CICADA_CS8201A,
MII_STR_CICADA_CS8201A },
   93         { MII_OUI_CICADA,               MII_MODEL_CICADA_CS8201B,
MII_STR_CICADA_CS8201B },
   95         { MII_OUI_xxCICADA,             MII_MODEL_xxCICADA_CS8201B,
MII_STR_xxCICADA_CS8201B },
   98         { 0,                    0,
NULL },
  100 };
  102 int
ciphymatch(struct device *parent, void *match, void *aux)
  104 {
  105         struct mii_attach_args *ma = aux;
  107         if (mii_phy_match(ma, ciphys) != NULL)
  108                 return (10);
  110         return (0);
  111 }
  113 void
ciphyattach(struct device *parent, struct device *self, void *aux)
  115 {
  116         struct mii_softc *sc = (struct mii_softc *)self;
  117         struct mii_attach_args *ma = aux;
  118         struct mii_data *mii = ma->mii_data;
  119         const struct mii_phydesc *mpd;
mpd = mii_phy_match(ma, ciphys);
printf(": %s, rev. %d\n", mpd->mpd_name, MII_REV(ma->mii_id2));
sc->mii_inst = mii->mii_instance;
sc->mii_phy = ma->mii_phyno;
sc->mii_funcs = &ciphy_funcs;
sc->mii_pdata = mii;
sc->mii_flags = ma->mii_flags;
sc->mii_anegticks = MII_ANEGTICKS;
sc->mii_flags |= MIIF_NOISOLATE;
PHY_RESET(sc);
sc->mii_capabilities =
PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
  137         if (sc->mii_capabilities & BMSR_EXTSTAT)
sc->mii_extcapabilities = PHY_READ(sc, MII_EXTSR);
  139         if ((sc->mii_capabilities & BMSR_MEDIAMASK) ||
  140             (sc->mii_capabilities & EXTSR_MEDIAMASK))
mii_phy_add_media(sc);
  142 }
  144 int
ciphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
  146 {
  147         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
  148         int reg, speed, gig;
  150         switch (cmd) {
  151         case MII_POLLSTAT:
  152                 /*
  153                  * If we're not polling our PHY instance, just return.
  154                  */
  155                 if (IFM_INST(ife->ifm_media) != sc->mii_inst)
  156                         return (0);
  157                 break;
  159         case MII_MEDIACHG:
  160                 /*
  161                  * If the media indicates a different PHY instance,
  162                  * isolate ourselves.
  163                  */
  164                 if (IFM_INST(ife->ifm_media) != sc->mii_inst) {
reg = PHY_READ(sc, MII_BMCR);
PHY_WRITE(sc, MII_BMCR, reg | BMCR_ISO);
  167                         return (0);
  168                 }
  170                 /*
  171                  * If the interface is not up, don't do anything.
  172                  */
  173                 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
  174                         break;
ciphy_fixup(sc);        /* XXX hardware bug work-around */
  178                 switch (IFM_SUBTYPE(ife->ifm_media)) {
  179                 case IFM_AUTO:
  180                         if (mii_phy_auto(sc, 0) == EJUSTRETURN)
  181                                 return (0);
  182                         break;
  183                 case IFM_1000_T:
speed = CIPHY_S1000;
  185                         goto setit;
  186                 case IFM_100_TX:
speed = CIPHY_S100;
  188                         goto setit;
  189                 case IFM_10_T:
speed = CIPHY_S10;
setit:
  192                         if ((ife->ifm_media & IFM_GMASK) == IFM_FDX) {
speed |= CIPHY_BMCR_FDX;
gig = CIPHY_1000CTL_AFD;
  195                         } else {
gig = CIPHY_1000CTL_AHD;
  197                         }
PHY_WRITE(sc, CIPHY_MII_1000CTL, 0);
PHY_WRITE(sc, CIPHY_MII_BMCR, speed);
PHY_WRITE(sc, CIPHY_MII_ANAR, CIPHY_SEL_TYPE);
  203                         if (IFM_SUBTYPE(ife->ifm_media) != IFM_1000_T) 
  204                                 break;
PHY_WRITE(sc, CIPHY_MII_1000CTL, gig);
PHY_WRITE(sc, CIPHY_MII_BMCR,
speed|CIPHY_BMCR_AUTOEN|CIPHY_BMCR_STARTNEG);
  210                         if (mii->mii_media.ifm_media & IFM_ETH_MASTER)
gig |= CIPHY_1000CTL_MSE|CIPHY_1000CTL_MSC;
PHY_WRITE(sc, CIPHY_MII_1000CTL, gig);
  213                         break;
  214                 case IFM_NONE:
PHY_WRITE(sc, MII_BMCR, BMCR_ISO|BMCR_PDOWN);
  216                         break;
  217                 case IFM_100_T4:
  218                 default:
  219                         return (EINVAL);
  220                 }
  221                 break;
  223         case MII_TICK:
  224                 /*
  225                  * If we're not currently selected, just return.
  226                  */
  227                 if (IFM_INST(ife->ifm_media) != sc->mii_inst)
  228                         return (0);
  230                 if (mii_phy_tick(sc) == EJUSTRETURN)
  231                         return (0);
  232                 break;
  233         }
  235         /* Update the media status. */
mii_phy_status(sc);
  238         /*
  239          * Callback if something changed. Note that we need to poke
  240          * apply fixups for certain PHY revs.
  241          */
  242         if (sc->mii_media_active != mii->mii_media_active || 
sc->mii_media_status != mii->mii_media_status ||
cmd == MII_MEDIACHG) {
ciphy_fixup(sc);
  246         }
mii_phy_update(sc, cmd);
  248         return (0);
  249 }
  251 void
ciphy_status(struct mii_softc *sc)
  253 {
  254         struct mii_data *mii = sc->mii_pdata;
  255         int bmsr, bmcr, gsr;
mii->mii_media_status = IFM_AVALID;
mii->mii_media_active = IFM_ETHER;
bmsr = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
  262         if (bmsr & BMSR_LINK)
mii->mii_media_status |= IFM_ACTIVE;
bmcr = PHY_READ(sc, CIPHY_MII_BMCR);
  267         if (bmcr & CIPHY_BMCR_LOOP)
mii->mii_media_active |= IFM_LOOP;
  270         if (bmcr & CIPHY_BMCR_AUTOEN) {
  271                 if ((bmsr & CIPHY_BMSR_ACOMP) == 0) {
  272                         /* Erg, still trying, I guess... */
mii->mii_media_active |= IFM_NONE;
  274                         return;
  275                 }
  276         }
bmsr = PHY_READ(sc, CIPHY_MII_AUXCSR);
  279         switch (bmsr & CIPHY_AUXCSR_SPEED) {
  280         case CIPHY_SPEED10:
mii->mii_media_active |= IFM_10_T;
  282                 break;
  283         case CIPHY_SPEED100:
mii->mii_media_active |= IFM_100_TX;
  285                 break;
  286         case CIPHY_SPEED1000:
mii->mii_media_active |= IFM_1000_T;
  288                 break;
  289         default:
printf("%s: unknown PHY speed %x\n",
sc->mii_dev.dv_xname, bmsr & CIPHY_AUXCSR_SPEED);
  292                 break;
  293         }
  295         if (bmsr & CIPHY_AUXCSR_FDX)
mii->mii_media_active |= IFM_FDX;
  297         else
mii->mii_media_active |= IFM_HDX;
gsr = PHY_READ(sc, CIPHY_MII_1000STS);
  301         if ((IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T) &&
gsr & CIPHY_1000STS_MSR)
mii->mii_media_active |= IFM_ETH_MASTER;
  304 }
  306 void
ciphy_reset(struct mii_softc *sc)
  308 {
mii_phy_reset(sc);
DELAY(1000);
  311 }
  313 #define PHY_SETBIT(x, y, z) \
PHY_WRITE(x, y, (PHY_READ(x, y) | (z)))
  315 #define PHY_CLRBIT(x, y, z) \
PHY_WRITE(x, y, (PHY_READ(x, y) & ~(z)))
  318 void
ciphy_fixup(struct mii_softc *sc)
  320 {
uint16_t                model;
uint16_t                status, speed;
model = MII_MODEL(PHY_READ(sc, CIPHY_MII_PHYIDR2));
status = PHY_READ(sc, CIPHY_MII_AUXCSR);
speed = status & CIPHY_AUXCSR_SPEED;
  328         if (strcmp(sc->mii_dev.dv_parent->dv_cfdata->cf_driver->cd_name, "nfe") == 0) {
  329                 /* need to set for 2.5V RGMII for NVIDIA adapters */
PHY_SETBIT(sc, CIPHY_MII_ECTL1, CIPHY_INTSEL_RGMII);
PHY_SETBIT(sc, CIPHY_MII_ECTL1, CIPHY_IOVOL_2500MV);
  332         }
  334         switch (model) {
  335         case MII_MODEL_CICADA_CS8201:
  337                 /* Turn off "aux mode" (whatever that means) */
PHY_SETBIT(sc, CIPHY_MII_AUXCSR, CIPHY_AUXCSR_MDPPS);
  340                 /*
  341                  * Work around speed polling bug in VT3119/VT3216
  342                  * when using MII in full duplex mode.
  343                  */
  344                 if ((speed == CIPHY_SPEED10 || speed == CIPHY_SPEED100) &&
  345                     (status & CIPHY_AUXCSR_FDX)) {
PHY_SETBIT(sc, CIPHY_MII_10BTCSR, CIPHY_10BTCSR_ECHO);
  347                 } else {
PHY_CLRBIT(sc, CIPHY_MII_10BTCSR, CIPHY_10BTCSR_ECHO);
  349                 }
  351                 /* Enable link/activity LED blink. */
PHY_SETBIT(sc, CIPHY_MII_LED, CIPHY_LED_LINKACTBLINK);
  354                 break;
  356         case MII_MODEL_CICADA_CS8201A:
  357         case MII_MODEL_CICADA_CS8201B:
  359                 /*
  360                  * Work around speed polling bug in VT3119/VT3216
  361                  * when using MII in full duplex mode.
  362                  */
  363                 if ((speed == CIPHY_SPEED10 || speed == CIPHY_SPEED100) &&
  364                     (status & CIPHY_AUXCSR_FDX)) {
PHY_SETBIT(sc, CIPHY_MII_10BTCSR, CIPHY_10BTCSR_ECHO);
  366                 } else {
PHY_CLRBIT(sc, CIPHY_MII_10BTCSR, CIPHY_10BTCSR_ECHO);
  368                 }
  370                 break;
  371         default:
printf("%s: unknown CICADA PHY model %x\n",
sc->mii_dev.dv_xname, model);
  374                 break;
  375         }
  376 }