drivers/net/phy/mdio_bus.c

   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