drivers/net/phy/mdio_bus.c

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