sys/dev/mii/mii.c

   1 /*      $NetBSD: mii.c,v 1.12 1999/08/03 19:41:49 drochner Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   9  * NASA Ames Research Center.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 /*
  37  * MII bus layer, glues MII-capable network interface drivers to sharable
  38  * PHY drivers.  This exports an interface compatible with BSD/OS 3.0's,
  39  * plus some NetBSD extensions.
  40  */
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/socket.h>
  45 #include <sys/malloc.h>
  46 #include <sys/module.h>
  47 #include <sys/bus.h>
  48
  49 #include <net/if.h>
  50 #include <net/if_var.h>
  51 #include <net/if_media.h>
  52
  53 #include <dev/mii/mii.h>
  54 #include <dev/mii/miivar.h>
  55
  56 MODULE_VERSION(miibus, 1);
  57
  58 #include "miibus_if.h"
  59
  60 static device_attach_t miibus_attach;
  61 static bus_child_location_str_t miibus_child_location_str;
  62 static bus_child_pnpinfo_str_t miibus_child_pnpinfo_str;
  63 static device_detach_t miibus_detach;
  64 static bus_hinted_child_t miibus_hinted_child;
  65 static bus_print_child_t miibus_print_child;
  66 static device_probe_t miibus_probe;
  67 static bus_read_ivar_t miibus_read_ivar;
  68 static miibus_readreg_t miibus_readreg;
  69 static miibus_statchg_t miibus_statchg;
  70 static miibus_writereg_t miibus_writereg;
  71 static miibus_linkchg_t miibus_linkchg;
  72 static miibus_mediainit_t miibus_mediainit;
  73
  74 static unsigned char mii_bitreverse(unsigned char x);
  75
  76 static device_method_t miibus_methods[] = {
  77         /* device interface */
  78         DEVMETHOD(device_probe,         miibus_probe),
  79         DEVMETHOD(device_attach,        miibus_attach),
  80         DEVMETHOD(device_detach,        miibus_detach),
  81         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  82
  83         /* bus interface */
  84         DEVMETHOD(bus_print_child,      miibus_print_child),
  85         DEVMETHOD(bus_read_ivar,        miibus_read_ivar),
  86         DEVMETHOD(bus_child_pnpinfo_str, miibus_child_pnpinfo_str),
  87         DEVMETHOD(bus_child_location_str, miibus_child_location_str),
  88         DEVMETHOD(bus_hinted_child,     miibus_hinted_child),
  89
  90         /* MII interface */
  91         DEVMETHOD(miibus_readreg,       miibus_readreg),
  92         DEVMETHOD(miibus_writereg,      miibus_writereg),
  93         DEVMETHOD(miibus_statchg,       miibus_statchg),
  94         DEVMETHOD(miibus_linkchg,       miibus_linkchg),
  95         DEVMETHOD(miibus_mediainit,     miibus_mediainit),
  96
  97         DEVMETHOD_END
  98 };
  99
 100 devclass_t miibus_devclass;
 101
 102 driver_t miibus_driver = {
 103         "miibus",
 104         miibus_methods,
 105         sizeof(struct mii_data)
 106 };
 107
 108 struct miibus_ivars {
 109         if_t            ifp;
 110         ifm_change_cb_t ifmedia_upd;
 111         ifm_stat_cb_t   ifmedia_sts;
 112         u_int           mii_flags;
 113         u_int           mii_offset;
 114 };
 115
 116 static int
 117 miibus_probe(device_t dev)
 118 {
 119
 120         device_set_desc(dev, "MII bus");
 121
 122         return (BUS_PROBE_SPECIFIC);
 123 }
 124
 125 static int
 126 miibus_attach(device_t dev)
 127 {
 128         struct miibus_ivars     *ivars;
 129         struct mii_attach_args  *ma;
 130         struct mii_data         *mii;
 131         device_t                *children;
 132         int                     i, nchildren;
 133
 134         mii = device_get_softc(dev);
 135         if (device_get_children(dev, &children, &nchildren) == 0) {
 136                 for (i = 0; i < nchildren; i++) {
 137                         ma = device_get_ivars(children[i]);
 138                         ma->mii_data = mii;
 139                 }
 140                 free(children, M_TEMP);
 141         }
 142         if (nchildren == 0) {
 143                 device_printf(dev, "cannot get children\n");
 144                 return (ENXIO);
 145         }
 146         ivars = device_get_ivars(dev);
 147         ifmedia_init(&mii->mii_media, IFM_IMASK, ivars->ifmedia_upd,
 148             ivars->ifmedia_sts);
 149         mii->mii_ifp = ivars->ifp;
 150         if_setcapabilitiesbit(mii->mii_ifp, IFCAP_LINKSTATE, 0);
 151         if_setcapenablebit(mii->mii_ifp, IFCAP_LINKSTATE, 0);
 152         LIST_INIT(&mii->mii_phys);
 153
 154         return (bus_generic_attach(dev));
 155 }
 156
 157 static int
 158 miibus_detach(device_t dev)
 159 {
 160         struct mii_data         *mii;
 161
 162         bus_generic_detach(dev);
 163         mii = device_get_softc(dev);
 164         ifmedia_removeall(&mii->mii_media);
 165         mii->mii_ifp = NULL;
 166
 167         return (0);
 168 }
 169
 170 static int
 171 miibus_print_child(device_t dev, device_t child)
 172 {
 173         struct mii_attach_args *ma;
 174         int retval;
 175
 176         ma = device_get_ivars(child);
 177         retval = bus_print_child_header(dev, child);
 178         retval += printf(" PHY %d", ma->mii_phyno);
 179         retval += bus_print_child_footer(dev, child);
 180
 181         return (retval);
 182 }
 183
 184 static int
 185 miibus_read_ivar(device_t dev, device_t child __unused, int which,
 186     uintptr_t *result)
 187 {
 188         struct miibus_ivars *ivars;
 189
 190         /*
 191          * NB: this uses the instance variables of the miibus rather than
 192          * its PHY children.
 193          */
 194         ivars = device_get_ivars(dev);
 195         switch (which) {
 196         case MIIBUS_IVAR_FLAGS:
 197                 *result = ivars->mii_flags;
 198                 break;
 199         default:
 200                 return (ENOENT);
 201         }
 202         return (0);
 203 }
 204
 205 static int
 206 miibus_child_pnpinfo_str(device_t dev __unused, device_t child, char *buf,
 207     size_t buflen)
 208 {
 209         struct mii_attach_args *ma;
 210
 211         ma = device_get_ivars(child);
 212         snprintf(buf, buflen, "oui=0x%x model=0x%x rev=0x%x",
 213             MII_OUI(ma->mii_id1, ma->mii_id2),
 214             MII_MODEL(ma->mii_id2), MII_REV(ma->mii_id2));
 215         return (0);
 216 }
 217
 218 static int
 219 miibus_child_location_str(device_t dev __unused, device_t child, char *buf,
 220     size_t buflen)
 221 {
 222         struct mii_attach_args *ma;
 223
 224         ma = device_get_ivars(child);
 225         snprintf(buf, buflen, "phyno=%d", ma->mii_phyno);
 226         return (0);
 227 }
 228
 229 static void
 230 miibus_hinted_child(device_t dev, const char *name, int unit)
 231 {
 232         struct miibus_ivars *ivars;
 233         struct mii_attach_args *args, *ma;
 234         device_t *children, phy;
 235         int i, nchildren;
 236         u_int val;
 237
 238         if (resource_int_value(name, unit, "phyno", &val) != 0)
 239                 return;
 240         if (device_get_children(dev, &children, &nchildren) != 0)
 241                 return;
 242         ma = NULL;
 243         for (i = 0; i < nchildren; i++) {
 244                 args = device_get_ivars(children[i]);
 245                 if (args->mii_phyno == val) {
 246                         ma = args;
 247                         break;
 248                 }
 249         }
 250         free(children, M_TEMP);
 251
 252         /*
 253          * Don't add a PHY that was automatically identified by having media
 254          * in its BMSR twice, only allow to alter its attach arguments.
 255          */
 256         if (ma == NULL) {
 257                 ma = malloc(sizeof(struct mii_attach_args), M_DEVBUF,
 258                     M_NOWAIT);
 259                 if (ma == NULL)
 260                         return;
 261                 phy = device_add_child(dev, name, unit);
 262                 if (phy == NULL) {
 263                         free(ma, M_DEVBUF);
 264                         return;
 265                 }
 266                 ivars = device_get_ivars(dev);
 267                 ma->mii_phyno = val;
 268                 ma->mii_offset = ivars->mii_offset++;
 269                 ma->mii_id1 = 0;
 270                 ma->mii_id2 = 0;
 271                 ma->mii_capmask = BMSR_DEFCAPMASK;
 272                 device_set_ivars(phy, ma);
 273         }
 274
 275         if (resource_int_value(name, unit, "id1", &val) == 0)
 276                 ma->mii_id1 = val;
 277         if (resource_int_value(name, unit, "id2", &val) == 0)
 278                 ma->mii_id2 = val;
 279         if (resource_int_value(name, unit, "capmask", &val) == 0)
 280                 ma->mii_capmask = val;
 281 }
 282
 283 static int
 284 miibus_readreg(device_t dev, int phy, int reg)
 285 {
 286         device_t                parent;
 287
 288         parent = device_get_parent(dev);
 289         return (MIIBUS_READREG(parent, phy, reg));
 290 }
 291
 292 static int
 293 miibus_writereg(device_t dev, int phy, int reg, int data)
 294 {
 295         device_t                parent;
 296
 297         parent = device_get_parent(dev);
 298         return (MIIBUS_WRITEREG(parent, phy, reg, data));
 299 }
 300
 301 static void
 302 miibus_statchg(device_t dev)
 303 {
 304         device_t                parent;
 305         struct mii_data         *mii;
 306
 307         parent = device_get_parent(dev);
 308         MIIBUS_STATCHG(parent);
 309
 310         mii = device_get_softc(dev);
 311         if_setbaudrate(mii->mii_ifp, ifmedia_baudrate(mii->mii_media_active));
 312 }
 313
 314 static void
 315 miibus_linkchg(device_t dev)
 316 {
 317         struct mii_data         *mii;
 318         device_t                parent;
 319         int                     link_state;
 320
 321         parent = device_get_parent(dev);
 322         MIIBUS_LINKCHG(parent);
 323
 324         mii = device_get_softc(dev);
 325
 326         if (mii->mii_media_status & IFM_AVALID) {
 327                 if (mii->mii_media_status & IFM_ACTIVE)
 328                         link_state = LINK_STATE_UP;
 329                 else
 330                         link_state = LINK_STATE_DOWN;
 331         } else
 332                 link_state = LINK_STATE_UNKNOWN;
 333         if_link_state_change(mii->mii_ifp, link_state);
 334 }
 335
 336 static void
 337 miibus_mediainit(device_t dev)
 338 {
 339         struct mii_data         *mii;
 340         struct ifmedia_entry    *m;
 341         int                     media = 0;
 342
 343         /* Poke the parent in case it has any media of its own to add. */
 344         MIIBUS_MEDIAINIT(device_get_parent(dev));
 345
 346         mii = device_get_softc(dev);
 347         LIST_FOREACH(m, &mii->mii_media.ifm_list, ifm_list) {
 348                 media = m->ifm_media;
 349                 if (media == (IFM_ETHER | IFM_AUTO))
 350                         break;
 351         }
 352
 353         ifmedia_set(&mii->mii_media, media);
 354 }
 355
 356 /*
 357  * Helper function used by network interface drivers, attaches the miibus and
 358  * the PHYs to the network interface driver parent.
 359  */
 360 int
 361 mii_attach(device_t dev, device_t *miibus, if_t ifp,
 362     ifm_change_cb_t ifmedia_upd, ifm_stat_cb_t ifmedia_sts, int capmask,
 363     int phyloc, int offloc, int flags)
 364 {
 365         struct miibus_ivars *ivars;
 366         struct mii_attach_args *args, ma;
 367         device_t *children, phy;
 368         int bmsr, first, i, nchildren, phymax, phymin, rv;
 369         uint32_t phymask;
 370
 371         if (phyloc != MII_PHY_ANY && offloc != MII_OFFSET_ANY) {
 372                 printf("%s: phyloc and offloc specified\n", __func__);
 373                 return (EINVAL);
 374         }
 375
 376         if (offloc != MII_OFFSET_ANY && (offloc < 0 || offloc >= MII_NPHY)) {
 377                 printf("%s: invalid offloc %d\n", __func__, offloc);
 378                 return (EINVAL);
 379         }
 380
 381         if (phyloc == MII_PHY_ANY) {
 382                 phymin = 0;
 383                 phymax = MII_NPHY - 1;
 384         } else {
 385                 if (phyloc < 0 || phyloc >= MII_NPHY) {
 386                         printf("%s: invalid phyloc %d\n", __func__, phyloc);
 387                         return (EINVAL);
 388                 }
 389                 phymin = phymax = phyloc;
 390         }
 391
 392         first = 0;
 393         if (*miibus == NULL) {
 394                 first = 1;
 395                 ivars = malloc(sizeof(*ivars), M_DEVBUF, M_NOWAIT);
 396                 if (ivars == NULL)
 397                         return (ENOMEM);
 398                 ivars->ifp = ifp;
 399                 ivars->ifmedia_upd = ifmedia_upd;
 400                 ivars->ifmedia_sts = ifmedia_sts;
 401                 ivars->mii_flags = flags;
 402                 *miibus = device_add_child(dev, "miibus", -1);
 403                 if (*miibus == NULL) {
 404                         rv = ENXIO;
 405                         goto fail;
 406                 }
 407                 device_set_ivars(*miibus, ivars);
 408         } else {
 409                 ivars = device_get_ivars(*miibus);
 410                 if (ivars->ifp != ifp || ivars->ifmedia_upd != ifmedia_upd ||
 411                     ivars->ifmedia_sts != ifmedia_sts ||
 412                     ivars->mii_flags != flags) {
 413                         printf("%s: non-matching invariant\n", __func__);
 414                         return (EINVAL);
 415                 }
 416                 /*
 417                  * Assignment of the attach arguments mii_data for the first
 418                  * pass is done in miibus_attach(), i.e. once the miibus softc
 419                  * has been allocated.
 420                  */
 421                 ma.mii_data = device_get_softc(*miibus);
 422         }
 423
 424         ma.mii_capmask = capmask;
 425
 426         if (resource_int_value(device_get_name(*miibus),
 427             device_get_unit(*miibus), "phymask", &phymask) != 0)
 428                 phymask = 0xffffffff;
 429
 430         if (device_get_children(*miibus, &children, &nchildren) != 0) {
 431                 children = NULL;
 432                 nchildren = 0;
 433         }
 434         ivars->mii_offset = 0;
 435         for (ma.mii_phyno = phymin; ma.mii_phyno <= phymax; ma.mii_phyno++) {
 436                 /*
 437                  * Make sure we haven't already configured a PHY at this
 438                  * address.  This allows mii_attach() to be called
 439                  * multiple times.
 440                  */
 441                 for (i = 0; i < nchildren; i++) {
 442                         args = device_get_ivars(children[i]);
 443                         if (args->mii_phyno == ma.mii_phyno) {
 444                                 /*
 445                                  * Yes, there is already something
 446                                  * configured at this address.
 447                                  */
 448                                 goto skip;
 449                         }
 450                 }
 451
 452                 /*
 453                  * Check to see if there is a PHY at this address.  Note,
 454                  * many braindead PHYs report 0/0 in their ID registers,
 455                  * so we test for media in the BMSR.
 456                  */
 457                 bmsr = MIIBUS_READREG(dev, ma.mii_phyno, MII_BMSR);
 458                 if (bmsr == 0 || bmsr == 0xffff ||
 459                     (bmsr & (BMSR_EXTSTAT | BMSR_MEDIAMASK)) == 0) {
 460                         /* Assume no PHY at this address. */
 461                         continue;
 462                 }
 463
 464                 /*
 465                  * There is a PHY at this address.  If we were given an
 466                  * `offset' locator, skip this PHY if it doesn't match.
 467                  */
 468                 if (offloc != MII_OFFSET_ANY && offloc != ivars->mii_offset)
 469                         goto skip;
 470
 471                 /*
 472                  * Skip this PHY if it's not included in the phymask hint.
 473                  */
 474                 if ((phymask & (1 << ma.mii_phyno)) == 0)
 475                         goto skip;
 476
 477                 /*
 478                  * Extract the IDs.  Braindead PHYs will be handled by
 479                  * the `ukphy' driver, as we have no ID information to
 480                  * match on.
 481                  */
 482                 ma.mii_id1 = MIIBUS_READREG(dev, ma.mii_phyno, MII_PHYIDR1);
 483                 ma.mii_id2 = MIIBUS_READREG(dev, ma.mii_phyno, MII_PHYIDR2);
 484
 485                 ma.mii_offset = ivars->mii_offset;
 486                 args = malloc(sizeof(struct mii_attach_args), M_DEVBUF,
 487                     M_NOWAIT);
 488                 if (args == NULL)
 489                         goto skip;
 490                 bcopy((char *)&ma, (char *)args, sizeof(ma));
 491                 phy = device_add_child(*miibus, NULL, -1);
 492                 if (phy == NULL) {
 493                         free(args, M_DEVBUF);
 494                         goto skip;
 495                 }
 496                 device_set_ivars(phy, args);
 497  skip:
 498                 ivars->mii_offset++;
 499         }
 500         free(children, M_TEMP);
 501
 502         if (first != 0) {
 503                 rv = device_set_driver(*miibus, &miibus_driver);
 504                 if (rv != 0)
 505                         goto fail;
 506                 bus_enumerate_hinted_children(*miibus);
 507                 rv = device_get_children(*miibus, &children, &nchildren);
 508                 if (rv != 0)
 509                         goto fail;
 510                 free(children, M_TEMP);
 511                 if (nchildren == 0) {
 512                         rv = ENXIO;
 513                         goto fail;
 514                 }
 515                 rv = bus_generic_attach(dev);
 516                 if (rv != 0)
 517                         goto fail;
 518
 519                 /* Attaching of the PHY drivers is done in miibus_attach(). */
 520                 return (0);
 521         }
 522         rv = bus_generic_attach(*miibus);
 523         if (rv != 0)
 524                 goto fail;
 525
 526         return (0);
 527
 528  fail:
 529         if (*miibus != NULL)
 530                 device_delete_child(dev, *miibus);
 531         free(ivars, M_DEVBUF);
 532         if (first != 0)
 533                 *miibus = NULL;
 534         return (rv);
 535 }
 536
 537 /*
 538  * Media changed; notify all PHYs.
 539  */
 540 int
 541 mii_mediachg(struct mii_data *mii)
 542 {
 543         struct mii_softc *child;
 544         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
 545         int rv;
 546
 547         mii->mii_media_status = 0;
 548         mii->mii_media_active = IFM_NONE;
 549
 550         LIST_FOREACH(child, &mii->mii_phys, mii_list) {
 551                 /*
 552                  * If the media indicates a different PHY instance,
 553                  * isolate this one.
 554                  */
 555                 if (IFM_INST(ife->ifm_media) != child->mii_inst) {
 556                         if ((child->mii_flags & MIIF_NOISOLATE) != 0) {
 557                                 device_printf(child->mii_dev, "%s: "
 558                                     "can't handle non-zero PHY instance %d\n",
 559                                     __func__, child->mii_inst);
 560                                 continue;
 561                         }
 562                         PHY_WRITE(child, MII_BMCR, PHY_READ(child, MII_BMCR) |
 563                             BMCR_ISO);
 564                         continue;
 565                 }
 566                 rv = PHY_SERVICE(child, mii, MII_MEDIACHG);
 567                 if (rv)
 568                         return (rv);
 569         }
 570         return (0);
 571 }
 572
 573 /*
 574  * Call the PHY tick routines, used during autonegotiation.
 575  */
 576 void
 577 mii_tick(struct mii_data *mii)
 578 {
 579         struct mii_softc *child;
 580         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
 581
 582         LIST_FOREACH(child, &mii->mii_phys, mii_list) {
 583                 /*
 584                  * If this PHY instance isn't currently selected, just skip
 585                  * it.
 586                  */
 587                 if (IFM_INST(ife->ifm_media) != child->mii_inst)
 588                         continue;
 589                 (void)PHY_SERVICE(child, mii, MII_TICK);
 590         }
 591 }
 592
 593 /*
 594  * Get media status from PHYs.
 595  */
 596 void
 597 mii_pollstat(struct mii_data *mii)
 598 {
 599         struct mii_softc *child;
 600         struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
 601
 602         mii->mii_media_status = 0;
 603         mii->mii_media_active = IFM_NONE;
 604
 605         LIST_FOREACH(child, &mii->mii_phys, mii_list) {
 606                 /*
 607                  * If we're not polling this PHY instance, just skip it.
 608                  */
 609                 if (IFM_INST(ife->ifm_media) != child->mii_inst)
 610                         continue;
 611                 (void)PHY_SERVICE(child, mii, MII_POLLSTAT);
 612         }
 613 }
 614
 615 static unsigned char
 616 mii_bitreverse(unsigned char x)
 617 {
 618         static unsigned const char nibbletab[16] = {
 619                 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
 620         };
 621
 622         return ((nibbletab[x & 15] << 4) | nibbletab[x >> 4]);
 623 }
 624
 625 u_int
 626 mii_oui(u_int id1, u_int id2)
 627 {
 628         u_int h;
 629
 630         h = (id1 << 6) | (id2 >> 10);
 631
 632         return ((mii_bitreverse(h >> 16) << 16) |
 633             (mii_bitreverse((h >> 8) & 0xff) << 8) |
 634             mii_bitreverse(h & 0xff));
 635 }
 636
 637 int
 638 mii_phy_mac_match(struct mii_softc *mii, const char *name)
 639 {
 640
 641         return (strcmp(device_get_name(device_get_parent(mii->mii_dev)),
 642             name) == 0);
 643 }
 644
 645 int
 646 mii_dev_mac_match(device_t parent, const char *name)
 647 {
 648
 649         return (strcmp(device_get_name(device_get_parent(
 650             device_get_parent(parent))), name) == 0);
 651 }
 652
 653 void *
 654 mii_phy_mac_softc(struct mii_softc *mii)
 655 {
 656
 657         return (device_get_softc(device_get_parent(mii->mii_dev)));
 658 }
 659
 660 void *
 661 mii_dev_mac_softc(device_t parent)
 662 {
 663
 664         return (device_get_softc(device_get_parent(device_get_parent(parent))));
 665 }