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/device.h> 12 #include <linux/errno.h> 13 #include <linux/etherdevice.h> 14 #include <linux/ethtool.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/init.h> 17 #include <linux/io.h> 18 #include <linux/kernel.h> 19 #include <linux/mii.h> 20 #include <linux/mm.h> 21 #include <linux/module.h> 22 #include <linux/netdevice.h> 23 #include <linux/of_device.h> 24 #include <linux/of_mdio.h> 25 #include <linux/phy.h> 26 #include <linux/reset.h> 27 #include <linux/slab.h> 28 #include <linux/spinlock.h> 29 #include <linux/string.h> 30 #include <linux/uaccess.h> 31 #include <linux/unistd.h> 32 #include "mdio-private.h" 33 34 #define CREATE_TRACE_POINTS 35 #include <trace/events/mdio.h> 36 37 int mdiobus_register_device(struct mdio_device *mdiodev) 38 { 39 int err; 40 41 if (mdiodev->bus->mdio_map[mdiodev->addr]) 42 return -EBUSY; 43 44 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) { 45 err = mdio_device_register_reset(mdiodev); 46 if (err) 47 return err; 48 49 /* Assert the reset signal */ 50 mdio_device_reset(mdiodev, 1); 51 } 52 53 mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev; 54 55 return 0; 56 } 57 EXPORT_SYMBOL(mdiobus_register_device); 58 59 int mdiobus_unregister_device(struct mdio_device *mdiodev) 60 { 61 if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev) 62 return -EINVAL; 63 64 mdio_device_unregister_reset(mdiodev); 65 66 mdiodev->bus->mdio_map[mdiodev->addr] = NULL; 67 68 return 0; 69 } 70 EXPORT_SYMBOL(mdiobus_unregister_device); 71 72 static struct mdio_device *mdiobus_find_device(struct mii_bus *bus, int addr) 73 { 74 bool addr_valid = addr >= 0 && addr < ARRAY_SIZE(bus->mdio_map); 75 76 if (WARN_ONCE(!addr_valid, "addr %d out of range\n", addr)) 77 return NULL; 78 79 return bus->mdio_map[addr]; 80 } 81 82 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr) 83 { 84 struct mdio_device *mdiodev; 85 86 mdiodev = mdiobus_find_device(bus, addr); 87 if (!mdiodev) 88 return NULL; 89 90 if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY)) 91 return NULL; 92 93 return container_of(mdiodev, struct phy_device, mdio); 94 } 95 EXPORT_SYMBOL(mdiobus_get_phy); 96 97 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr) 98 { 99 return mdiobus_find_device(bus, addr) != NULL; 100 } 101 EXPORT_SYMBOL(mdiobus_is_registered_device); 102 103 /** 104 * mdiobus_release - mii_bus device release callback 105 * @d: the target struct device that contains the mii_bus 106 * 107 * Description: called when the last reference to an mii_bus is 108 * dropped, to free the underlying memory. 109 */ 110 static void mdiobus_release(struct device *d) 111 { 112 struct mii_bus *bus = to_mii_bus(d); 113 114 WARN(bus->state != MDIOBUS_RELEASED && 115 /* for compatibility with error handling in drivers */ 116 bus->state != MDIOBUS_ALLOCATED, 117 "%s: not in RELEASED or ALLOCATED state\n", 118 bus->id); 119 120 if (bus->state == MDIOBUS_RELEASED) 121 fwnode_handle_put(dev_fwnode(d)); 122 123 kfree(bus); 124 } 125 126 struct mdio_bus_stat_attr { 127 struct device_attribute attr; 128 int address; 129 unsigned int field_offset; 130 }; 131 132 static struct mdio_bus_stat_attr *to_sattr(struct device_attribute *attr) 133 { 134 return container_of(attr, struct mdio_bus_stat_attr, attr); 135 } 136 137 static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset) 138 { 139 const u64_stats_t *stats = (const void *)s + offset; 140 unsigned int start; 141 u64 val = 0; 142 143 do { 144 start = u64_stats_fetch_begin(&s->syncp); 145 val = u64_stats_read(stats); 146 } while (u64_stats_fetch_retry(&s->syncp, start)); 147 148 return val; 149 } 150 151 static ssize_t mdio_bus_stat_field_show(struct device *dev, 152 struct device_attribute *attr, 153 char *buf) 154 { 155 struct mdio_bus_stat_attr *sattr = to_sattr(attr); 156 struct mii_bus *bus = to_mii_bus(dev); 157 u64 val = 0; 158 159 if (sattr->address < 0) { 160 /* get global stats */ 161 for (int i = 0; i < PHY_MAX_ADDR; i++) 162 val += mdio_bus_get_stat(&bus->stats[i], 163 sattr->field_offset); 164 } else { 165 val = mdio_bus_get_stat(&bus->stats[sattr->address], 166 sattr->field_offset); 167 } 168 169 return sysfs_emit(buf, "%llu\n", val); 170 } 171 172 static ssize_t mdio_bus_device_stat_field_show(struct device *dev, 173 struct device_attribute *attr, 174 char *buf) 175 { 176 struct mdio_bus_stat_attr *sattr = to_sattr(attr); 177 struct mdio_device *mdiodev = to_mdio_device(dev); 178 struct mii_bus *bus = mdiodev->bus; 179 int addr = mdiodev->addr; 180 u64 val; 181 182 val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset); 183 184 return sysfs_emit(buf, "%llu\n", val); 185 } 186 187 #define MDIO_BUS_STATS_ATTR(field) \ 188 static const struct mdio_bus_stat_attr dev_attr_mdio_bus_##field = { \ 189 .attr = __ATTR(field, 0444, mdio_bus_stat_field_show, NULL), \ 190 .address = -1, \ 191 .field_offset = offsetof(struct mdio_bus_stats, field), \ 192 }; \ 193 static const struct mdio_bus_stat_attr dev_attr_mdio_bus_device_##field = { \ 194 .attr = __ATTR(field, 0444, mdio_bus_device_stat_field_show, NULL), \ 195 .field_offset = offsetof(struct mdio_bus_stats, field), \ 196 } 197 198 MDIO_BUS_STATS_ATTR(transfers); 199 MDIO_BUS_STATS_ATTR(errors); 200 MDIO_BUS_STATS_ATTR(writes); 201 MDIO_BUS_STATS_ATTR(reads); 202 203 #define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file) \ 204 static const struct mdio_bus_stat_attr \ 205 dev_attr_mdio_bus_addr_##field##_##addr = { \ 206 .attr = { .attr = { .name = file, .mode = 0444 }, \ 207 .show = mdio_bus_stat_field_show, \ 208 }, \ 209 .address = addr, \ 210 .field_offset = offsetof(struct mdio_bus_stats, field), \ 211 } 212 213 #define MDIO_BUS_STATS_ADDR_ATTR(field, addr) \ 214 MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, \ 215 __stringify(field) "_" __stringify(addr)) 216 217 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr) \ 218 MDIO_BUS_STATS_ADDR_ATTR(transfers, addr); \ 219 MDIO_BUS_STATS_ADDR_ATTR(errors, addr); \ 220 MDIO_BUS_STATS_ADDR_ATTR(writes, addr); \ 221 MDIO_BUS_STATS_ADDR_ATTR(reads, addr) \ 222 223 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0); 224 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1); 225 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2); 226 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3); 227 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4); 228 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5); 229 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6); 230 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7); 231 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8); 232 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9); 233 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10); 234 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11); 235 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12); 236 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13); 237 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14); 238 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15); 239 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16); 240 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17); 241 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18); 242 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19); 243 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20); 244 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21); 245 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22); 246 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23); 247 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24); 248 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25); 249 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26); 250 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27); 251 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28); 252 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29); 253 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30); 254 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31); 255 256 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr) \ 257 &dev_attr_mdio_bus_addr_transfers_##addr.attr.attr, \ 258 &dev_attr_mdio_bus_addr_errors_##addr.attr.attr, \ 259 &dev_attr_mdio_bus_addr_writes_##addr.attr.attr, \ 260 &dev_attr_mdio_bus_addr_reads_##addr.attr.attr \ 261 262 static const struct attribute *const mdio_bus_statistics_attrs[] = { 263 &dev_attr_mdio_bus_transfers.attr.attr, 264 &dev_attr_mdio_bus_errors.attr.attr, 265 &dev_attr_mdio_bus_writes.attr.attr, 266 &dev_attr_mdio_bus_reads.attr.attr, 267 MDIO_BUS_STATS_ADDR_ATTR_GROUP(0), 268 MDIO_BUS_STATS_ADDR_ATTR_GROUP(1), 269 MDIO_BUS_STATS_ADDR_ATTR_GROUP(2), 270 MDIO_BUS_STATS_ADDR_ATTR_GROUP(3), 271 MDIO_BUS_STATS_ADDR_ATTR_GROUP(4), 272 MDIO_BUS_STATS_ADDR_ATTR_GROUP(5), 273 MDIO_BUS_STATS_ADDR_ATTR_GROUP(6), 274 MDIO_BUS_STATS_ADDR_ATTR_GROUP(7), 275 MDIO_BUS_STATS_ADDR_ATTR_GROUP(8), 276 MDIO_BUS_STATS_ADDR_ATTR_GROUP(9), 277 MDIO_BUS_STATS_ADDR_ATTR_GROUP(10), 278 MDIO_BUS_STATS_ADDR_ATTR_GROUP(11), 279 MDIO_BUS_STATS_ADDR_ATTR_GROUP(12), 280 MDIO_BUS_STATS_ADDR_ATTR_GROUP(13), 281 MDIO_BUS_STATS_ADDR_ATTR_GROUP(14), 282 MDIO_BUS_STATS_ADDR_ATTR_GROUP(15), 283 MDIO_BUS_STATS_ADDR_ATTR_GROUP(16), 284 MDIO_BUS_STATS_ADDR_ATTR_GROUP(17), 285 MDIO_BUS_STATS_ADDR_ATTR_GROUP(18), 286 MDIO_BUS_STATS_ADDR_ATTR_GROUP(19), 287 MDIO_BUS_STATS_ADDR_ATTR_GROUP(20), 288 MDIO_BUS_STATS_ADDR_ATTR_GROUP(21), 289 MDIO_BUS_STATS_ADDR_ATTR_GROUP(22), 290 MDIO_BUS_STATS_ADDR_ATTR_GROUP(23), 291 MDIO_BUS_STATS_ADDR_ATTR_GROUP(24), 292 MDIO_BUS_STATS_ADDR_ATTR_GROUP(25), 293 MDIO_BUS_STATS_ADDR_ATTR_GROUP(26), 294 MDIO_BUS_STATS_ADDR_ATTR_GROUP(27), 295 MDIO_BUS_STATS_ADDR_ATTR_GROUP(28), 296 MDIO_BUS_STATS_ADDR_ATTR_GROUP(29), 297 MDIO_BUS_STATS_ADDR_ATTR_GROUP(30), 298 MDIO_BUS_STATS_ADDR_ATTR_GROUP(31), 299 NULL, 300 }; 301 302 static const struct attribute_group mdio_bus_statistics_group = { 303 .name = "statistics", 304 .attrs_const = mdio_bus_statistics_attrs, 305 }; 306 __ATTRIBUTE_GROUPS(mdio_bus_statistics); 307 308 const struct class mdio_bus_class = { 309 .name = "mdio_bus", 310 .dev_release = mdiobus_release, 311 .dev_groups = mdio_bus_statistics_groups, 312 }; 313 EXPORT_SYMBOL_GPL(mdio_bus_class); 314 315 /** 316 * mdio_find_bus - Given the name of a mdiobus, find the mii_bus. 317 * @mdio_name: The name of a mdiobus. 318 * 319 * Return: a reference to the mii_bus, or NULL if none found. The 320 * embedded struct device will have its reference count incremented, 321 * and this must be put_deviced'ed once the bus is finished with. 322 */ 323 struct mii_bus *mdio_find_bus(const char *mdio_name) 324 { 325 struct device *d; 326 327 d = class_find_device_by_name(&mdio_bus_class, mdio_name); 328 return d ? to_mii_bus(d) : NULL; 329 } 330 EXPORT_SYMBOL(mdio_find_bus); 331 332 #if IS_ENABLED(CONFIG_OF_MDIO) 333 /** 334 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus. 335 * @mdio_bus_np: Pointer to the mii_bus. 336 * 337 * Return: a reference to the mii_bus, or NULL if none found. The 338 * embedded struct device will have its reference count incremented, 339 * and this must be put once the bus is finished with. 340 * 341 * Because the association of a device_node and mii_bus is made via 342 * of_mdiobus_register(), the mii_bus cannot be found before it is 343 * registered with of_mdiobus_register(). 344 * 345 */ 346 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np) 347 { 348 struct device *d; 349 350 if (!mdio_bus_np) 351 return NULL; 352 353 d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np); 354 return d ? to_mii_bus(d) : NULL; 355 } 356 EXPORT_SYMBOL(of_mdio_find_bus); 357 #endif 358 359 static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret) 360 { 361 preempt_disable(); 362 u64_stats_update_begin(&stats->syncp); 363 364 u64_stats_inc(&stats->transfers); 365 if (ret < 0) { 366 u64_stats_inc(&stats->errors); 367 goto out; 368 } 369 370 if (op) 371 u64_stats_inc(&stats->reads); 372 else 373 u64_stats_inc(&stats->writes); 374 out: 375 u64_stats_update_end(&stats->syncp); 376 preempt_enable(); 377 } 378 379 /** 380 * __mdiobus_read - Unlocked version of the mdiobus_read function 381 * @bus: the mii_bus struct 382 * @addr: the phy address 383 * @regnum: register number to read 384 * 385 * Return: The register value if successful, negative error code on failure 386 * 387 * Read a MDIO bus register. Caller must hold the mdio bus lock. 388 * 389 * NOTE: MUST NOT be called from interrupt context. 390 */ 391 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 392 { 393 int retval; 394 395 lockdep_assert_held_once(&bus->mdio_lock); 396 397 if (addr >= PHY_MAX_ADDR) 398 return -ENXIO; 399 400 if (bus->read) 401 retval = bus->read(bus, addr, regnum); 402 else 403 retval = -EOPNOTSUPP; 404 405 trace_mdio_access(bus, 1, addr, regnum, retval, retval); 406 mdiobus_stats_acct(&bus->stats[addr], true, retval); 407 408 return retval; 409 } 410 EXPORT_SYMBOL(__mdiobus_read); 411 412 /** 413 * __mdiobus_write - Unlocked version of the mdiobus_write function 414 * @bus: the mii_bus struct 415 * @addr: the phy address 416 * @regnum: register number to write 417 * @val: value to write to @regnum 418 * 419 * Return: Zero if successful, negative error code on failure 420 * 421 * Write a MDIO bus register. Caller must hold the mdio bus lock. 422 * 423 * NOTE: MUST NOT be called from interrupt context. 424 */ 425 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 426 { 427 int err; 428 429 lockdep_assert_held_once(&bus->mdio_lock); 430 431 if (addr >= PHY_MAX_ADDR) 432 return -ENXIO; 433 434 if (bus->write) 435 err = bus->write(bus, addr, regnum, val); 436 else 437 err = -EOPNOTSUPP; 438 439 trace_mdio_access(bus, 0, addr, regnum, val, err); 440 mdiobus_stats_acct(&bus->stats[addr], false, err); 441 442 return err; 443 } 444 EXPORT_SYMBOL(__mdiobus_write); 445 446 /** 447 * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function 448 * @bus: the mii_bus struct 449 * @addr: the phy address 450 * @regnum: register number to modify 451 * @mask: bit mask of bits to clear 452 * @set: bit mask of bits to set 453 * 454 * Return: 1 if the register was modified, 0 if no change was needed, 455 * negative on any error condition 456 * 457 * Read, modify, and if any change, write the register value back to the 458 * device. 459 * 460 * NOTE: MUST NOT be called from interrupt context. 461 */ 462 int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, 463 u16 mask, u16 set) 464 { 465 int new, ret; 466 467 ret = __mdiobus_read(bus, addr, regnum); 468 if (ret < 0) 469 return ret; 470 471 new = (ret & ~mask) | set; 472 if (new == ret) 473 return 0; 474 475 ret = __mdiobus_write(bus, addr, regnum, new); 476 477 return ret < 0 ? ret : 1; 478 } 479 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed); 480 481 /** 482 * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function 483 * @bus: the mii_bus struct 484 * @addr: the phy address 485 * @devad: device address to read 486 * @regnum: register number to read 487 * 488 * Return: The register value if successful, negative error code on failure 489 * 490 * Read a MDIO bus register. Caller must hold the mdio bus lock. 491 * 492 * NOTE: MUST NOT be called from interrupt context. 493 */ 494 int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum) 495 { 496 int retval; 497 498 lockdep_assert_held_once(&bus->mdio_lock); 499 500 if (addr >= PHY_MAX_ADDR) 501 return -ENXIO; 502 503 if (bus->read_c45) 504 retval = bus->read_c45(bus, addr, devad, regnum); 505 else 506 retval = -EOPNOTSUPP; 507 508 trace_mdio_access(bus, 1, addr, regnum, retval, retval); 509 mdiobus_stats_acct(&bus->stats[addr], true, retval); 510 511 return retval; 512 } 513 EXPORT_SYMBOL(__mdiobus_c45_read); 514 515 /** 516 * __mdiobus_c45_write - Unlocked version of the mdiobus_write function 517 * @bus: the mii_bus struct 518 * @addr: the phy address 519 * @devad: device address to read 520 * @regnum: register number to write 521 * @val: value to write to @regnum 522 * 523 * Return: Zero if successful, negative error code on failure 524 * 525 * Write a MDIO bus register. Caller must hold the mdio bus lock. 526 * 527 * NOTE: MUST NOT be called from interrupt context. 528 */ 529 int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, 530 u16 val) 531 { 532 int err; 533 534 lockdep_assert_held_once(&bus->mdio_lock); 535 536 if (addr >= PHY_MAX_ADDR) 537 return -ENXIO; 538 539 if (bus->write_c45) 540 err = bus->write_c45(bus, addr, devad, regnum, val); 541 else 542 err = -EOPNOTSUPP; 543 544 trace_mdio_access(bus, 0, addr, regnum, val, err); 545 mdiobus_stats_acct(&bus->stats[addr], false, err); 546 547 return err; 548 } 549 EXPORT_SYMBOL(__mdiobus_c45_write); 550 551 /** 552 * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function 553 * @bus: the mii_bus struct 554 * @addr: the phy address 555 * @devad: device address to read 556 * @regnum: register number to modify 557 * @mask: bit mask of bits to clear 558 * @set: bit mask of bits to set 559 * 560 * Return: 1 if the register was modified, 0 if no change was needed, 561 * negative on any error condition 562 * 563 * Read, modify, and if any change, write the register value back to the 564 * device. Any error returns a negative number. 565 * 566 * NOTE: MUST NOT be called from interrupt context. 567 */ 568 static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, 569 int devad, u32 regnum, u16 mask, 570 u16 set) 571 { 572 int new, ret; 573 574 ret = __mdiobus_c45_read(bus, addr, devad, regnum); 575 if (ret < 0) 576 return ret; 577 578 new = (ret & ~mask) | set; 579 if (new == ret) 580 return 0; 581 582 ret = __mdiobus_c45_write(bus, addr, devad, regnum, new); 583 584 return ret < 0 ? ret : 1; 585 } 586 587 /** 588 * mdiobus_read_nested - Nested version of the mdiobus_read function 589 * @bus: the mii_bus struct 590 * @addr: the phy address 591 * @regnum: register number to read 592 * 593 * Return: The register value if successful, negative error code on failure 594 * 595 * In case of nested MDIO bus access avoid lockdep false positives by 596 * using mutex_lock_nested(). 597 * 598 * NOTE: MUST NOT be called from interrupt context, 599 * because the bus read/write functions may wait for an interrupt 600 * to conclude the operation. 601 */ 602 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum) 603 { 604 int retval; 605 606 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 607 retval = __mdiobus_read(bus, addr, regnum); 608 mutex_unlock(&bus->mdio_lock); 609 610 return retval; 611 } 612 EXPORT_SYMBOL(mdiobus_read_nested); 613 614 /** 615 * mdiobus_read - Convenience function for reading a given MII mgmt register 616 * @bus: the mii_bus struct 617 * @addr: the phy address 618 * @regnum: register number to read 619 * 620 * Return: The register value if successful, negative error code on failure 621 * 622 * NOTE: MUST NOT be called from interrupt context, 623 * because the bus read/write functions may wait for an interrupt 624 * to conclude the operation. 625 */ 626 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 627 { 628 int retval; 629 630 mutex_lock(&bus->mdio_lock); 631 retval = __mdiobus_read(bus, addr, regnum); 632 mutex_unlock(&bus->mdio_lock); 633 634 return retval; 635 } 636 EXPORT_SYMBOL(mdiobus_read); 637 638 /** 639 * mdiobus_c45_read - Convenience function for reading a given MII mgmt register 640 * @bus: the mii_bus struct 641 * @addr: the phy address 642 * @devad: device address to read 643 * @regnum: register number to read 644 * 645 * Return: The register value if successful, negative error code on failure 646 * 647 * NOTE: MUST NOT be called from interrupt context, 648 * because the bus read/write functions may wait for an interrupt 649 * to conclude the operation. 650 */ 651 int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum) 652 { 653 int retval; 654 655 mutex_lock(&bus->mdio_lock); 656 retval = __mdiobus_c45_read(bus, addr, devad, regnum); 657 mutex_unlock(&bus->mdio_lock); 658 659 return retval; 660 } 661 EXPORT_SYMBOL(mdiobus_c45_read); 662 663 /** 664 * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function 665 * @bus: the mii_bus struct 666 * @addr: the phy address 667 * @devad: device address to read 668 * @regnum: register number to read 669 * 670 * Return: The register value if successful, negative error code on failure 671 * 672 * In case of nested MDIO bus access avoid lockdep false positives by 673 * using mutex_lock_nested(). 674 * 675 * NOTE: MUST NOT be called from interrupt context, 676 * because the bus read/write functions may wait for an interrupt 677 * to conclude the operation. 678 */ 679 int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad, 680 u32 regnum) 681 { 682 int retval; 683 684 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 685 retval = __mdiobus_c45_read(bus, addr, devad, regnum); 686 mutex_unlock(&bus->mdio_lock); 687 688 return retval; 689 } 690 EXPORT_SYMBOL(mdiobus_c45_read_nested); 691 692 /** 693 * mdiobus_write_nested - Nested version of the mdiobus_write function 694 * @bus: the mii_bus struct 695 * @addr: the phy address 696 * @regnum: register number to write 697 * @val: value to write to @regnum 698 * 699 * Return: Zero if successful, negative error code on failure 700 * 701 * In case of nested MDIO bus access avoid lockdep false positives by 702 * using mutex_lock_nested(). 703 * 704 * NOTE: MUST NOT be called from interrupt context, 705 * because the bus read/write functions may wait for an interrupt 706 * to conclude the operation. 707 */ 708 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val) 709 { 710 int err; 711 712 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 713 err = __mdiobus_write(bus, addr, regnum, val); 714 mutex_unlock(&bus->mdio_lock); 715 716 return err; 717 } 718 EXPORT_SYMBOL(mdiobus_write_nested); 719 720 /** 721 * mdiobus_write - Convenience function for writing a given MII mgmt register 722 * @bus: the mii_bus struct 723 * @addr: the phy address 724 * @regnum: register number to write 725 * @val: value to write to @regnum 726 * 727 * Return: Zero if successful, negative error code on failure 728 * 729 * NOTE: MUST NOT be called from interrupt context, 730 * because the bus read/write functions may wait for an interrupt 731 * to conclude the operation. 732 */ 733 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 734 { 735 int err; 736 737 mutex_lock(&bus->mdio_lock); 738 err = __mdiobus_write(bus, addr, regnum, val); 739 mutex_unlock(&bus->mdio_lock); 740 741 return err; 742 } 743 EXPORT_SYMBOL(mdiobus_write); 744 745 /** 746 * mdiobus_c45_write - Convenience function for writing a given MII mgmt register 747 * @bus: the mii_bus struct 748 * @addr: the phy address 749 * @devad: device address to read 750 * @regnum: register number to write 751 * @val: value to write to @regnum 752 * 753 * Return: Zero if successful, negative error code on failure 754 * 755 * NOTE: MUST NOT be called from interrupt context, 756 * because the bus read/write functions may wait for an interrupt 757 * to conclude the operation. 758 */ 759 int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, 760 u16 val) 761 { 762 int err; 763 764 mutex_lock(&bus->mdio_lock); 765 err = __mdiobus_c45_write(bus, addr, devad, regnum, val); 766 mutex_unlock(&bus->mdio_lock); 767 768 return err; 769 } 770 EXPORT_SYMBOL(mdiobus_c45_write); 771 772 /** 773 * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function 774 * @bus: the mii_bus struct 775 * @addr: the phy address 776 * @devad: device address to read 777 * @regnum: register number to write 778 * @val: value to write to @regnum 779 * 780 * Return: Zero if successful, negative error code on failure 781 * 782 * In case of nested MDIO bus access avoid lockdep false positives by 783 * using mutex_lock_nested(). 784 * 785 * NOTE: MUST NOT be called from interrupt context, 786 * because the bus read/write functions may wait for an interrupt 787 * to conclude the operation. 788 */ 789 int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad, 790 u32 regnum, u16 val) 791 { 792 int err; 793 794 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 795 err = __mdiobus_c45_write(bus, addr, devad, regnum, val); 796 mutex_unlock(&bus->mdio_lock); 797 798 return err; 799 } 800 EXPORT_SYMBOL(mdiobus_c45_write_nested); 801 802 /* 803 * __mdiobus_modify - Convenience function for modifying a given mdio device 804 * register 805 * @bus: the mii_bus struct 806 * @addr: the phy address 807 * @regnum: register number to write 808 * @mask: bit mask of bits to clear 809 * @set: bit mask of bits to set 810 * 811 * Return: 0 on success, negative on any error condition 812 */ 813 int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, 814 u16 set) 815 { 816 int err; 817 818 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set); 819 820 return err < 0 ? err : 0; 821 } 822 EXPORT_SYMBOL_GPL(__mdiobus_modify); 823 824 /** 825 * mdiobus_modify - Convenience function for modifying a given mdio device 826 * register 827 * @bus: the mii_bus struct 828 * @addr: the phy address 829 * @regnum: register number to write 830 * @mask: bit mask of bits to clear 831 * @set: bit mask of bits to set 832 * 833 * Return: 0 on success, negative on any error condition 834 */ 835 int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set) 836 { 837 int err; 838 839 mutex_lock(&bus->mdio_lock); 840 err = __mdiobus_modify(bus, addr, regnum, mask, set); 841 mutex_unlock(&bus->mdio_lock); 842 843 return err; 844 } 845 EXPORT_SYMBOL_GPL(mdiobus_modify); 846 847 /** 848 * mdiobus_c45_modify - Convenience function for modifying a given mdio device 849 * register 850 * @bus: the mii_bus struct 851 * @addr: the phy address 852 * @devad: device address to read 853 * @regnum: register number to write 854 * @mask: bit mask of bits to clear 855 * @set: bit mask of bits to set 856 * 857 * Return: 0 on success, negative on any error condition 858 */ 859 int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum, 860 u16 mask, u16 set) 861 { 862 int err; 863 864 mutex_lock(&bus->mdio_lock); 865 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, 866 mask, set); 867 mutex_unlock(&bus->mdio_lock); 868 869 return err < 0 ? err : 0; 870 } 871 EXPORT_SYMBOL_GPL(mdiobus_c45_modify); 872 873 /** 874 * mdiobus_modify_changed - Convenience function for modifying a given mdio 875 * device register and returning if it changed 876 * @bus: the mii_bus struct 877 * @addr: the phy address 878 * @regnum: register number to write 879 * @mask: bit mask of bits to clear 880 * @set: bit mask of bits to set 881 * 882 * Return: 1 if the register was modified, 0 if no change was needed, 883 * negative on any error condition 884 */ 885 int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, 886 u16 mask, u16 set) 887 { 888 int err; 889 890 mutex_lock(&bus->mdio_lock); 891 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set); 892 mutex_unlock(&bus->mdio_lock); 893 894 return err; 895 } 896 EXPORT_SYMBOL_GPL(mdiobus_modify_changed); 897 898 /** 899 * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio 900 * device register and returning if it changed 901 * @bus: the mii_bus struct 902 * @addr: the phy address 903 * @devad: device address to read 904 * @regnum: register number to write 905 * @mask: bit mask of bits to clear 906 * @set: bit mask of bits to set 907 * 908 * Return: 1 if the register was modified, 0 if no change was needed, 909 * negative on any error condition 910 */ 911 int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad, 912 u32 regnum, u16 mask, u16 set) 913 { 914 int err; 915 916 mutex_lock(&bus->mdio_lock); 917 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set); 918 mutex_unlock(&bus->mdio_lock); 919 920 return err; 921 } 922 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed); 923 924 /** 925 * mdio_bus_match - determine if given MDIO driver supports the given 926 * MDIO device 927 * @dev: target MDIO device 928 * @drv: given MDIO driver 929 * 930 * Return: 1 if the driver supports the device, 0 otherwise 931 * 932 * Description: This may require calling the devices own match function, 933 * since different classes of MDIO devices have different match criteria. 934 */ 935 static int mdio_bus_match(struct device *dev, const struct device_driver *drv) 936 { 937 const struct mdio_driver *mdiodrv = to_mdio_driver(drv); 938 struct mdio_device *mdio = to_mdio_device(dev); 939 940 /* Both the driver and device must type-match */ 941 if (!(mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) != 942 !(mdio->flags & MDIO_DEVICE_FLAG_PHY)) 943 return 0; 944 945 if (of_driver_match_device(dev, drv)) 946 return 1; 947 948 if (mdio->bus_match) 949 return mdio->bus_match(dev, drv); 950 951 return 0; 952 } 953 954 static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env) 955 { 956 int rc; 957 958 /* Some devices have extra OF data and an OF-style MODALIAS */ 959 rc = of_device_uevent_modalias(dev, env); 960 if (rc != -ENODEV) 961 return rc; 962 963 return 0; 964 } 965 966 static const struct attribute *const mdio_bus_device_statistics_attrs[] = { 967 &dev_attr_mdio_bus_device_transfers.attr.attr, 968 &dev_attr_mdio_bus_device_errors.attr.attr, 969 &dev_attr_mdio_bus_device_writes.attr.attr, 970 &dev_attr_mdio_bus_device_reads.attr.attr, 971 NULL, 972 }; 973 974 static const struct attribute_group mdio_bus_device_statistics_group = { 975 .name = "statistics", 976 .attrs_const = mdio_bus_device_statistics_attrs, 977 }; 978 __ATTRIBUTE_GROUPS(mdio_bus_device_statistics); 979 980 const struct bus_type mdio_bus_type = { 981 .name = "mdio_bus", 982 .dev_groups = mdio_bus_device_statistics_groups, 983 .match = mdio_bus_match, 984 .uevent = mdio_uevent, 985 }; 986 EXPORT_SYMBOL(mdio_bus_type); 987 988 static int __init mdio_bus_init(void) 989 { 990 int ret; 991 992 ret = class_register(&mdio_bus_class); 993 if (!ret) { 994 ret = bus_register(&mdio_bus_type); 995 if (ret) 996 class_unregister(&mdio_bus_class); 997 } 998 999 return ret; 1000 } 1001 1002 static void __exit mdio_bus_exit(void) 1003 { 1004 class_unregister(&mdio_bus_class); 1005 bus_unregister(&mdio_bus_type); 1006 } 1007 1008 subsys_initcall(mdio_bus_init); 1009 module_exit(mdio_bus_exit); 1010 1011 MODULE_LICENSE("GPL"); 1012 MODULE_DESCRIPTION("MDIO bus/device layer"); 1013