1 // SPDX-License-Identifier: GPL-2.0+ 2 /* MDIO Bus interface 3 * 4 * Author: Andy Fleming 5 * 6 * Copyright (c) 2004 Freescale Semiconductor, Inc. 7 */ 8 9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 10 11 #include <linux/kernel.h> 12 #include <linux/string.h> 13 #include <linux/errno.h> 14 #include <linux/unistd.h> 15 #include <linux/slab.h> 16 #include <linux/interrupt.h> 17 #include <linux/init.h> 18 #include <linux/delay.h> 19 #include <linux/device.h> 20 #include <linux/gpio.h> 21 #include <linux/gpio/consumer.h> 22 #include <linux/of_device.h> 23 #include <linux/of_mdio.h> 24 #include <linux/of_gpio.h> 25 #include <linux/netdevice.h> 26 #include <linux/etherdevice.h> 27 #include <linux/skbuff.h> 28 #include <linux/spinlock.h> 29 #include <linux/mm.h> 30 #include <linux/module.h> 31 #include <linux/mii.h> 32 #include <linux/ethtool.h> 33 #include <linux/phy.h> 34 #include <linux/io.h> 35 #include <linux/uaccess.h> 36 37 #define CREATE_TRACE_POINTS 38 #include <trace/events/mdio.h> 39 40 #include "mdio-boardinfo.h" 41 42 static int mdiobus_register_gpiod(struct mdio_device *mdiodev) 43 { 44 struct gpio_desc *gpiod = NULL; 45 46 /* Deassert the optional reset signal */ 47 if (mdiodev->dev.of_node) 48 gpiod = fwnode_get_named_gpiod(&mdiodev->dev.of_node->fwnode, 49 "reset-gpios", 0, GPIOD_OUT_LOW, 50 "PHY reset"); 51 if (IS_ERR(gpiod)) { 52 if (PTR_ERR(gpiod) == -ENOENT || PTR_ERR(gpiod) == -ENOSYS) 53 gpiod = NULL; 54 else 55 return PTR_ERR(gpiod); 56 } 57 58 mdiodev->reset = gpiod; 59 60 /* Assert the reset signal again */ 61 mdio_device_reset(mdiodev, 1); 62 63 return 0; 64 } 65 66 int mdiobus_register_device(struct mdio_device *mdiodev) 67 { 68 int err; 69 70 if (mdiodev->bus->mdio_map[mdiodev->addr]) 71 return -EBUSY; 72 73 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) { 74 err = mdiobus_register_gpiod(mdiodev); 75 if (err) 76 return err; 77 } 78 79 mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev; 80 81 return 0; 82 } 83 EXPORT_SYMBOL(mdiobus_register_device); 84 85 int mdiobus_unregister_device(struct mdio_device *mdiodev) 86 { 87 if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev) 88 return -EINVAL; 89 90 mdiodev->bus->mdio_map[mdiodev->addr] = NULL; 91 92 return 0; 93 } 94 EXPORT_SYMBOL(mdiobus_unregister_device); 95 96 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr) 97 { 98 struct mdio_device *mdiodev = bus->mdio_map[addr]; 99 100 if (!mdiodev) 101 return NULL; 102 103 if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY)) 104 return NULL; 105 106 return container_of(mdiodev, struct phy_device, mdio); 107 } 108 EXPORT_SYMBOL(mdiobus_get_phy); 109 110 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr) 111 { 112 return bus->mdio_map[addr]; 113 } 114 EXPORT_SYMBOL(mdiobus_is_registered_device); 115 116 /** 117 * mdiobus_alloc_size - allocate a mii_bus structure 118 * @size: extra amount of memory to allocate for private storage. 119 * If non-zero, then bus->priv is points to that memory. 120 * 121 * Description: called by a bus driver to allocate an mii_bus 122 * structure to fill in. 123 */ 124 struct mii_bus *mdiobus_alloc_size(size_t size) 125 { 126 struct mii_bus *bus; 127 size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN); 128 size_t alloc_size; 129 int i; 130 131 /* If we alloc extra space, it should be aligned */ 132 if (size) 133 alloc_size = aligned_size + size; 134 else 135 alloc_size = sizeof(*bus); 136 137 bus = kzalloc(alloc_size, GFP_KERNEL); 138 if (!bus) 139 return NULL; 140 141 bus->state = MDIOBUS_ALLOCATED; 142 if (size) 143 bus->priv = (void *)bus + aligned_size; 144 145 /* Initialise the interrupts to polling */ 146 for (i = 0; i < PHY_MAX_ADDR; i++) 147 bus->irq[i] = PHY_POLL; 148 149 return bus; 150 } 151 EXPORT_SYMBOL(mdiobus_alloc_size); 152 153 static void _devm_mdiobus_free(struct device *dev, void *res) 154 { 155 mdiobus_free(*(struct mii_bus **)res); 156 } 157 158 static int devm_mdiobus_match(struct device *dev, void *res, void *data) 159 { 160 struct mii_bus **r = res; 161 162 if (WARN_ON(!r || !*r)) 163 return 0; 164 165 return *r == data; 166 } 167 168 /** 169 * devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size() 170 * @dev: Device to allocate mii_bus for 171 * @sizeof_priv: Space to allocate for private structure. 172 * 173 * Managed mdiobus_alloc_size. mii_bus allocated with this function is 174 * automatically freed on driver detach. 175 * 176 * If an mii_bus allocated with this function needs to be freed separately, 177 * devm_mdiobus_free() must be used. 178 * 179 * RETURNS: 180 * Pointer to allocated mii_bus on success, NULL on failure. 181 */ 182 struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv) 183 { 184 struct mii_bus **ptr, *bus; 185 186 ptr = devres_alloc(_devm_mdiobus_free, sizeof(*ptr), GFP_KERNEL); 187 if (!ptr) 188 return NULL; 189 190 /* use raw alloc_dr for kmalloc caller tracing */ 191 bus = mdiobus_alloc_size(sizeof_priv); 192 if (bus) { 193 *ptr = bus; 194 devres_add(dev, ptr); 195 } else { 196 devres_free(ptr); 197 } 198 199 return bus; 200 } 201 EXPORT_SYMBOL_GPL(devm_mdiobus_alloc_size); 202 203 /** 204 * devm_mdiobus_free - Resource-managed mdiobus_free() 205 * @dev: Device this mii_bus belongs to 206 * @bus: the mii_bus associated with the device 207 * 208 * Free mii_bus allocated with devm_mdiobus_alloc_size(). 209 */ 210 void devm_mdiobus_free(struct device *dev, struct mii_bus *bus) 211 { 212 int rc; 213 214 rc = devres_release(dev, _devm_mdiobus_free, 215 devm_mdiobus_match, bus); 216 WARN_ON(rc); 217 } 218 EXPORT_SYMBOL_GPL(devm_mdiobus_free); 219 220 /** 221 * mdiobus_release - mii_bus device release callback 222 * @d: the target struct device that contains the mii_bus 223 * 224 * Description: called when the last reference to an mii_bus is 225 * dropped, to free the underlying memory. 226 */ 227 static void mdiobus_release(struct device *d) 228 { 229 struct mii_bus *bus = to_mii_bus(d); 230 BUG_ON(bus->state != MDIOBUS_RELEASED && 231 /* for compatibility with error handling in drivers */ 232 bus->state != MDIOBUS_ALLOCATED); 233 kfree(bus); 234 } 235 236 static struct class mdio_bus_class = { 237 .name = "mdio_bus", 238 .dev_release = mdiobus_release, 239 }; 240 241 #if IS_ENABLED(CONFIG_OF_MDIO) 242 /* Helper function for of_mdio_find_bus */ 243 static int of_mdio_bus_match(struct device *dev, const void *mdio_bus_np) 244 { 245 return dev->of_node == mdio_bus_np; 246 } 247 /** 248 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus. 249 * @mdio_bus_np: Pointer to the mii_bus. 250 * 251 * Returns a reference to the mii_bus, or NULL if none found. The 252 * embedded struct device will have its reference count incremented, 253 * and this must be put once the bus is finished with. 254 * 255 * Because the association of a device_node and mii_bus is made via 256 * of_mdiobus_register(), the mii_bus cannot be found before it is 257 * registered with of_mdiobus_register(). 258 * 259 */ 260 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np) 261 { 262 struct device *d; 263 264 if (!mdio_bus_np) 265 return NULL; 266 267 d = class_find_device(&mdio_bus_class, NULL, mdio_bus_np, 268 of_mdio_bus_match); 269 270 return d ? to_mii_bus(d) : NULL; 271 } 272 EXPORT_SYMBOL(of_mdio_find_bus); 273 274 /* Walk the list of subnodes of a mdio bus and look for a node that 275 * matches the mdio device's address with its 'reg' property. If 276 * found, set the of_node pointer for the mdio device. This allows 277 * auto-probed phy devices to be supplied with information passed in 278 * via DT. 279 */ 280 static void of_mdiobus_link_mdiodev(struct mii_bus *bus, 281 struct mdio_device *mdiodev) 282 { 283 struct device *dev = &mdiodev->dev; 284 struct device_node *child; 285 286 if (dev->of_node || !bus->dev.of_node) 287 return; 288 289 for_each_available_child_of_node(bus->dev.of_node, child) { 290 int addr; 291 292 addr = of_mdio_parse_addr(dev, child); 293 if (addr < 0) 294 continue; 295 296 if (addr == mdiodev->addr) { 297 dev->of_node = child; 298 dev->fwnode = of_fwnode_handle(child); 299 return; 300 } 301 } 302 } 303 #else /* !IS_ENABLED(CONFIG_OF_MDIO) */ 304 static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio, 305 struct mdio_device *mdiodev) 306 { 307 } 308 #endif 309 310 /** 311 * mdiobus_create_device_from_board_info - create a full MDIO device given 312 * a mdio_board_info structure 313 * @bus: MDIO bus to create the devices on 314 * @bi: mdio_board_info structure describing the devices 315 * 316 * Returns 0 on success or < 0 on error. 317 */ 318 static int mdiobus_create_device(struct mii_bus *bus, 319 struct mdio_board_info *bi) 320 { 321 struct mdio_device *mdiodev; 322 int ret = 0; 323 324 mdiodev = mdio_device_create(bus, bi->mdio_addr); 325 if (IS_ERR(mdiodev)) 326 return -ENODEV; 327 328 strncpy(mdiodev->modalias, bi->modalias, 329 sizeof(mdiodev->modalias)); 330 mdiodev->bus_match = mdio_device_bus_match; 331 mdiodev->dev.platform_data = (void *)bi->platform_data; 332 333 ret = mdio_device_register(mdiodev); 334 if (ret) 335 mdio_device_free(mdiodev); 336 337 return ret; 338 } 339 340 /** 341 * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus 342 * @bus: target mii_bus 343 * @owner: module containing bus accessor functions 344 * 345 * Description: Called by a bus driver to bring up all the PHYs 346 * on a given bus, and attach them to the bus. Drivers should use 347 * mdiobus_register() rather than __mdiobus_register() unless they 348 * need to pass a specific owner module. MDIO devices which are not 349 * PHYs will not be brought up by this function. They are expected to 350 * to be explicitly listed in DT and instantiated by of_mdiobus_register(). 351 * 352 * Returns 0 on success or < 0 on error. 353 */ 354 int __mdiobus_register(struct mii_bus *bus, struct module *owner) 355 { 356 struct mdio_device *mdiodev; 357 int i, err; 358 struct gpio_desc *gpiod; 359 360 if (NULL == bus || NULL == bus->name || 361 NULL == bus->read || NULL == bus->write) 362 return -EINVAL; 363 364 BUG_ON(bus->state != MDIOBUS_ALLOCATED && 365 bus->state != MDIOBUS_UNREGISTERED); 366 367 bus->owner = owner; 368 bus->dev.parent = bus->parent; 369 bus->dev.class = &mdio_bus_class; 370 bus->dev.groups = NULL; 371 dev_set_name(&bus->dev, "%s", bus->id); 372 373 err = device_register(&bus->dev); 374 if (err) { 375 pr_err("mii_bus %s failed to register\n", bus->id); 376 return -EINVAL; 377 } 378 379 mutex_init(&bus->mdio_lock); 380 381 /* de-assert bus level PHY GPIO reset */ 382 gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_LOW); 383 if (IS_ERR(gpiod)) { 384 dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n", 385 bus->id); 386 device_del(&bus->dev); 387 return PTR_ERR(gpiod); 388 } else if (gpiod) { 389 bus->reset_gpiod = gpiod; 390 391 gpiod_set_value_cansleep(gpiod, 1); 392 udelay(bus->reset_delay_us); 393 gpiod_set_value_cansleep(gpiod, 0); 394 } 395 396 if (bus->reset) 397 bus->reset(bus); 398 399 for (i = 0; i < PHY_MAX_ADDR; i++) { 400 if ((bus->phy_mask & (1 << i)) == 0) { 401 struct phy_device *phydev; 402 403 phydev = mdiobus_scan(bus, i); 404 if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV)) { 405 err = PTR_ERR(phydev); 406 goto error; 407 } 408 } 409 } 410 411 mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device); 412 413 bus->state = MDIOBUS_REGISTERED; 414 pr_info("%s: probed\n", bus->name); 415 return 0; 416 417 error: 418 while (--i >= 0) { 419 mdiodev = bus->mdio_map[i]; 420 if (!mdiodev) 421 continue; 422 423 mdiodev->device_remove(mdiodev); 424 mdiodev->device_free(mdiodev); 425 } 426 427 /* Put PHYs in RESET to save power */ 428 if (bus->reset_gpiod) 429 gpiod_set_value_cansleep(bus->reset_gpiod, 1); 430 431 device_del(&bus->dev); 432 return err; 433 } 434 EXPORT_SYMBOL(__mdiobus_register); 435 436 void mdiobus_unregister(struct mii_bus *bus) 437 { 438 struct mdio_device *mdiodev; 439 int i; 440 441 BUG_ON(bus->state != MDIOBUS_REGISTERED); 442 bus->state = MDIOBUS_UNREGISTERED; 443 444 for (i = 0; i < PHY_MAX_ADDR; i++) { 445 mdiodev = bus->mdio_map[i]; 446 if (!mdiodev) 447 continue; 448 449 if (mdiodev->reset) 450 gpiod_put(mdiodev->reset); 451 452 mdiodev->device_remove(mdiodev); 453 mdiodev->device_free(mdiodev); 454 } 455 456 /* Put PHYs in RESET to save power */ 457 if (bus->reset_gpiod) 458 gpiod_set_value_cansleep(bus->reset_gpiod, 1); 459 460 device_del(&bus->dev); 461 } 462 EXPORT_SYMBOL(mdiobus_unregister); 463 464 /** 465 * mdiobus_free - free a struct mii_bus 466 * @bus: mii_bus to free 467 * 468 * This function releases the reference to the underlying device 469 * object in the mii_bus. If this is the last reference, the mii_bus 470 * will be freed. 471 */ 472 void mdiobus_free(struct mii_bus *bus) 473 { 474 /* For compatibility with error handling in drivers. */ 475 if (bus->state == MDIOBUS_ALLOCATED) { 476 kfree(bus); 477 return; 478 } 479 480 BUG_ON(bus->state != MDIOBUS_UNREGISTERED); 481 bus->state = MDIOBUS_RELEASED; 482 483 put_device(&bus->dev); 484 } 485 EXPORT_SYMBOL(mdiobus_free); 486 487 /** 488 * mdiobus_scan - scan a bus for MDIO devices. 489 * @bus: mii_bus to scan 490 * @addr: address on bus to scan 491 * 492 * This function scans the MDIO bus, looking for devices which can be 493 * identified using a vendor/product ID in registers 2 and 3. Not all 494 * MDIO devices have such registers, but PHY devices typically 495 * do. Hence this function assumes anything found is a PHY, or can be 496 * treated as a PHY. Other MDIO devices, such as switches, will 497 * probably not be found during the scan. 498 */ 499 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr) 500 { 501 struct phy_device *phydev; 502 int err; 503 504 phydev = get_phy_device(bus, addr, false); 505 if (IS_ERR(phydev)) 506 return phydev; 507 508 /* 509 * For DT, see if the auto-probed phy has a correspoding child 510 * in the bus node, and set the of_node pointer in this case. 511 */ 512 of_mdiobus_link_mdiodev(bus, &phydev->mdio); 513 514 err = phy_device_register(phydev); 515 if (err) { 516 phy_device_free(phydev); 517 return ERR_PTR(-ENODEV); 518 } 519 520 return phydev; 521 } 522 EXPORT_SYMBOL(mdiobus_scan); 523 524 /** 525 * __mdiobus_read - Unlocked version of the mdiobus_read function 526 * @bus: the mii_bus struct 527 * @addr: the phy address 528 * @regnum: register number to read 529 * 530 * Read a MDIO bus register. Caller must hold the mdio bus lock. 531 * 532 * NOTE: MUST NOT be called from interrupt context. 533 */ 534 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 535 { 536 int retval; 537 538 WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock)); 539 540 retval = bus->read(bus, addr, regnum); 541 542 trace_mdio_access(bus, 1, addr, regnum, retval, retval); 543 544 return retval; 545 } 546 EXPORT_SYMBOL(__mdiobus_read); 547 548 /** 549 * __mdiobus_write - Unlocked version of the mdiobus_write function 550 * @bus: the mii_bus struct 551 * @addr: the phy address 552 * @regnum: register number to write 553 * @val: value to write to @regnum 554 * 555 * Write a MDIO bus register. Caller must hold the mdio bus lock. 556 * 557 * NOTE: MUST NOT be called from interrupt context. 558 */ 559 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 560 { 561 int err; 562 563 WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock)); 564 565 err = bus->write(bus, addr, regnum, val); 566 567 trace_mdio_access(bus, 0, addr, regnum, val, err); 568 569 return err; 570 } 571 EXPORT_SYMBOL(__mdiobus_write); 572 573 /** 574 * mdiobus_read_nested - Nested version of the mdiobus_read function 575 * @bus: the mii_bus struct 576 * @addr: the phy address 577 * @regnum: register number to read 578 * 579 * In case of nested MDIO bus access avoid lockdep false positives by 580 * using mutex_lock_nested(). 581 * 582 * NOTE: MUST NOT be called from interrupt context, 583 * because the bus read/write functions may wait for an interrupt 584 * to conclude the operation. 585 */ 586 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum) 587 { 588 int retval; 589 590 BUG_ON(in_interrupt()); 591 592 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 593 retval = __mdiobus_read(bus, addr, regnum); 594 mutex_unlock(&bus->mdio_lock); 595 596 return retval; 597 } 598 EXPORT_SYMBOL(mdiobus_read_nested); 599 600 /** 601 * mdiobus_read - Convenience function for reading a given MII mgmt register 602 * @bus: the mii_bus struct 603 * @addr: the phy address 604 * @regnum: register number to read 605 * 606 * NOTE: MUST NOT be called from interrupt context, 607 * because the bus read/write functions may wait for an interrupt 608 * to conclude the operation. 609 */ 610 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 611 { 612 int retval; 613 614 BUG_ON(in_interrupt()); 615 616 mutex_lock(&bus->mdio_lock); 617 retval = __mdiobus_read(bus, addr, regnum); 618 mutex_unlock(&bus->mdio_lock); 619 620 return retval; 621 } 622 EXPORT_SYMBOL(mdiobus_read); 623 624 /** 625 * mdiobus_write_nested - Nested version of the mdiobus_write function 626 * @bus: the mii_bus struct 627 * @addr: the phy address 628 * @regnum: register number to write 629 * @val: value to write to @regnum 630 * 631 * In case of nested MDIO bus access avoid lockdep false positives by 632 * using mutex_lock_nested(). 633 * 634 * NOTE: MUST NOT be called from interrupt context, 635 * because the bus read/write functions may wait for an interrupt 636 * to conclude the operation. 637 */ 638 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val) 639 { 640 int err; 641 642 BUG_ON(in_interrupt()); 643 644 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 645 err = __mdiobus_write(bus, addr, regnum, val); 646 mutex_unlock(&bus->mdio_lock); 647 648 return err; 649 } 650 EXPORT_SYMBOL(mdiobus_write_nested); 651 652 /** 653 * mdiobus_write - Convenience function for writing a given MII mgmt register 654 * @bus: the mii_bus struct 655 * @addr: the phy address 656 * @regnum: register number to write 657 * @val: value to write to @regnum 658 * 659 * NOTE: MUST NOT be called from interrupt context, 660 * because the bus read/write functions may wait for an interrupt 661 * to conclude the operation. 662 */ 663 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 664 { 665 int err; 666 667 BUG_ON(in_interrupt()); 668 669 mutex_lock(&bus->mdio_lock); 670 err = __mdiobus_write(bus, addr, regnum, val); 671 mutex_unlock(&bus->mdio_lock); 672 673 return err; 674 } 675 EXPORT_SYMBOL(mdiobus_write); 676 677 /** 678 * mdio_bus_match - determine if given MDIO driver supports the given 679 * MDIO device 680 * @dev: target MDIO device 681 * @drv: given MDIO driver 682 * 683 * Description: Given a MDIO device, and a MDIO driver, return 1 if 684 * the driver supports the device. Otherwise, return 0. This may 685 * require calling the devices own match function, since different classes 686 * of MDIO devices have different match criteria. 687 */ 688 static int mdio_bus_match(struct device *dev, struct device_driver *drv) 689 { 690 struct mdio_device *mdio = to_mdio_device(dev); 691 692 if (of_driver_match_device(dev, drv)) 693 return 1; 694 695 if (mdio->bus_match) 696 return mdio->bus_match(dev, drv); 697 698 return 0; 699 } 700 701 static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env) 702 { 703 int rc; 704 705 /* Some devices have extra OF data and an OF-style MODALIAS */ 706 rc = of_device_uevent_modalias(dev, env); 707 if (rc != -ENODEV) 708 return rc; 709 710 return 0; 711 } 712 713 struct bus_type mdio_bus_type = { 714 .name = "mdio_bus", 715 .match = mdio_bus_match, 716 .uevent = mdio_uevent, 717 }; 718 EXPORT_SYMBOL(mdio_bus_type); 719 720 int __init mdio_bus_init(void) 721 { 722 int ret; 723 724 ret = class_register(&mdio_bus_class); 725 if (!ret) { 726 ret = bus_register(&mdio_bus_type); 727 if (ret) 728 class_unregister(&mdio_bus_class); 729 } 730 731 return ret; 732 } 733 EXPORT_SYMBOL_GPL(mdio_bus_init); 734 735 #if IS_ENABLED(CONFIG_PHYLIB) 736 void mdio_bus_exit(void) 737 { 738 class_unregister(&mdio_bus_class); 739 bus_unregister(&mdio_bus_type); 740 } 741 EXPORT_SYMBOL_GPL(mdio_bus_exit); 742 #else 743 module_init(mdio_bus_init); 744 /* no module_exit, intentional */ 745 MODULE_LICENSE("GPL"); 746 MODULE_DESCRIPTION("MDIO bus/device layer"); 747 #endif 748