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