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