sys/dev/mii/ip1000phy.c

   1 /*-
   2  * Copyright (c) 2006, Pyun YongHyeon <yongari@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  * Driver for the IC Plus IP1000A/IP1001 10/100/1000 PHY.
  34  */
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/kernel.h>
  39 #include <sys/module.h>
  40 #include <sys/socket.h>
  41 #include <sys/bus.h>
  42
  43 #include <net/if.h>
  44 #include <net/if_media.h>
  45
  46 #include <dev/mii/mii.h>
  47 #include <dev/mii/miivar.h>
  48 #include "miidevs.h"
  49
  50 #include <dev/mii/ip1000phyreg.h>
  51
  52 #include "miibus_if.h"
  53
  54 #include <machine/bus.h>
  55 #include <dev/stge/if_stgereg.h>
  56
  57 static int ip1000phy_probe(device_t);
  58 static int ip1000phy_attach(device_t);
  59
  60 struct ip1000phy_softc {
  61         struct mii_softc mii_sc;
  62         int model;
  63         int revision;
  64 };
  65
  66 static device_method_t ip1000phy_methods[] = {
  67         /* device interface */
  68         DEVMETHOD(device_probe,         ip1000phy_probe),
  69         DEVMETHOD(device_attach,        ip1000phy_attach),
  70         DEVMETHOD(device_detach,        mii_phy_detach),
  71         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  72         { 0, 0 }
  73 };
  74
  75 static devclass_t ip1000phy_devclass;
  76 static driver_t ip1000phy_driver = {
  77         "ip1000phy",
  78         ip1000phy_methods,
  79         sizeof (struct mii_softc)
  80 };
  81
  82 DRIVER_MODULE(ip1000phy, miibus, ip1000phy_driver, ip1000phy_devclass, 0, 0);
  83
  84 static int      ip1000phy_service(struct mii_softc *, struct mii_data *, int);
  85 static void     ip1000phy_status(struct mii_softc *);
  86 static void     ip1000phy_reset(struct mii_softc *);
  87 static int      ip1000phy_mii_phy_auto(struct mii_softc *, int);
  88
  89 static const struct mii_phydesc ip1000phys[] = {
  90         MII_PHY_DESC(ICPLUS, IP1000A),
  91         MII_PHY_DESC(ICPLUS, IP1001),
  92         MII_PHY_END
  93 };
  94
  95 static int
  96 ip1000phy_probe(device_t dev)
  97 {
  98
  99         return (mii_phy_dev_probe(dev, ip1000phys, BUS_PROBE_DEFAULT));
 100 }
 101
 102 static int
 103 ip1000phy_attach(device_t dev)
 104 {
 105         struct ip1000phy_softc *isc;
 106         struct mii_softc *sc;
 107         struct mii_attach_args *ma;
 108         struct mii_data *mii;
 109
 110         isc = device_get_softc(dev);
 111         sc = &isc->mii_sc;
 112         ma = device_get_ivars(dev);
 113         sc->mii_dev = device_get_parent(dev);
 114         mii = ma->mii_data;
 115         LIST_INSERT_HEAD(&mii->mii_phys, sc, mii_list);
 116
 117         sc->mii_flags = miibus_get_flags(dev);
 118         sc->mii_inst = mii->mii_instance++;
 119         sc->mii_phy = ma->mii_phyno;
 120         sc->mii_service = ip1000phy_service;
 121         sc->mii_pdata = mii;
 122
 123         sc->mii_flags |= MIIF_NOISOLATE | MIIF_NOMANPAUSE;
 124
 125         isc->model = MII_MODEL(ma->mii_id2);
 126         isc->revision = MII_REV(ma->mii_id2);
 127         if (isc->model == MII_MODEL_ICPLUS_IP1000A &&
 128              strcmp(mii->mii_ifp->if_dname, "stge") == 0 &&
 129              (sc->mii_flags & MIIF_MACPRIV0) != 0)
 130                 sc->mii_flags |= MIIF_PHYPRIV0;
 131
 132         sc->mii_capabilities = PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
 133         if (sc->mii_capabilities & BMSR_EXTSTAT)
 134                 sc->mii_extcapabilities = PHY_READ(sc, MII_EXTSR);
 135         device_printf(dev, " ");
 136
 137         ip1000phy_reset(sc);
 138         mii_phy_add_media(sc);
 139         printf("\n");
 140
 141         MIIBUS_MEDIAINIT(sc->mii_dev);
 142         return (0);
 143 }
 144
 145 static int
 146 ip1000phy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
 147 {
 148         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
 149         uint32_t gig, reg, speed;
 150
 151         switch (cmd) {
 152         case MII_POLLSTAT:
 153                 break;
 154
 155         case MII_MEDIACHG:
 156                 /*
 157                  * If the interface is not up, don't do anything.
 158                  */
 159                 if ((mii->mii_ifp->if_flags & IFF_UP) == 0) {
 160                         break;
 161                 }
 162
 163                 ip1000phy_reset(sc);
 164                 switch (IFM_SUBTYPE(ife->ifm_media)) {
 165                 case IFM_AUTO:
 166                         (void)ip1000phy_mii_phy_auto(sc, ife->ifm_media);
 167                         goto done;
 168
 169                 case IFM_1000_T:
 170                         /*
 171                          * XXX
 172                          * Manual 1000baseT setting doesn't seem to work.
 173                          */
 174                         speed = IP1000PHY_BMCR_1000;
 175                         break;
 176
 177                 case IFM_100_TX:
 178                         speed = IP1000PHY_BMCR_100;
 179                         break;
 180
 181                 case IFM_10_T:
 182                         speed = IP1000PHY_BMCR_10;
 183                         break;
 184
 185                 default:
 186                         return (EINVAL);
 187                 }
 188
 189                 if (((ife->ifm_media & IFM_GMASK) & IFM_FDX) != 0) {
 190                         speed |= IP1000PHY_BMCR_FDX;
 191                         gig = IP1000PHY_1000CR_1000T_FDX;
 192                 } else
 193                         gig = IP1000PHY_1000CR_1000T;
 194
 195                 PHY_WRITE(sc, IP1000PHY_MII_1000CR, 0);
 196                 PHY_WRITE(sc, IP1000PHY_MII_BMCR, speed);
 197
 198                 if (IFM_SUBTYPE(ife->ifm_media) != IFM_1000_T)
 199                         break;
 200
 201                 gig |= IP1000PHY_1000CR_MASTER | IP1000PHY_1000CR_MANUAL;
 202                 if ((ife->ifm_media & IFM_ETH_MASTER) != 0 ||
 203                     (mii->mii_ifp->if_flags & IFF_LINK0) != 0)
 204                         gig |= IP1000PHY_1000CR_MMASTER;
 205                 PHY_WRITE(sc, IP1000PHY_MII_1000CR, gig);
 206
 207 done:
 208                 break;
 209
 210         case MII_TICK:
 211                 /*
 212                  * Is the interface even up?
 213                  */
 214                 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
 215                         return (0);
 216
 217                 /*
 218                  * Only used for autonegotiation.
 219                  */
 220                 if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO) {
 221                         sc->mii_ticks = 0;
 222                         break;
 223                 }
 224
 225                 /*
 226                  * check for link.
 227                  */
 228                 reg = PHY_READ(sc, MII_BMSR) | PHY_READ(sc, MII_BMSR);
 229                 if (reg & BMSR_LINK) {
 230                         sc->mii_ticks = 0;
 231                         break;
 232                 }
 233
 234                 /* Announce link loss right after it happens */
 235                 if (sc->mii_ticks++ == 0)
 236                         break;
 237
 238                 /*
 239                  * Only retry autonegotiation every mii_anegticks seconds.
 240                  */
 241                 if (sc->mii_ticks <= sc->mii_anegticks)
 242                         break;
 243
 244                 sc->mii_ticks = 0;
 245                 ip1000phy_mii_phy_auto(sc, ife->ifm_media);
 246                 break;
 247         }
 248
 249         /* Update the media status. */
 250         ip1000phy_status(sc);
 251
 252         /* Callback if something changed. */
 253         mii_phy_update(sc, cmd);
 254         return (0);
 255 }
 256
 257 static void
 258 ip1000phy_status(struct mii_softc *sc)
 259 {
 260         struct ip1000phy_softc *isc;
 261         struct mii_data *mii = sc->mii_pdata;
 262         uint32_t bmsr, bmcr, stat;
 263
 264         isc = (struct ip1000phy_softc *)sc;
 265
 266         mii->mii_media_status = IFM_AVALID;
 267         mii->mii_media_active = IFM_ETHER;
 268
 269         bmsr = PHY_READ(sc, IP1000PHY_MII_BMSR) |
 270             PHY_READ(sc, IP1000PHY_MII_BMSR);
 271         if ((bmsr & IP1000PHY_BMSR_LINK) != 0)
 272                 mii->mii_media_status |= IFM_ACTIVE;
 273
 274         bmcr = PHY_READ(sc, IP1000PHY_MII_BMCR);
 275         if ((bmcr & IP1000PHY_BMCR_LOOP) != 0)
 276                 mii->mii_media_active |= IFM_LOOP;
 277
 278         if ((bmcr & IP1000PHY_BMCR_AUTOEN) != 0) {
 279                 if ((bmsr & IP1000PHY_BMSR_ANEGCOMP) == 0) {
 280                         /* Erg, still trying, I guess... */
 281                         mii->mii_media_active |= IFM_NONE;
 282                         return;
 283                 }
 284         }
 285
 286         if (isc->model == MII_MODEL_ICPLUS_IP1001) {
 287                 stat = PHY_READ(sc, IP1000PHY_LSR);
 288                 switch (stat & IP1000PHY_LSR_SPEED_MASK) {
 289                 case IP1000PHY_LSR_SPEED_10:
 290                         mii->mii_media_active |= IFM_10_T;
 291                         break;
 292                 case IP1000PHY_LSR_SPEED_100:
 293                         mii->mii_media_active |= IFM_100_TX;
 294                         break;
 295                 case IP1000PHY_LSR_SPEED_1000:
 296                         mii->mii_media_active |= IFM_1000_T;
 297                         break;
 298                 default:
 299                         mii->mii_media_active |= IFM_NONE;
 300                         return;
 301                 }
 302                 if ((stat & IP1000PHY_LSR_FULL_DUPLEX) != 0)
 303                         mii->mii_media_active |= IFM_FDX;
 304                 else
 305                         mii->mii_media_active |= IFM_HDX;
 306         } else {
 307                 stat = PHY_READ(sc, STGE_PhyCtrl);
 308                 switch (PC_LinkSpeed(stat)) {
 309                 case PC_LinkSpeed_Down:
 310                         mii->mii_media_active |= IFM_NONE;
 311                         return;
 312                 case PC_LinkSpeed_10:
 313                         mii->mii_media_active |= IFM_10_T;
 314                         break;
 315                 case PC_LinkSpeed_100:
 316                         mii->mii_media_active |= IFM_100_TX;
 317                         break;
 318                 case PC_LinkSpeed_1000:
 319                         mii->mii_media_active |= IFM_1000_T;
 320                         break;
 321                 default:
 322                         mii->mii_media_active |= IFM_NONE;
 323                         return;
 324                 }
 325                 if ((stat & PC_PhyDuplexStatus) != 0)
 326                         mii->mii_media_active |= IFM_FDX;
 327                 else
 328                         mii->mii_media_active |= IFM_HDX;
 329         }
 330
 331         if ((mii->mii_media_active & IFM_FDX) != 0)
 332                 mii->mii_media_active |= mii_phy_flowstatus(sc);
 333
 334         if ((mii->mii_media_active & IFM_1000_T) != 0) {
 335                 stat = PHY_READ(sc, IP1000PHY_MII_1000SR);
 336                 if ((stat & IP1000PHY_1000SR_MASTER) != 0)
 337                         mii->mii_media_active |= IFM_ETH_MASTER;
 338         }
 339 }
 340
 341 static int
 342 ip1000phy_mii_phy_auto(struct mii_softc *sc, int media)
 343 {
 344         struct ip1000phy_softc *isc;
 345         uint32_t reg;
 346
 347         isc = (struct ip1000phy_softc *)sc;
 348         reg = 0;
 349         if (isc->model == MII_MODEL_ICPLUS_IP1001) {
 350                 reg = PHY_READ(sc, IP1000PHY_MII_ANAR);
 351                 reg &= ~(IP1000PHY_ANAR_PAUSE | IP1000PHY_ANAR_APAUSE);
 352                 reg |= IP1000PHY_ANAR_NP;
 353         }
 354         reg |= IP1000PHY_ANAR_10T | IP1000PHY_ANAR_10T_FDX |
 355             IP1000PHY_ANAR_100TX | IP1000PHY_ANAR_100TX_FDX;
 356         if ((media & IFM_FLOW) != 0 || (sc->mii_flags & MIIF_FORCEPAUSE) != 0)
 357                 reg |= IP1000PHY_ANAR_PAUSE | IP1000PHY_ANAR_APAUSE;
 358         PHY_WRITE(sc, IP1000PHY_MII_ANAR, reg | IP1000PHY_ANAR_CSMA);
 359
 360         reg = IP1000PHY_1000CR_1000T | IP1000PHY_1000CR_1000T_FDX;
 361         reg |= IP1000PHY_1000CR_MASTER;
 362         PHY_WRITE(sc, IP1000PHY_MII_1000CR, reg);
 363         PHY_WRITE(sc, IP1000PHY_MII_BMCR, (IP1000PHY_BMCR_FDX |
 364             IP1000PHY_BMCR_AUTOEN | IP1000PHY_BMCR_STARTNEG));
 365
 366         return (EJUSTRETURN);
 367 }
 368
 369 static void
 370 ip1000phy_load_dspcode(struct mii_softc *sc)
 371 {
 372
 373         PHY_WRITE(sc, 31, 0x0001);
 374         PHY_WRITE(sc, 27, 0x01e0);
 375         PHY_WRITE(sc, 31, 0x0002);
 376         PHY_WRITE(sc, 27, 0xeb8e);
 377         PHY_WRITE(sc, 31, 0x0000);
 378         PHY_WRITE(sc, 30, 0x005e);
 379         PHY_WRITE(sc, 9, 0x0700);
 380
 381         DELAY(50);
 382 }
 383
 384 static void
 385 ip1000phy_reset(struct mii_softc *sc)
 386 {
 387         uint32_t reg;
 388
 389         mii_phy_reset(sc);
 390
 391         /* clear autoneg/full-duplex as we don't want it after reset */
 392         reg = PHY_READ(sc, IP1000PHY_MII_BMCR);
 393         reg &= ~(IP1000PHY_BMCR_AUTOEN | IP1000PHY_BMCR_FDX);
 394         PHY_WRITE(sc, MII_BMCR, reg);
 395
 396         if ((sc->mii_flags & MIIF_PHYPRIV0) != 0)
 397                 ip1000phy_load_dspcode(sc);
 398 }