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 1436