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