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