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