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