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