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/delay.h>
  12 #include <linux/device.h>
  13 #include <linux/errno.h>
  14 #include <linux/etherdevice.h>
  15 #include <linux/ethtool.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/init.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/io.h>
  20 #include <linux/kernel.h>
  21 #include <linux/micrel_phy.h>
  22 #include <linux/mii.h>
  23 #include <linux/mm.h>
  24 #include <linux/module.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/of_device.h>
  27 #include <linux/of_mdio.h>
  28 #include <linux/phy.h>
  29 #include <linux/reset.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/slab.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/string.h>
  34 #include <linux/uaccess.h>
  35 #include <linux/unistd.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         /* Deassert the optional reset signal */
  45         mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
  46                                                  "reset", GPIOD_OUT_LOW);
  47         if (IS_ERR(mdiodev->reset_gpio))
  48                 return PTR_ERR(mdiodev->reset_gpio);
  49
  50         if (mdiodev->reset_gpio)
  51                 gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
  52
  53         return 0;
  54 }
  55
  56 static int mdiobus_register_reset(struct mdio_device *mdiodev)
  57 {
  58         struct reset_control *reset;
  59
  60         reset = reset_control_get_optional_exclusive(&mdiodev->dev, "phy");
  61         if (IS_ERR(reset))
  62                 return PTR_ERR(reset);
  63
  64         mdiodev->reset_ctrl = reset;
  65
  66         return 0;
  67 }
  68
  69 int mdiobus_register_device(struct mdio_device *mdiodev)
  70 {
  71         int err;
  72
  73         if (mdiodev->bus->mdio_map[mdiodev->addr])
  74                 return -EBUSY;
  75
  76         if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
  77                 err = mdiobus_register_gpiod(mdiodev);
  78                 if (err)
  79                         return err;
  80
  81                 err = mdiobus_register_reset(mdiodev);
  82                 if (err)
  83                         return err;
  84
  85                 /* Assert the reset signal */
  86                 mdio_device_reset(mdiodev, 1);
  87         }
  88
  89         mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
  90
  91         return 0;
  92 }
  93 EXPORT_SYMBOL(mdiobus_register_device);
  94
  95 int mdiobus_unregister_device(struct mdio_device *mdiodev)
  96 {
  97         if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
  98                 return -EINVAL;
  99
 100         reset_control_put(mdiodev->reset_ctrl);
 101
 102         mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
 103
 104         return 0;
 105 }
 106 EXPORT_SYMBOL(mdiobus_unregister_device);
 107
 108 static struct mdio_device *mdiobus_find_device(struct mii_bus *bus, int addr)
 109 {
 110         bool addr_valid = addr >= 0 && addr < ARRAY_SIZE(bus->mdio_map);
 111
 112         if (WARN_ONCE(!addr_valid, "addr %d out of range\n", addr))
 113                 return NULL;
 114
 115         return bus->mdio_map[addr];
 116 }
 117
 118 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
 119 {
 120         struct mdio_device *mdiodev;
 121
 122         mdiodev = mdiobus_find_device(bus, addr);
 123         if (!mdiodev)
 124                 return NULL;
 125
 126         if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
 127                 return NULL;
 128
 129         return container_of(mdiodev, struct phy_device, mdio);
 130 }
 131 EXPORT_SYMBOL(mdiobus_get_phy);
 132
 133 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
 134 {
 135         return mdiobus_find_device(bus, addr) != NULL;
 136 }
 137 EXPORT_SYMBOL(mdiobus_is_registered_device);
 138
 139 /**
 140  * mdiobus_alloc_size - allocate a mii_bus structure
 141  * @size: extra amount of memory to allocate for private storage.
 142  * If non-zero, then bus->priv is points to that memory.
 143  *
 144  * Description: called by a bus driver to allocate an mii_bus
 145  * structure to fill in.
 146  */
 147 struct mii_bus *mdiobus_alloc_size(size_t size)
 148 {
 149         struct mii_bus *bus;
 150         size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
 151         size_t alloc_size;
 152         int i;
 153
 154         /* If we alloc extra space, it should be aligned */
 155         if (size)
 156                 alloc_size = aligned_size + size;
 157         else
 158                 alloc_size = sizeof(*bus);
 159
 160         bus = kzalloc(alloc_size, GFP_KERNEL);
 161         if (!bus)
 162                 return NULL;
 163
 164         bus->state = MDIOBUS_ALLOCATED;
 165         if (size)
 166                 bus->priv = (void *)bus + aligned_size;
 167
 168         /* Initialise the interrupts to polling and 64-bit seqcounts */
 169         for (i = 0; i < PHY_MAX_ADDR; i++) {
 170                 bus->irq[i] = PHY_POLL;
 171                 u64_stats_init(&bus->stats[i].syncp);
 172         }
 173
 174         return bus;
 175 }
 176 EXPORT_SYMBOL(mdiobus_alloc_size);
 177
 178 /**
 179  * mdiobus_release - mii_bus device release callback
 180  * @d: the target struct device that contains the mii_bus
 181  *
 182  * Description: called when the last reference to an mii_bus is
 183  * dropped, to free the underlying memory.
 184  */
 185 static void mdiobus_release(struct device *d)
 186 {
 187         struct mii_bus *bus = to_mii_bus(d);
 188
 189         WARN(bus->state != MDIOBUS_RELEASED &&
 190              /* for compatibility with error handling in drivers */
 191              bus->state != MDIOBUS_ALLOCATED,
 192              "%s: not in RELEASED or ALLOCATED state\n",
 193              bus->id);
 194
 195         if (bus->state == MDIOBUS_RELEASED)
 196                 fwnode_handle_put(dev_fwnode(d));
 197
 198         kfree(bus);
 199 }
 200
 201 struct mdio_bus_stat_attr {
 202         int addr;
 203         unsigned int field_offset;
 204 };
 205
 206 static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset)
 207 {
 208         const char *p = (const char *)s + offset;
 209         unsigned int start;
 210         u64 val = 0;
 211
 212         do {
 213                 start = u64_stats_fetch_begin(&s->syncp);
 214                 val = u64_stats_read((const u64_stats_t *)p);
 215         } while (u64_stats_fetch_retry(&s->syncp, start));
 216
 217         return val;
 218 }
 219
 220 static u64 mdio_bus_get_global_stat(struct mii_bus *bus, unsigned int offset)
 221 {
 222         unsigned int i;
 223         u64 val = 0;
 224
 225         for (i = 0; i < PHY_MAX_ADDR; i++)
 226                 val += mdio_bus_get_stat(&bus->stats[i], offset);
 227
 228         return val;
 229 }
 230
 231 static ssize_t mdio_bus_stat_field_show(struct device *dev,
 232                                         struct device_attribute *attr,
 233                                         char *buf)
 234 {
 235         struct mii_bus *bus = to_mii_bus(dev);
 236         struct mdio_bus_stat_attr *sattr;
 237         struct dev_ext_attribute *eattr;
 238         u64 val;
 239
 240         eattr = container_of(attr, struct dev_ext_attribute, attr);
 241         sattr = eattr->var;
 242
 243         if (sattr->addr < 0)
 244                 val = mdio_bus_get_global_stat(bus, sattr->field_offset);
 245         else
 246                 val = mdio_bus_get_stat(&bus->stats[sattr->addr],
 247                                         sattr->field_offset);
 248
 249         return sysfs_emit(buf, "%llu\n", val);
 250 }
 251
 252 static ssize_t mdio_bus_device_stat_field_show(struct device *dev,
 253                                                struct device_attribute *attr,
 254                                                char *buf)
 255 {
 256         struct mdio_device *mdiodev = to_mdio_device(dev);
 257         struct mii_bus *bus = mdiodev->bus;
 258         struct mdio_bus_stat_attr *sattr;
 259         struct dev_ext_attribute *eattr;
 260         int addr = mdiodev->addr;
 261         u64 val;
 262
 263         eattr = container_of(attr, struct dev_ext_attribute, attr);
 264         sattr = eattr->var;
 265
 266         val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset);
 267
 268         return sysfs_emit(buf, "%llu\n", val);
 269 }
 270
 271 #define MDIO_BUS_STATS_ATTR_DECL(field, file)                           \
 272 static struct dev_ext_attribute dev_attr_mdio_bus_##field = {           \
 273         .attr = { .attr = { .name = file, .mode = 0444 },               \
 274                      .show = mdio_bus_stat_field_show,                  \
 275         },                                                              \
 276         .var = &((struct mdio_bus_stat_attr) {                          \
 277                 -1, offsetof(struct mdio_bus_stats, field)              \
 278         }),                                                             \
 279 };                                                                      \
 280 static struct dev_ext_attribute dev_attr_mdio_bus_device_##field = {    \
 281         .attr = { .attr = { .name = file, .mode = 0444 },               \
 282                      .show = mdio_bus_device_stat_field_show,           \
 283         },                                                              \
 284         .var = &((struct mdio_bus_stat_attr) {                          \
 285                 -1, offsetof(struct mdio_bus_stats, field)              \
 286         }),                                                             \
 287 };
 288
 289 #define MDIO_BUS_STATS_ATTR(field)                                      \
 290         MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
 291
 292 MDIO_BUS_STATS_ATTR(transfers);
 293 MDIO_BUS_STATS_ATTR(errors);
 294 MDIO_BUS_STATS_ATTR(writes);
 295 MDIO_BUS_STATS_ATTR(reads);
 296
 297 #define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file)                \
 298 static struct dev_ext_attribute dev_attr_mdio_bus_addr_##field##_##addr = { \
 299         .attr = { .attr = { .name = file, .mode = 0444 },               \
 300                      .show = mdio_bus_stat_field_show,                  \
 301         },                                                              \
 302         .var = &((struct mdio_bus_stat_attr) {                          \
 303                 addr, offsetof(struct mdio_bus_stats, field)            \
 304         }),                                                             \
 305 }
 306
 307 #define MDIO_BUS_STATS_ADDR_ATTR(field, addr)                           \
 308         MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr,                      \
 309                                  __stringify(field) "_" __stringify(addr))
 310
 311 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr)                       \
 312         MDIO_BUS_STATS_ADDR_ATTR(transfers, addr);                      \
 313         MDIO_BUS_STATS_ADDR_ATTR(errors, addr);                         \
 314         MDIO_BUS_STATS_ADDR_ATTR(writes, addr);                         \
 315         MDIO_BUS_STATS_ADDR_ATTR(reads, addr)                           \
 316
 317 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0);
 318 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1);
 319 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2);
 320 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3);
 321 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4);
 322 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5);
 323 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6);
 324 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7);
 325 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8);
 326 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9);
 327 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10);
 328 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11);
 329 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12);
 330 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13);
 331 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14);
 332 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15);
 333 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16);
 334 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17);
 335 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18);
 336 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19);
 337 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20);
 338 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21);
 339 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22);
 340 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23);
 341 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24);
 342 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25);
 343 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26);
 344 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27);
 345 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28);
 346 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29);
 347 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30);
 348 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31);
 349
 350 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr)                            \
 351         &dev_attr_mdio_bus_addr_transfers_##addr.attr.attr,             \
 352         &dev_attr_mdio_bus_addr_errors_##addr.attr.attr,                \
 353         &dev_attr_mdio_bus_addr_writes_##addr.attr.attr,                \
 354         &dev_attr_mdio_bus_addr_reads_##addr.attr.attr                  \
 355
 356 static struct attribute *mdio_bus_statistics_attrs[] = {
 357         &dev_attr_mdio_bus_transfers.attr.attr,
 358         &dev_attr_mdio_bus_errors.attr.attr,
 359         &dev_attr_mdio_bus_writes.attr.attr,
 360         &dev_attr_mdio_bus_reads.attr.attr,
 361         MDIO_BUS_STATS_ADDR_ATTR_GROUP(0),
 362         MDIO_BUS_STATS_ADDR_ATTR_GROUP(1),
 363         MDIO_BUS_STATS_ADDR_ATTR_GROUP(2),
 364         MDIO_BUS_STATS_ADDR_ATTR_GROUP(3),
 365         MDIO_BUS_STATS_ADDR_ATTR_GROUP(4),
 366         MDIO_BUS_STATS_ADDR_ATTR_GROUP(5),
 367         MDIO_BUS_STATS_ADDR_ATTR_GROUP(6),
 368         MDIO_BUS_STATS_ADDR_ATTR_GROUP(7),
 369         MDIO_BUS_STATS_ADDR_ATTR_GROUP(8),
 370         MDIO_BUS_STATS_ADDR_ATTR_GROUP(9),
 371         MDIO_BUS_STATS_ADDR_ATTR_GROUP(10),
 372         MDIO_BUS_STATS_ADDR_ATTR_GROUP(11),
 373         MDIO_BUS_STATS_ADDR_ATTR_GROUP(12),
 374         MDIO_BUS_STATS_ADDR_ATTR_GROUP(13),
 375         MDIO_BUS_STATS_ADDR_ATTR_GROUP(14),
 376         MDIO_BUS_STATS_ADDR_ATTR_GROUP(15),
 377         MDIO_BUS_STATS_ADDR_ATTR_GROUP(16),
 378         MDIO_BUS_STATS_ADDR_ATTR_GROUP(17),
 379         MDIO_BUS_STATS_ADDR_ATTR_GROUP(18),
 380         MDIO_BUS_STATS_ADDR_ATTR_GROUP(19),
 381         MDIO_BUS_STATS_ADDR_ATTR_GROUP(20),
 382         MDIO_BUS_STATS_ADDR_ATTR_GROUP(21),
 383         MDIO_BUS_STATS_ADDR_ATTR_GROUP(22),
 384         MDIO_BUS_STATS_ADDR_ATTR_GROUP(23),
 385         MDIO_BUS_STATS_ADDR_ATTR_GROUP(24),
 386         MDIO_BUS_STATS_ADDR_ATTR_GROUP(25),
 387         MDIO_BUS_STATS_ADDR_ATTR_GROUP(26),
 388         MDIO_BUS_STATS_ADDR_ATTR_GROUP(27),
 389         MDIO_BUS_STATS_ADDR_ATTR_GROUP(28),
 390         MDIO_BUS_STATS_ADDR_ATTR_GROUP(29),
 391         MDIO_BUS_STATS_ADDR_ATTR_GROUP(30),
 392         MDIO_BUS_STATS_ADDR_ATTR_GROUP(31),
 393         NULL,
 394 };
 395
 396 static const struct attribute_group mdio_bus_statistics_group = {
 397         .name   = "statistics",
 398         .attrs  = mdio_bus_statistics_attrs,
 399 };
 400
 401 static const struct attribute_group *mdio_bus_groups[] = {
 402         &mdio_bus_statistics_group,
 403         NULL,
 404 };
 405
 406 static struct class mdio_bus_class = {
 407         .name           = "mdio_bus",
 408         .dev_release    = mdiobus_release,
 409         .dev_groups     = mdio_bus_groups,
 410 };
 411
 412 /**
 413  * mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
 414  * @mdio_name: The name of a mdiobus.
 415  *
 416  * Returns a reference to the mii_bus, or NULL if none found.  The
 417  * embedded struct device will have its reference count incremented,
 418  * and this must be put_deviced'ed once the bus is finished with.
 419  */
 420 struct mii_bus *mdio_find_bus(const char *mdio_name)
 421 {
 422         struct device *d;
 423
 424         d = class_find_device_by_name(&mdio_bus_class, mdio_name);
 425         return d ? to_mii_bus(d) : NULL;
 426 }
 427 EXPORT_SYMBOL(mdio_find_bus);
 428
 429 #if IS_ENABLED(CONFIG_OF_MDIO)
 430 /**
 431  * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
 432  * @mdio_bus_np: Pointer to the mii_bus.
 433  *
 434  * Returns a reference to the mii_bus, or NULL if none found.  The
 435  * embedded struct device will have its reference count incremented,
 436  * and this must be put once the bus is finished with.
 437  *
 438  * Because the association of a device_node and mii_bus is made via
 439  * of_mdiobus_register(), the mii_bus cannot be found before it is
 440  * registered with of_mdiobus_register().
 441  *
 442  */
 443 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
 444 {
 445         struct device *d;
 446
 447         if (!mdio_bus_np)
 448                 return NULL;
 449
 450         d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
 451         return d ? to_mii_bus(d) : NULL;
 452 }
 453 EXPORT_SYMBOL(of_mdio_find_bus);
 454
 455 /* Walk the list of subnodes of a mdio bus and look for a node that
 456  * matches the mdio device's address with its 'reg' property. If
 457  * found, set the of_node pointer for the mdio device. This allows
 458  * auto-probed phy devices to be supplied with information passed in
 459  * via DT.
 460  * If a PHY package is found, PHY is searched also there.
 461  */
 462 static int of_mdiobus_find_phy(struct device *dev, struct mdio_device *mdiodev,
 463                                struct device_node *np)
 464 {
 465         struct device_node *child;
 466
 467         for_each_available_child_of_node(np, child) {
 468                 int addr;
 469
 470                 if (of_node_name_eq(child, "ethernet-phy-package")) {
 471                         /* Validate PHY package reg presence */
 472                         if (!of_property_present(child, "reg")) {
 473                                 of_node_put(child);
 474                                 return -EINVAL;
 475                         }
 476
 477                         if (!of_mdiobus_find_phy(dev, mdiodev, child)) {
 478                                 /* The refcount for the PHY package will be
 479                                  * incremented later when PHY join the Package.
 480                                  */
 481                                 of_node_put(child);
 482                                 return 0;
 483                         }
 484
 485                         continue;
 486                 }
 487
 488                 addr = of_mdio_parse_addr(dev, child);
 489                 if (addr < 0)
 490                         continue;
 491
 492                 if (addr == mdiodev->addr) {
 493                         device_set_node(dev, of_fwnode_handle(child));
 494                         /* The refcount on "child" is passed to the mdio
 495                          * device. Do _not_ use of_node_put(child) here.
 496                          */
 497                         return 0;
 498                 }
 499         }
 500
 501         return -ENODEV;
 502 }
 503
 504 static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
 505                                     struct mdio_device *mdiodev)
 506 {
 507         struct device *dev = &mdiodev->dev;
 508
 509         if (dev->of_node || !bus->dev.of_node)
 510                 return;
 511
 512         of_mdiobus_find_phy(dev, mdiodev, bus->dev.of_node);
 513 }
 514 #else /* !IS_ENABLED(CONFIG_OF_MDIO) */
 515 static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
 516                                            struct mdio_device *mdiodev)
 517 {
 518 }
 519 #endif
 520
 521 /**
 522  * mdiobus_create_device - create a full MDIO device given
 523  * a mdio_board_info structure
 524  * @bus: MDIO bus to create the devices on
 525  * @bi: mdio_board_info structure describing the devices
 526  *
 527  * Returns 0 on success or < 0 on error.
 528  */
 529 static int mdiobus_create_device(struct mii_bus *bus,
 530                                  struct mdio_board_info *bi)
 531 {
 532         struct mdio_device *mdiodev;
 533         int ret = 0;
 534
 535         mdiodev = mdio_device_create(bus, bi->mdio_addr);
 536         if (IS_ERR(mdiodev))
 537                 return -ENODEV;
 538
 539         strscpy(mdiodev->modalias, bi->modalias,
 540                 sizeof(mdiodev->modalias));
 541         mdiodev->bus_match = mdio_device_bus_match;
 542         mdiodev->dev.platform_data = (void *)bi->platform_data;
 543
 544         ret = mdio_device_register(mdiodev);
 545         if (ret)
 546                 mdio_device_free(mdiodev);
 547
 548         return ret;
 549 }
 550
 551 static struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr, bool c45)
 552 {
 553         struct phy_device *phydev = ERR_PTR(-ENODEV);
 554         int err;
 555
 556         phydev = get_phy_device(bus, addr, c45);
 557         if (IS_ERR(phydev))
 558                 return phydev;
 559
 560         /* For DT, see if the auto-probed phy has a corresponding child
 561          * in the bus node, and set the of_node pointer in this case.
 562          */
 563         of_mdiobus_link_mdiodev(bus, &phydev->mdio);
 564
 565         err = phy_device_register(phydev);
 566         if (err) {
 567                 phy_device_free(phydev);
 568                 return ERR_PTR(-ENODEV);
 569         }
 570
 571         return phydev;
 572 }
 573
 574 /**
 575  * mdiobus_scan_c22 - scan one address on a bus for C22 MDIO devices.
 576  * @bus: mii_bus to scan
 577  * @addr: address on bus to scan
 578  *
 579  * This function scans one address on the MDIO bus, looking for
 580  * devices which can be identified using a vendor/product ID in
 581  * registers 2 and 3. Not all MDIO devices have such registers, but
 582  * PHY devices typically do. Hence this function assumes anything
 583  * found is a PHY, or can be treated as a PHY. Other MDIO devices,
 584  * such as switches, will probably not be found during the scan.
 585  */
 586 struct phy_device *mdiobus_scan_c22(struct mii_bus *bus, int addr)
 587 {
 588         return mdiobus_scan(bus, addr, false);
 589 }
 590 EXPORT_SYMBOL(mdiobus_scan_c22);
 591
 592 /**
 593  * mdiobus_scan_c45 - scan one address on a bus for C45 MDIO devices.
 594  * @bus: mii_bus to scan
 595  * @addr: address on bus to scan
 596  *
 597  * This function scans one address on the MDIO bus, looking for
 598  * devices which can be identified using a vendor/product ID in
 599  * registers 2 and 3. Not all MDIO devices have such registers, but
 600  * PHY devices typically do. Hence this function assumes anything
 601  * found is a PHY, or can be treated as a PHY. Other MDIO devices,
 602  * such as switches, will probably not be found during the scan.
 603  */
 604 static struct phy_device *mdiobus_scan_c45(struct mii_bus *bus, int addr)
 605 {
 606         return mdiobus_scan(bus, addr, true);
 607 }
 608
 609 static int mdiobus_scan_bus_c22(struct mii_bus *bus)
 610 {
 611         int i;
 612
 613         for (i = 0; i < PHY_MAX_ADDR; i++) {
 614                 if ((bus->phy_mask & BIT(i)) == 0) {
 615                         struct phy_device *phydev;
 616
 617                         phydev = mdiobus_scan_c22(bus, i);
 618                         if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
 619                                 return PTR_ERR(phydev);
 620                 }
 621         }
 622         return 0;
 623 }
 624
 625 static int mdiobus_scan_bus_c45(struct mii_bus *bus)
 626 {
 627         int i;
 628
 629         for (i = 0; i < PHY_MAX_ADDR; i++) {
 630                 if ((bus->phy_mask & BIT(i)) == 0) {
 631                         struct phy_device *phydev;
 632
 633                         /* Don't scan C45 if we already have a C22 device */
 634                         if (bus->mdio_map[i])
 635                                 continue;
 636
 637                         phydev = mdiobus_scan_c45(bus, i);
 638                         if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
 639                                 return PTR_ERR(phydev);
 640                 }
 641         }
 642         return 0;
 643 }
 644
 645 /* There are some C22 PHYs which do bad things when where is a C45
 646  * transaction on the bus, like accepting a read themselves, and
 647  * stomping over the true devices reply, to performing a write to
 648  * themselves which was intended for another device. Now that C22
 649  * devices have been found, see if any of them are bad for C45, and if we
 650  * should skip the C45 scan.
 651  */
 652 static bool mdiobus_prevent_c45_scan(struct mii_bus *bus)
 653 {
 654         int i;
 655
 656         for (i = 0; i < PHY_MAX_ADDR; i++) {
 657                 struct phy_device *phydev;
 658                 u32 oui;
 659
 660                 phydev = mdiobus_get_phy(bus, i);
 661                 if (!phydev)
 662                         continue;
 663                 oui = phydev->phy_id >> 10;
 664
 665                 if (oui == MICREL_OUI)
 666                         return true;
 667         }
 668         return false;
 669 }
 670
 671 /**
 672  * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
 673  * @bus: target mii_bus
 674  * @owner: module containing bus accessor functions
 675  *
 676  * Description: Called by a bus driver to bring up all the PHYs
 677  *   on a given bus, and attach them to the bus. Drivers should use
 678  *   mdiobus_register() rather than __mdiobus_register() unless they
 679  *   need to pass a specific owner module. MDIO devices which are not
 680  *   PHYs will not be brought up by this function. They are expected
 681  *   to be explicitly listed in DT and instantiated by of_mdiobus_register().
 682  *
 683  * Returns 0 on success or < 0 on error.
 684  */
 685 int __mdiobus_register(struct mii_bus *bus, struct module *owner)
 686 {
 687         struct mdio_device *mdiodev;
 688         struct gpio_desc *gpiod;
 689         bool prevent_c45_scan;
 690         int i, err;
 691
 692         if (!bus || !bus->name)
 693                 return -EINVAL;
 694
 695         /* An access method always needs both read and write operations */
 696         if (!!bus->read != !!bus->write || !!bus->read_c45 != !!bus->write_c45)
 697                 return -EINVAL;
 698
 699         /* At least one method is mandatory */
 700         if (!bus->read && !bus->read_c45)
 701                 return -EINVAL;
 702
 703         if (bus->parent && bus->parent->of_node)
 704                 bus->parent->of_node->fwnode.flags |=
 705                                         FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD;
 706
 707         WARN(bus->state != MDIOBUS_ALLOCATED &&
 708              bus->state != MDIOBUS_UNREGISTERED,
 709              "%s: not in ALLOCATED or UNREGISTERED state\n", bus->id);
 710
 711         bus->owner = owner;
 712         bus->dev.parent = bus->parent;
 713         bus->dev.class = &mdio_bus_class;
 714         bus->dev.groups = NULL;
 715         dev_set_name(&bus->dev, "%s", bus->id);
 716
 717         /* If the bus state is allocated, we're registering a fresh bus
 718          * that may have a fwnode associated with it. Grab a reference
 719          * to the fwnode. This will be dropped when the bus is released.
 720          * If the bus was set to unregistered, it means that the bus was
 721          * previously registered, and we've already grabbed a reference.
 722          */
 723         if (bus->state == MDIOBUS_ALLOCATED)
 724                 fwnode_handle_get(dev_fwnode(&bus->dev));
 725
 726         /* We need to set state to MDIOBUS_UNREGISTERED to correctly release
 727          * the device in mdiobus_free()
 728          *
 729          * State will be updated later in this function in case of success
 730          */
 731         bus->state = MDIOBUS_UNREGISTERED;
 732
 733         err = device_register(&bus->dev);
 734         if (err) {
 735                 pr_err("mii_bus %s failed to register\n", bus->id);
 736                 return -EINVAL;
 737         }
 738
 739         mutex_init(&bus->mdio_lock);
 740         mutex_init(&bus->shared_lock);
 741
 742         /* assert bus level PHY GPIO reset */
 743         gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_HIGH);
 744         if (IS_ERR(gpiod)) {
 745                 err = dev_err_probe(&bus->dev, PTR_ERR(gpiod),
 746                                     "mii_bus %s couldn't get reset GPIO\n",
 747                                     bus->id);
 748                 device_del(&bus->dev);
 749                 return err;
 750         } else  if (gpiod) {
 751                 bus->reset_gpiod = gpiod;
 752                 fsleep(bus->reset_delay_us);
 753                 gpiod_set_value_cansleep(gpiod, 0);
 754                 if (bus->reset_post_delay_us > 0)
 755                         fsleep(bus->reset_post_delay_us);
 756         }
 757
 758         if (bus->reset) {
 759                 err = bus->reset(bus);
 760                 if (err)
 761                         goto error_reset_gpiod;
 762         }
 763
 764         if (bus->read) {
 765                 err = mdiobus_scan_bus_c22(bus);
 766                 if (err)
 767                         goto error;
 768         }
 769
 770         prevent_c45_scan = mdiobus_prevent_c45_scan(bus);
 771
 772         if (!prevent_c45_scan && bus->read_c45) {
 773                 err = mdiobus_scan_bus_c45(bus);
 774                 if (err)
 775                         goto error;
 776         }
 777
 778         mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
 779
 780         bus->state = MDIOBUS_REGISTERED;
 781         dev_dbg(&bus->dev, "probed\n");
 782         return 0;
 783
 784 error:
 785         for (i = 0; i < PHY_MAX_ADDR; i++) {
 786                 mdiodev = bus->mdio_map[i];
 787                 if (!mdiodev)
 788                         continue;
 789
 790                 mdiodev->device_remove(mdiodev);
 791                 mdiodev->device_free(mdiodev);
 792         }
 793 error_reset_gpiod:
 794         /* Put PHYs in RESET to save power */
 795         if (bus->reset_gpiod)
 796                 gpiod_set_value_cansleep(bus->reset_gpiod, 1);
 797
 798         device_del(&bus->dev);
 799         return err;
 800 }
 801 EXPORT_SYMBOL(__mdiobus_register);
 802
 803 void mdiobus_unregister(struct mii_bus *bus)
 804 {
 805         struct mdio_device *mdiodev;
 806         int i;
 807
 808         if (WARN_ON_ONCE(bus->state != MDIOBUS_REGISTERED))
 809                 return;
 810         bus->state = MDIOBUS_UNREGISTERED;
 811
 812         for (i = 0; i < PHY_MAX_ADDR; i++) {
 813                 mdiodev = bus->mdio_map[i];
 814                 if (!mdiodev)
 815                         continue;
 816
 817                 if (mdiodev->reset_gpio)
 818                         gpiod_put(mdiodev->reset_gpio);
 819
 820                 mdiodev->device_remove(mdiodev);
 821                 mdiodev->device_free(mdiodev);
 822         }
 823
 824         /* Put PHYs in RESET to save power */
 825         if (bus->reset_gpiod)
 826                 gpiod_set_value_cansleep(bus->reset_gpiod, 1);
 827
 828         device_del(&bus->dev);
 829 }
 830 EXPORT_SYMBOL(mdiobus_unregister);
 831
 832 /**
 833  * mdiobus_free - free a struct mii_bus
 834  * @bus: mii_bus to free
 835  *
 836  * This function releases the reference to the underlying device
 837  * object in the mii_bus.  If this is the last reference, the mii_bus
 838  * will be freed.
 839  */
 840 void mdiobus_free(struct mii_bus *bus)
 841 {
 842         /* For compatibility with error handling in drivers. */
 843         if (bus->state == MDIOBUS_ALLOCATED) {
 844                 kfree(bus);
 845                 return;
 846         }
 847
 848         WARN(bus->state != MDIOBUS_UNREGISTERED,
 849              "%s: not in UNREGISTERED state\n", bus->id);
 850         bus->state = MDIOBUS_RELEASED;
 851
 852         put_device(&bus->dev);
 853 }
 854 EXPORT_SYMBOL(mdiobus_free);
 855
 856 static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret)
 857 {
 858         preempt_disable();
 859         u64_stats_update_begin(&stats->syncp);
 860
 861         u64_stats_inc(&stats->transfers);
 862         if (ret < 0) {
 863                 u64_stats_inc(&stats->errors);
 864                 goto out;
 865         }
 866
 867         if (op)
 868                 u64_stats_inc(&stats->reads);
 869         else
 870                 u64_stats_inc(&stats->writes);
 871 out:
 872         u64_stats_update_end(&stats->syncp);
 873         preempt_enable();
 874 }
 875
 876 /**
 877  * __mdiobus_read - Unlocked version of the mdiobus_read function
 878  * @bus: the mii_bus struct
 879  * @addr: the phy address
 880  * @regnum: register number to read
 881  *
 882  * Read a MDIO bus register. Caller must hold the mdio bus lock.
 883  *
 884  * NOTE: MUST NOT be called from interrupt context.
 885  */
 886 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
 887 {
 888         int retval;
 889
 890         lockdep_assert_held_once(&bus->mdio_lock);
 891
 892         if (bus->read)
 893                 retval = bus->read(bus, addr, regnum);
 894         else
 895                 retval = -EOPNOTSUPP;
 896
 897         trace_mdio_access(bus, 1, addr, regnum, retval, retval);
 898         mdiobus_stats_acct(&bus->stats[addr], true, retval);
 899
 900         return retval;
 901 }
 902 EXPORT_SYMBOL(__mdiobus_read);
 903
 904 /**
 905  * __mdiobus_write - Unlocked version of the mdiobus_write function
 906  * @bus: the mii_bus struct
 907  * @addr: the phy address
 908  * @regnum: register number to write
 909  * @val: value to write to @regnum
 910  *
 911  * Write a MDIO bus register. Caller must hold the mdio bus lock.
 912  *
 913  * NOTE: MUST NOT be called from interrupt context.
 914  */
 915 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
 916 {
 917         int err;
 918
 919         lockdep_assert_held_once(&bus->mdio_lock);
 920
 921         if (bus->write)
 922                 err = bus->write(bus, addr, regnum, val);
 923         else
 924                 err = -EOPNOTSUPP;
 925
 926         trace_mdio_access(bus, 0, addr, regnum, val, err);
 927         mdiobus_stats_acct(&bus->stats[addr], false, err);
 928
 929         return err;
 930 }
 931 EXPORT_SYMBOL(__mdiobus_write);
 932
 933 /**
 934  * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function
 935  * @bus: the mii_bus struct
 936  * @addr: the phy address
 937  * @regnum: register number to modify
 938  * @mask: bit mask of bits to clear
 939  * @set: bit mask of bits to set
 940  *
 941  * Read, modify, and if any change, write the register value back to the
 942  * device. Any error returns a negative number.
 943  *
 944  * NOTE: MUST NOT be called from interrupt context.
 945  */
 946 int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
 947                              u16 mask, u16 set)
 948 {
 949         int new, ret;
 950
 951         ret = __mdiobus_read(bus, addr, regnum);
 952         if (ret < 0)
 953                 return ret;
 954
 955         new = (ret & ~mask) | set;
 956         if (new == ret)
 957                 return 0;
 958
 959         ret = __mdiobus_write(bus, addr, regnum, new);
 960
 961         return ret < 0 ? ret : 1;
 962 }
 963 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed);
 964
 965 /**
 966  * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function
 967  * @bus: the mii_bus struct
 968  * @addr: the phy address
 969  * @devad: device address to read
 970  * @regnum: register number to read
 971  *
 972  * Read a MDIO bus register. Caller must hold the mdio bus lock.
 973  *
 974  * NOTE: MUST NOT be called from interrupt context.
 975  */
 976 int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
 977 {
 978         int retval;
 979
 980         lockdep_assert_held_once(&bus->mdio_lock);
 981
 982         if (bus->read_c45)
 983                 retval = bus->read_c45(bus, addr, devad, regnum);
 984         else
 985                 retval = -EOPNOTSUPP;
 986
 987         trace_mdio_access(bus, 1, addr, regnum, retval, retval);
 988         mdiobus_stats_acct(&bus->stats[addr], true, retval);
 989
 990         return retval;
 991 }
 992 EXPORT_SYMBOL(__mdiobus_c45_read);
 993
 994 /**
 995  * __mdiobus_c45_write - Unlocked version of the mdiobus_write function
 996  * @bus: the mii_bus struct
 997  * @addr: the phy address
 998  * @devad: device address to read
 999  * @regnum: register number to write
1000  * @val: value to write to @regnum
1001  *
1002  * Write a MDIO bus register. Caller must hold the mdio bus lock.
1003  *
1004  * NOTE: MUST NOT be called from interrupt context.
1005  */
1006 int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1007                         u16 val)
1008 {
1009         int err;
1010
1011         lockdep_assert_held_once(&bus->mdio_lock);
1012
1013         if (bus->write_c45)
1014                 err = bus->write_c45(bus, addr, devad, regnum, val);
1015         else
1016                 err = -EOPNOTSUPP;
1017
1018         trace_mdio_access(bus, 0, addr, regnum, val, err);
1019         mdiobus_stats_acct(&bus->stats[addr], false, err);
1020
1021         return err;
1022 }
1023 EXPORT_SYMBOL(__mdiobus_c45_write);
1024
1025 /**
1026  * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function
1027  * @bus: the mii_bus struct
1028  * @addr: the phy address
1029  * @devad: device address to read
1030  * @regnum: register number to modify
1031  * @mask: bit mask of bits to clear
1032  * @set: bit mask of bits to set
1033  *
1034  * Read, modify, and if any change, write the register value back to the
1035  * device. Any error returns a negative number.
1036  *
1037  * NOTE: MUST NOT be called from interrupt context.
1038  */
1039 static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr,
1040                                         int devad, u32 regnum, u16 mask,
1041                                         u16 set)
1042 {
1043         int new, ret;
1044
1045         ret = __mdiobus_c45_read(bus, addr, devad, regnum);
1046         if (ret < 0)
1047                 return ret;
1048
1049         new = (ret & ~mask) | set;
1050         if (new == ret)
1051                 return 0;
1052
1053         ret = __mdiobus_c45_write(bus, addr, devad, regnum, new);
1054
1055         return ret < 0 ? ret : 1;
1056 }
1057
1058 /**
1059  * mdiobus_read_nested - Nested version of the mdiobus_read function
1060  * @bus: the mii_bus struct
1061  * @addr: the phy address
1062  * @regnum: register number to read
1063  *
1064  * In case of nested MDIO bus access avoid lockdep false positives by
1065  * using mutex_lock_nested().
1066  *
1067  * NOTE: MUST NOT be called from interrupt context,
1068  * because the bus read/write functions may wait for an interrupt
1069  * to conclude the operation.
1070  */
1071 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
1072 {
1073         int retval;
1074
1075         mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1076         retval = __mdiobus_read(bus, addr, regnum);
1077         mutex_unlock(&bus->mdio_lock);
1078
1079         return retval;
1080 }
1081 EXPORT_SYMBOL(mdiobus_read_nested);
1082
1083 /**
1084  * mdiobus_read - Convenience function for reading a given MII mgmt register
1085  * @bus: the mii_bus struct
1086  * @addr: the phy address
1087  * @regnum: register number to read
1088  *
1089  * NOTE: MUST NOT be called from interrupt context,
1090  * because the bus read/write functions may wait for an interrupt
1091  * to conclude the operation.
1092  */
1093 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
1094 {
1095         int retval;
1096
1097         mutex_lock(&bus->mdio_lock);
1098         retval = __mdiobus_read(bus, addr, regnum);
1099         mutex_unlock(&bus->mdio_lock);
1100
1101         return retval;
1102 }
1103 EXPORT_SYMBOL(mdiobus_read);
1104
1105 /**
1106  * mdiobus_c45_read - Convenience function for reading a given MII mgmt register
1107  * @bus: the mii_bus struct
1108  * @addr: the phy address
1109  * @devad: device address to read
1110  * @regnum: register number to read
1111  *
1112  * NOTE: MUST NOT be called from interrupt context,
1113  * because the bus read/write functions may wait for an interrupt
1114  * to conclude the operation.
1115  */
1116 int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
1117 {
1118         int retval;
1119
1120         mutex_lock(&bus->mdio_lock);
1121         retval = __mdiobus_c45_read(bus, addr, devad, regnum);
1122         mutex_unlock(&bus->mdio_lock);
1123
1124         return retval;
1125 }
1126 EXPORT_SYMBOL(mdiobus_c45_read);
1127
1128 /**
1129  * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function
1130  * @bus: the mii_bus struct
1131  * @addr: the phy address
1132  * @devad: device address to read
1133  * @regnum: register number to read
1134  *
1135  * In case of nested MDIO bus access avoid lockdep false positives by
1136  * using mutex_lock_nested().
1137  *
1138  * NOTE: MUST NOT be called from interrupt context,
1139  * because the bus read/write functions may wait for an interrupt
1140  * to conclude the operation.
1141  */
1142 int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad,
1143                             u32 regnum)
1144 {
1145         int retval;
1146
1147         mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1148         retval = __mdiobus_c45_read(bus, addr, devad, regnum);
1149         mutex_unlock(&bus->mdio_lock);
1150
1151         return retval;
1152 }
1153 EXPORT_SYMBOL(mdiobus_c45_read_nested);
1154
1155 /**
1156  * mdiobus_write_nested - Nested version of the mdiobus_write function
1157  * @bus: the mii_bus struct
1158  * @addr: the phy address
1159  * @regnum: register number to write
1160  * @val: value to write to @regnum
1161  *
1162  * In case of nested MDIO bus access avoid lockdep false positives by
1163  * using mutex_lock_nested().
1164  *
1165  * NOTE: MUST NOT be called from interrupt context,
1166  * because the bus read/write functions may wait for an interrupt
1167  * to conclude the operation.
1168  */
1169 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1170 {
1171         int err;
1172
1173         mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1174         err = __mdiobus_write(bus, addr, regnum, val);
1175         mutex_unlock(&bus->mdio_lock);
1176
1177         return err;
1178 }
1179 EXPORT_SYMBOL(mdiobus_write_nested);
1180
1181 /**
1182  * mdiobus_write - Convenience function for writing a given MII mgmt register
1183  * @bus: the mii_bus struct
1184  * @addr: the phy address
1185  * @regnum: register number to write
1186  * @val: value to write to @regnum
1187  *
1188  * NOTE: MUST NOT be called from interrupt context,
1189  * because the bus read/write functions may wait for an interrupt
1190  * to conclude the operation.
1191  */
1192 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1193 {
1194         int err;
1195
1196         mutex_lock(&bus->mdio_lock);
1197         err = __mdiobus_write(bus, addr, regnum, val);
1198         mutex_unlock(&bus->mdio_lock);
1199
1200         return err;
1201 }
1202 EXPORT_SYMBOL(mdiobus_write);
1203
1204 /**
1205  * mdiobus_c45_write - Convenience function for writing a given MII mgmt register
1206  * @bus: the mii_bus struct
1207  * @addr: the phy address
1208  * @devad: device address to read
1209  * @regnum: register number to write
1210  * @val: value to write to @regnum
1211  *
1212  * NOTE: MUST NOT be called from interrupt context,
1213  * because the bus read/write functions may wait for an interrupt
1214  * to conclude the operation.
1215  */
1216 int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1217                       u16 val)
1218 {
1219         int err;
1220
1221         mutex_lock(&bus->mdio_lock);
1222         err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
1223         mutex_unlock(&bus->mdio_lock);
1224
1225         return err;
1226 }
1227 EXPORT_SYMBOL(mdiobus_c45_write);
1228
1229 /**
1230  * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function
1231  * @bus: the mii_bus struct
1232  * @addr: the phy address
1233  * @devad: device address to read
1234  * @regnum: register number to write
1235  * @val: value to write to @regnum
1236  *
1237  * In case of nested MDIO bus access avoid lockdep false positives by
1238  * using mutex_lock_nested().
1239  *
1240  * NOTE: MUST NOT be called from interrupt context,
1241  * because the bus read/write functions may wait for an interrupt
1242  * to conclude the operation.
1243  */
1244 int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad,
1245                              u32 regnum, u16 val)
1246 {
1247         int err;
1248
1249         mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1250         err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
1251         mutex_unlock(&bus->mdio_lock);
1252
1253         return err;
1254 }
1255 EXPORT_SYMBOL(mdiobus_c45_write_nested);
1256
1257 /*
1258  * __mdiobus_modify - Convenience function for modifying a given mdio device
1259  *      register
1260  * @bus: the mii_bus struct
1261  * @addr: the phy address
1262  * @regnum: register number to write
1263  * @mask: bit mask of bits to clear
1264  * @set: bit mask of bits to set
1265  */
1266 int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
1267                      u16 set)
1268 {
1269         int err;
1270
1271         err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1272
1273         return err < 0 ? err : 0;
1274 }
1275 EXPORT_SYMBOL_GPL(__mdiobus_modify);
1276
1277 /**
1278  * mdiobus_modify - Convenience function for modifying a given mdio device
1279  *      register
1280  * @bus: the mii_bus struct
1281  * @addr: the phy address
1282  * @regnum: register number to write
1283  * @mask: bit mask of bits to clear
1284  * @set: bit mask of bits to set
1285  */
1286 int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)
1287 {
1288         int err;
1289
1290         mutex_lock(&bus->mdio_lock);
1291         err = __mdiobus_modify(bus, addr, regnum, mask, set);
1292         mutex_unlock(&bus->mdio_lock);
1293
1294         return err;
1295 }
1296 EXPORT_SYMBOL_GPL(mdiobus_modify);
1297
1298 /**
1299  * mdiobus_c45_modify - Convenience function for modifying a given mdio device
1300  *      register
1301  * @bus: the mii_bus struct
1302  * @addr: the phy address
1303  * @devad: device address to read
1304  * @regnum: register number to write
1305  * @mask: bit mask of bits to clear
1306  * @set: bit mask of bits to set
1307  */
1308 int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum,
1309                        u16 mask, u16 set)
1310 {
1311         int err;
1312
1313         mutex_lock(&bus->mdio_lock);
1314         err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum,
1315                                            mask, set);
1316         mutex_unlock(&bus->mdio_lock);
1317
1318         return err < 0 ? err : 0;
1319 }
1320 EXPORT_SYMBOL_GPL(mdiobus_c45_modify);
1321
1322 /**
1323  * mdiobus_modify_changed - Convenience function for modifying a given mdio
1324  *      device register and returning if it changed
1325  * @bus: the mii_bus struct
1326  * @addr: the phy address
1327  * @regnum: register number to write
1328  * @mask: bit mask of bits to clear
1329  * @set: bit mask of bits to set
1330  */
1331 int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
1332                            u16 mask, u16 set)
1333 {
1334         int err;
1335
1336         mutex_lock(&bus->mdio_lock);
1337         err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1338         mutex_unlock(&bus->mdio_lock);
1339
1340         return err;
1341 }
1342 EXPORT_SYMBOL_GPL(mdiobus_modify_changed);
1343
1344 /**
1345  * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio
1346  *      device register and returning if it changed
1347  * @bus: the mii_bus struct
1348  * @addr: the phy address
1349  * @devad: device address to read
1350  * @regnum: register number to write
1351  * @mask: bit mask of bits to clear
1352  * @set: bit mask of bits to set
1353  */
1354 int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad,
1355                                u32 regnum, u16 mask, u16 set)
1356 {
1357         int err;
1358
1359         mutex_lock(&bus->mdio_lock);
1360         err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set);
1361         mutex_unlock(&bus->mdio_lock);
1362
1363         return err;
1364 }
1365 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
1366
1367 /**
1368  * mdio_bus_match - determine if given MDIO driver supports the given
1369  *                  MDIO device
1370  * @dev: target MDIO device
1371  * @drv: given MDIO driver
1372  *
1373  * Description: Given a MDIO device, and a MDIO driver, return 1 if
1374  *   the driver supports the device.  Otherwise, return 0. This may
1375  *   require calling the devices own match function, since different classes
1376  *   of MDIO devices have different match criteria.
1377  */
1378 static int mdio_bus_match(struct device *dev, const struct device_driver *drv)
1379 {
1380         const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
1381         struct mdio_device *mdio = to_mdio_device(dev);
1382
1383         /* Both the driver and device must type-match */
1384         if (!(mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) !=
1385             !(mdio->flags & MDIO_DEVICE_FLAG_PHY))
1386                 return 0;
1387
1388         if (of_driver_match_device(dev, drv))
1389                 return 1;
1390
1391         if (mdio->bus_match)
1392                 return mdio->bus_match(dev, drv);
1393
1394         return 0;
1395 }
1396
1397 static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env)
1398 {
1399         int rc;
1400
1401         /* Some devices have extra OF data and an OF-style MODALIAS */
1402         rc = of_device_uevent_modalias(dev, env);
1403         if (rc != -ENODEV)
1404                 return rc;
1405
1406         return 0;
1407 }
1408
1409 static struct attribute *mdio_bus_device_statistics_attrs[] = {
1410         &dev_attr_mdio_bus_device_transfers.attr.attr,
1411         &dev_attr_mdio_bus_device_errors.attr.attr,
1412         &dev_attr_mdio_bus_device_writes.attr.attr,
1413         &dev_attr_mdio_bus_device_reads.attr.attr,
1414         NULL,
1415 };
1416
1417 static const struct attribute_group mdio_bus_device_statistics_group = {
1418         .name   = "statistics",
1419         .attrs  = mdio_bus_device_statistics_attrs,
1420 };
1421
1422 static const struct attribute_group *mdio_bus_dev_groups[] = {
1423         &mdio_bus_device_statistics_group,
1424         NULL,
1425 };
1426
1427 const struct bus_type mdio_bus_type = {
1428         .name           = "mdio_bus",
1429         .dev_groups     = mdio_bus_dev_groups,
1430         .match          = mdio_bus_match,
1431         .uevent         = mdio_uevent,
1432 };
1433 EXPORT_SYMBOL(mdio_bus_type);
1434
1435 int __init mdio_bus_init(void)
1436 {
1437         int ret;
1438
1439         ret = class_register(&mdio_bus_class);
1440         if (!ret) {
1441                 ret = bus_register(&mdio_bus_type);
1442                 if (ret)
1443                         class_unregister(&mdio_bus_class);
1444         }
1445
1446         return ret;
1447 }
1448
1449 #if IS_ENABLED(CONFIG_PHYLIB)
1450 void mdio_bus_exit(void)
1451 {
1452         class_unregister(&mdio_bus_class);
1453         bus_unregister(&mdio_bus_type);
1454 }
1455 EXPORT_SYMBOL_GPL(mdio_bus_exit);
1456 #else
1457 module_init(mdio_bus_init);
1458 /* no module_exit, intentional */
1459 MODULE_LICENSE("GPL");
1460 MODULE_DESCRIPTION("MDIO bus/device layer");
1461 #endif