sys/dev/netif/mii_layer/jmphy.c

   1 /*-
   2  * Copyright (c) 2008, 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  * $FreeBSD: src/sys/dev/mii/jmphy.c,v 1.1 2008/05/27 01:16:40 yongari Exp $
  28  */
  29
  30 /*
  31  * Driver for the JMicron JMP211 10/100/1000, JMP202 10/100 PHY.
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/kernel.h>
  37
  38 #include <net/if.h>
  39 #include <net/if_media.h>
  40
  41 #include <dev/netif/mii_layer/mii.h>
  42 #include <dev/netif/mii_layer/miivar.h>
  43 #include <dev/netif/mii_layer/jmphyreg.h>
  44
  45 #include "miibus_if.h"
  46 #include "miidevs.h"
  47
  48 static int      jmphy_service(struct mii_softc *, struct mii_data *, int);
  49 static void     jmphy_status(struct mii_softc *);
  50 static int      jmphy_probe(device_t);
  51 static int      jmphy_attach(device_t);
  52 static void     jmphy_reset(struct mii_softc *);
  53 static uint16_t jmphy_anar(struct ifmedia_entry *);
  54 static int      jmphy_auto(struct mii_softc *, struct ifmedia_entry *);
  55
  56 static device_method_t jmphy_methods[] = {
  57         /* Device interface. */
  58         DEVMETHOD(device_probe,         jmphy_probe),
  59         DEVMETHOD(device_attach,        jmphy_attach),
  60         DEVMETHOD(device_detach,        ukphy_detach),
  61         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  62         { NULL, NULL }
  63 };
  64
  65 static devclass_t jmphy_devclass;
  66 static driver_t jmphy_driver = {
  67         "jmphy",
  68         jmphy_methods,
  69         sizeof(struct mii_softc)
  70 };
  71
  72 DRIVER_MODULE(jmphy, miibus, jmphy_driver, jmphy_devclass, NULL, NULL);
  73
  74 static const struct mii_phydesc jmphys[] = {
  75         MII_PHYDESC(JMICRON, JMP202),
  76         MII_PHYDESC(JMICRON, JMP211),
  77         MII_PHYDESC_NULL
  78 };
  79
  80 static int
  81 jmphy_probe(device_t dev)
  82 {
  83         struct mii_attach_args *ma = device_get_ivars(dev);
  84         const struct mii_phydesc *mpd;
  85
  86         mpd = mii_phy_match(ma, jmphys);
  87         if (mpd != NULL) {
  88                 device_set_desc(dev, mpd->mpd_name);
  89                 return 0;
  90         }
  91         return ENXIO;
  92 }
  93
  94 static int
  95 jmphy_attach(device_t dev)
  96 {
  97         struct mii_softc *sc;
  98         struct mii_attach_args *ma;
  99         struct mii_data *mii;
 100
 101         sc = device_get_softc(dev);
 102         ma = device_get_ivars(dev);
 103
 104         mii_softc_init(sc, ma);
 105         sc->mii_dev = device_get_parent(dev);
 106         mii = device_get_softc(sc->mii_dev);
 107         LIST_INSERT_HEAD(&mii->mii_phys, sc, mii_list);
 108
 109         sc->mii_inst = mii->mii_instance;
 110         sc->mii_service = jmphy_service;
 111         sc->mii_reset = jmphy_reset;
 112         sc->mii_pdata = mii;
 113
 114         mii->mii_instance++;
 115
 116         jmphy_reset(sc);
 117
 118         sc->mii_capabilities = PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
 119         if (sc->mii_capabilities & BMSR_EXTSTAT)
 120                 sc->mii_extcapabilities = PHY_READ(sc, MII_EXTSR);
 121
 122         device_printf(dev, " ");
 123         if ((sc->mii_capabilities & BMSR_MEDIAMASK) == 0 &&
 124             (sc->mii_extcapabilities & EXTSR_MEDIAMASK) == 0)
 125                 kprintf("no media present");
 126         else
 127                 mii_phy_add_media(sc);
 128         kprintf("\n");
 129
 130         MIIBUS_MEDIAINIT(sc->mii_dev);
 131         return(0);
 132 }
 133
 134 static int
 135 jmphy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
 136 {
 137         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
 138         uint16_t bmcr;
 139
 140         switch (cmd) {
 141         case MII_POLLSTAT:
 142                 /*
 143                  * If we're not polling our PHY instance, just return.
 144                  */
 145                 if (IFM_INST(ife->ifm_media) != sc->mii_inst)
 146                         return (0);
 147                 break;
 148
 149         case MII_MEDIACHG:
 150                 /*
 151                  * If the media indicates a different PHY instance,
 152                  * isolate ourselves.
 153                  */
 154                 if (IFM_INST(ife->ifm_media) != sc->mii_inst) {
 155                         bmcr = PHY_READ(sc, MII_BMCR);
 156                         PHY_WRITE(sc, MII_BMCR, bmcr | BMCR_ISO);
 157                         return (0);
 158                 }
 159
 160                 /*
 161                  * If the interface is not up, don't do anything.
 162                  */
 163                 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
 164                         break;
 165
 166                 if (jmphy_auto(sc, ife) != EJUSTRETURN)
 167                         return (EINVAL);
 168                 break;
 169
 170         case MII_TICK:
 171                 /*
 172                  * If we're not currently selected, just return.
 173                  */
 174                 if (IFM_INST(ife->ifm_media) != sc->mii_inst)
 175                         return (0);
 176
 177                 /*
 178                  * Is the interface even up?
 179                  */
 180                 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
 181                         return (0);
 182
 183                 /*
 184                  * Only used for autonegotiation.
 185                  */
 186                 if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
 187                         break;
 188
 189                 /* Check for link. */
 190                 if (PHY_READ(sc, JMPHY_SSR) & JMPHY_SSR_LINK_UP) {
 191                         sc->mii_ticks = 0;
 192                         break;
 193                 }
 194
 195                 /* Announce link loss right after it happens. */
 196                 if (sc->mii_ticks++ == 0)
 197                         break;
 198                 if (sc->mii_ticks <= sc->mii_anegticks)
 199                         return (0);
 200
 201                 sc->mii_ticks = 0;
 202                 jmphy_auto(sc, ife);
 203                 break;
 204         }
 205
 206         /* Update the media status. */
 207         jmphy_status(sc);
 208
 209         /* Callback if something changed. */
 210         mii_phy_update(sc, cmd);
 211         return (0);
 212 }
 213
 214 static void
 215 jmphy_status(struct mii_softc *sc)
 216 {
 217         struct mii_data *mii = sc->mii_pdata;
 218         int bmcr, ssr;
 219
 220         mii->mii_media_status = IFM_AVALID;
 221         mii->mii_media_active = IFM_ETHER;
 222
 223         ssr = PHY_READ(sc, JMPHY_SSR);
 224         if ((ssr & JMPHY_SSR_LINK_UP) != 0)
 225                 mii->mii_media_status |= IFM_ACTIVE;
 226
 227         bmcr = PHY_READ(sc, MII_BMCR);
 228         if ((bmcr & BMCR_ISO) != 0) {
 229                 mii->mii_media_active |= IFM_NONE;
 230                 mii->mii_media_status = 0;
 231                 return;
 232         }
 233
 234         if ((bmcr & BMCR_LOOP) != 0)
 235                 mii->mii_media_active |= IFM_LOOP;
 236
 237         if ((ssr & JMPHY_SSR_SPD_DPLX_RESOLVED) == 0) {
 238                 /* Erg, still trying, I guess... */
 239                 mii->mii_media_active |= IFM_NONE;
 240                 return;
 241         }
 242
 243         switch ((ssr & JMPHY_SSR_SPEED_MASK)) {
 244         case JMPHY_SSR_SPEED_1000:
 245                 mii->mii_media_active |= IFM_1000_T;
 246                 /*
 247                  * jmphy(4) got a valid link so reset mii_ticks.
 248                  * Resetting mii_ticks is needed in order to
 249                  * detect link loss after auto-negotiation.
 250                  */
 251                 sc->mii_ticks = 0;
 252                 break;
 253         case JMPHY_SSR_SPEED_100:
 254                 mii->mii_media_active |= IFM_100_TX;
 255                 sc->mii_ticks = 0;
 256                 break;
 257         case JMPHY_SSR_SPEED_10:
 258                 mii->mii_media_active |= IFM_10_T;
 259                 sc->mii_ticks = 0;
 260                 break;
 261         default:
 262                 mii->mii_media_active |= IFM_NONE;
 263                 return;
 264         }
 265
 266         if ((ssr & JMPHY_SSR_DUPLEX) != 0)
 267                 mii->mii_media_active |= IFM_FDX;
 268         else
 269                 mii->mii_media_active |= IFM_HDX;
 270         /* XXX Flow-control. */
 271 #ifdef notyet
 272         if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T) {
 273                 if ((PHY_READ(sc, MII_100T2SR) & GTSR_MS_RES) != 0)
 274                         mii->mii_media_active |= IFM_ETH_MASTER;
 275         }
 276 #endif
 277 }
 278
 279 static void
 280 jmphy_reset(struct mii_softc *sc)
 281 {
 282         int i;
 283
 284         /* Disable sleep mode. */
 285         PHY_WRITE(sc, JMPHY_TMCTL,
 286             PHY_READ(sc, JMPHY_TMCTL) & ~JMPHY_TMCTL_SLEEP_ENB);
 287         PHY_WRITE(sc, MII_BMCR, BMCR_RESET | BMCR_AUTOEN);
 288
 289         for (i = 0; i < 1000; i++) {
 290                 DELAY(1);
 291                 if ((PHY_READ(sc, MII_BMCR) & BMCR_RESET) == 0)
 292                         break;
 293         }
 294 }
 295
 296 static uint16_t
 297 jmphy_anar(struct ifmedia_entry *ife)
 298 {
 299         uint16_t anar;
 300
 301         anar = 0;
 302         switch (IFM_SUBTYPE(ife->ifm_media)) {
 303         case IFM_AUTO:
 304                 anar |= ANAR_TX_FD | ANAR_TX | ANAR_10_FD | ANAR_10;
 305                 break;
 306         case IFM_1000_T:
 307                 break;
 308         case IFM_100_TX:
 309                 anar |= ANAR_TX | ANAR_TX_FD;
 310                 break;
 311         case IFM_10_T:
 312                 anar |= ANAR_10 | ANAR_10_FD;
 313                 break;
 314         default:
 315                 break;
 316         }
 317
 318         return (anar);
 319 }
 320
 321 static int
 322 jmphy_auto(struct mii_softc *sc, struct ifmedia_entry *ife)
 323 {
 324         uint16_t anar, bmcr, gig;
 325
 326         gig = 0;
 327         bmcr = PHY_READ(sc, MII_BMCR);
 328         switch (IFM_SUBTYPE(ife->ifm_media)) {
 329         case IFM_AUTO:
 330                 gig |= GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX;
 331                 break;
 332         case IFM_1000_T:
 333                 gig |= GTCR_ADV_1000TFDX | GTCR_ADV_1000THDX;
 334                 break;
 335         case IFM_100_TX:
 336         case IFM_10_T:
 337                 break;
 338         case IFM_NONE:
 339                 PHY_WRITE(sc, MII_BMCR, bmcr | BMCR_ISO | BMCR_PDOWN);
 340                 return (EJUSTRETURN);
 341         default:
 342                 return (EINVAL);
 343         }
 344
 345         if ((ife->ifm_media & IFM_LOOP) != 0)
 346                 bmcr |= BMCR_LOOP;
 347
 348         anar = jmphy_anar(ife);
 349         /* XXX Always advertise pause capability. */
 350         anar |= (3 << 10);
 351
 352         if ((sc->mii_flags & MIIF_HAVE_GTCR) != 0) {
 353 #ifdef notyet
 354                 struct mii_data *mii;
 355
 356                 mii = sc->mii_pdata;
 357                 if ((mii->mii_media.ifm_media & IFM_ETH_MASTER) != 0)
 358                         gig |= GTCR_MAN_MS | GTCR_MAN_ADV;
 359 #endif
 360                 PHY_WRITE(sc, MII_100T2CR, gig);
 361         }
 362         PHY_WRITE(sc, MII_ANAR, anar | ANAR_CSMA);
 363         PHY_WRITE(sc, MII_BMCR, bmcr | BMCR_AUTOEN | BMCR_STARTNEG);
 364
 365         return (EJUSTRETURN);
 366 }