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 (bus->read) 449 retval = bus->read(bus, addr, regnum); 450 else 451 retval = -EOPNOTSUPP; 452 453 trace_mdio_access(bus, 1, addr, regnum, retval, retval); 454 mdiobus_stats_acct(&bus->stats[addr], true, retval); 455 456 return retval; 457 } 458 EXPORT_SYMBOL(__mdiobus_read); 459 460 /** 461 * __mdiobus_write - Unlocked version of the mdiobus_write function 462 * @bus: the mii_bus struct 463 * @addr: the phy address 464 * @regnum: register number to write 465 * @val: value to write to @regnum 466 * 467 * Write a MDIO bus register. Caller must hold the mdio bus lock. 468 * 469 * NOTE: MUST NOT be called from interrupt context. 470 */ 471 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 472 { 473 int err; 474 475 lockdep_assert_held_once(&bus->mdio_lock); 476 477 if (bus->write) 478 err = bus->write(bus, addr, regnum, val); 479 else 480 err = -EOPNOTSUPP; 481 482 trace_mdio_access(bus, 0, addr, regnum, val, err); 483 mdiobus_stats_acct(&bus->stats[addr], false, err); 484 485 return err; 486 } 487 EXPORT_SYMBOL(__mdiobus_write); 488 489 /** 490 * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function 491 * @bus: the mii_bus struct 492 * @addr: the phy address 493 * @regnum: register number to modify 494 * @mask: bit mask of bits to clear 495 * @set: bit mask of bits to set 496 * 497 * Read, modify, and if any change, write the register value back to the 498 * device. Any error returns a negative number. 499 * 500 * NOTE: MUST NOT be called from interrupt context. 501 */ 502 int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, 503 u16 mask, u16 set) 504 { 505 int new, ret; 506 507 ret = __mdiobus_read(bus, addr, regnum); 508 if (ret < 0) 509 return ret; 510 511 new = (ret & ~mask) | set; 512 if (new == ret) 513 return 0; 514 515 ret = __mdiobus_write(bus, addr, regnum, new); 516 517 return ret < 0 ? ret : 1; 518 } 519 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed); 520 521 /** 522 * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function 523 * @bus: the mii_bus struct 524 * @addr: the phy address 525 * @devad: device address to read 526 * @regnum: register number to read 527 * 528 * Read a MDIO bus register. Caller must hold the mdio bus lock. 529 * 530 * NOTE: MUST NOT be called from interrupt context. 531 */ 532 int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum) 533 { 534 int retval; 535 536 lockdep_assert_held_once(&bus->mdio_lock); 537 538 if (bus->read_c45) 539 retval = bus->read_c45(bus, addr, devad, regnum); 540 else 541 retval = -EOPNOTSUPP; 542 543 trace_mdio_access(bus, 1, addr, regnum, retval, retval); 544 mdiobus_stats_acct(&bus->stats[addr], true, retval); 545 546 return retval; 547 } 548 EXPORT_SYMBOL(__mdiobus_c45_read); 549 550 /** 551 * __mdiobus_c45_write - Unlocked version of the mdiobus_write function 552 * @bus: the mii_bus struct 553 * @addr: the phy address 554 * @devad: device address to read 555 * @regnum: register number to write 556 * @val: value to write to @regnum 557 * 558 * Write a MDIO bus register. Caller must hold the mdio bus lock. 559 * 560 * NOTE: MUST NOT be called from interrupt context. 561 */ 562 int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, 563 u16 val) 564 { 565 int err; 566 567 lockdep_assert_held_once(&bus->mdio_lock); 568 569 if (bus->write_c45) 570 err = bus->write_c45(bus, addr, devad, regnum, val); 571 else 572 err = -EOPNOTSUPP; 573 574 trace_mdio_access(bus, 0, addr, regnum, val, err); 575 mdiobus_stats_acct(&bus->stats[addr], false, err); 576 577 return err; 578 } 579 EXPORT_SYMBOL(__mdiobus_c45_write); 580 581 /** 582 * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function 583 * @bus: the mii_bus struct 584 * @addr: the phy address 585 * @devad: device address to read 586 * @regnum: register number to modify 587 * @mask: bit mask of bits to clear 588 * @set: bit mask of bits to set 589 * 590 * Read, modify, and if any change, write the register value back to the 591 * device. Any error returns a negative number. 592 * 593 * NOTE: MUST NOT be called from interrupt context. 594 */ 595 static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, 596 int devad, u32 regnum, u16 mask, 597 u16 set) 598 { 599 int new, ret; 600 601 ret = __mdiobus_c45_read(bus, addr, devad, regnum); 602 if (ret < 0) 603 return ret; 604 605 new = (ret & ~mask) | set; 606 if (new == ret) 607 return 0; 608 609 ret = __mdiobus_c45_write(bus, addr, devad, regnum, new); 610 611 return ret < 0 ? ret : 1; 612 } 613 614 /** 615 * mdiobus_read_nested - Nested version of the mdiobus_read function 616 * @bus: the mii_bus struct 617 * @addr: the phy address 618 * @regnum: register number to read 619 * 620 * In case of nested MDIO bus access avoid lockdep false positives by 621 * using mutex_lock_nested(). 622 * 623 * NOTE: MUST NOT be called from interrupt context, 624 * because the bus read/write functions may wait for an interrupt 625 * to conclude the operation. 626 */ 627 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum) 628 { 629 int retval; 630 631 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 632 retval = __mdiobus_read(bus, addr, regnum); 633 mutex_unlock(&bus->mdio_lock); 634 635 return retval; 636 } 637 EXPORT_SYMBOL(mdiobus_read_nested); 638 639 /** 640 * mdiobus_read - Convenience function for reading a given MII mgmt register 641 * @bus: the mii_bus struct 642 * @addr: the phy address 643 * @regnum: register number to read 644 * 645 * NOTE: MUST NOT be called from interrupt context, 646 * because the bus read/write functions may wait for an interrupt 647 * to conclude the operation. 648 */ 649 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) 650 { 651 int retval; 652 653 mutex_lock(&bus->mdio_lock); 654 retval = __mdiobus_read(bus, addr, regnum); 655 mutex_unlock(&bus->mdio_lock); 656 657 return retval; 658 } 659 EXPORT_SYMBOL(mdiobus_read); 660 661 /** 662 * mdiobus_c45_read - Convenience function for reading a given MII mgmt register 663 * @bus: the mii_bus struct 664 * @addr: the phy address 665 * @devad: device address to read 666 * @regnum: register number to read 667 * 668 * NOTE: MUST NOT be called from interrupt context, 669 * because the bus read/write functions may wait for an interrupt 670 * to conclude the operation. 671 */ 672 int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum) 673 { 674 int retval; 675 676 mutex_lock(&bus->mdio_lock); 677 retval = __mdiobus_c45_read(bus, addr, devad, regnum); 678 mutex_unlock(&bus->mdio_lock); 679 680 return retval; 681 } 682 EXPORT_SYMBOL(mdiobus_c45_read); 683 684 /** 685 * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function 686 * @bus: the mii_bus struct 687 * @addr: the phy address 688 * @devad: device address to read 689 * @regnum: register number to read 690 * 691 * In case of nested MDIO bus access avoid lockdep false positives by 692 * using mutex_lock_nested(). 693 * 694 * NOTE: MUST NOT be called from interrupt context, 695 * because the bus read/write functions may wait for an interrupt 696 * to conclude the operation. 697 */ 698 int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad, 699 u32 regnum) 700 { 701 int retval; 702 703 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 704 retval = __mdiobus_c45_read(bus, addr, devad, regnum); 705 mutex_unlock(&bus->mdio_lock); 706 707 return retval; 708 } 709 EXPORT_SYMBOL(mdiobus_c45_read_nested); 710 711 /** 712 * mdiobus_write_nested - Nested version of the mdiobus_write function 713 * @bus: the mii_bus struct 714 * @addr: the phy address 715 * @regnum: register number to write 716 * @val: value to write to @regnum 717 * 718 * In case of nested MDIO bus access avoid lockdep false positives by 719 * using mutex_lock_nested(). 720 * 721 * NOTE: MUST NOT be called from interrupt context, 722 * because the bus read/write functions may wait for an interrupt 723 * to conclude the operation. 724 */ 725 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val) 726 { 727 int err; 728 729 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 730 err = __mdiobus_write(bus, addr, regnum, val); 731 mutex_unlock(&bus->mdio_lock); 732 733 return err; 734 } 735 EXPORT_SYMBOL(mdiobus_write_nested); 736 737 /** 738 * mdiobus_write - Convenience function for writing a given MII mgmt register 739 * @bus: the mii_bus struct 740 * @addr: the phy address 741 * @regnum: register number to write 742 * @val: value to write to @regnum 743 * 744 * NOTE: MUST NOT be called from interrupt context, 745 * because the bus read/write functions may wait for an interrupt 746 * to conclude the operation. 747 */ 748 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) 749 { 750 int err; 751 752 mutex_lock(&bus->mdio_lock); 753 err = __mdiobus_write(bus, addr, regnum, val); 754 mutex_unlock(&bus->mdio_lock); 755 756 return err; 757 } 758 EXPORT_SYMBOL(mdiobus_write); 759 760 /** 761 * mdiobus_c45_write - Convenience function for writing a given MII mgmt register 762 * @bus: the mii_bus struct 763 * @addr: the phy address 764 * @devad: device address to read 765 * @regnum: register number to write 766 * @val: value to write to @regnum 767 * 768 * NOTE: MUST NOT be called from interrupt context, 769 * because the bus read/write functions may wait for an interrupt 770 * to conclude the operation. 771 */ 772 int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum, 773 u16 val) 774 { 775 int err; 776 777 mutex_lock(&bus->mdio_lock); 778 err = __mdiobus_c45_write(bus, addr, devad, regnum, val); 779 mutex_unlock(&bus->mdio_lock); 780 781 return err; 782 } 783 EXPORT_SYMBOL(mdiobus_c45_write); 784 785 /** 786 * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function 787 * @bus: the mii_bus struct 788 * @addr: the phy address 789 * @devad: device address to read 790 * @regnum: register number to write 791 * @val: value to write to @regnum 792 * 793 * In case of nested MDIO bus access avoid lockdep false positives by 794 * using mutex_lock_nested(). 795 * 796 * NOTE: MUST NOT be called from interrupt context, 797 * because the bus read/write functions may wait for an interrupt 798 * to conclude the operation. 799 */ 800 int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad, 801 u32 regnum, u16 val) 802 { 803 int err; 804 805 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); 806 err = __mdiobus_c45_write(bus, addr, devad, regnum, val); 807 mutex_unlock(&bus->mdio_lock); 808 809 return err; 810 } 811 EXPORT_SYMBOL(mdiobus_c45_write_nested); 812 813 /* 814 * __mdiobus_modify - Convenience function for modifying a given mdio device 815 * register 816 * @bus: the mii_bus struct 817 * @addr: the phy address 818 * @regnum: register number to write 819 * @mask: bit mask of bits to clear 820 * @set: bit mask of bits to set 821 */ 822 int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, 823 u16 set) 824 { 825 int err; 826 827 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set); 828 829 return err < 0 ? err : 0; 830 } 831 EXPORT_SYMBOL_GPL(__mdiobus_modify); 832 833 /** 834 * mdiobus_modify - Convenience function for modifying a given mdio device 835 * register 836 * @bus: the mii_bus struct 837 * @addr: the phy address 838 * @regnum: register number to write 839 * @mask: bit mask of bits to clear 840 * @set: bit mask of bits to set 841 */ 842 int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set) 843 { 844 int err; 845 846 mutex_lock(&bus->mdio_lock); 847 err = __mdiobus_modify(bus, addr, regnum, mask, set); 848 mutex_unlock(&bus->mdio_lock); 849 850 return err; 851 } 852 EXPORT_SYMBOL_GPL(mdiobus_modify); 853 854 /** 855 * mdiobus_c45_modify - Convenience function for modifying a given mdio device 856 * register 857 * @bus: the mii_bus struct 858 * @addr: the phy address 859 * @devad: device address to read 860 * @regnum: register number to write 861 * @mask: bit mask of bits to clear 862 * @set: bit mask of bits to set 863 */ 864 int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum, 865 u16 mask, u16 set) 866 { 867 int err; 868 869 mutex_lock(&bus->mdio_lock); 870 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, 871 mask, set); 872 mutex_unlock(&bus->mdio_lock); 873 874 return err < 0 ? err : 0; 875 } 876 EXPORT_SYMBOL_GPL(mdiobus_c45_modify); 877 878 /** 879 * mdiobus_modify_changed - Convenience function for modifying a given mdio 880 * device register and returning if it changed 881 * @bus: the mii_bus struct 882 * @addr: the phy address 883 * @regnum: register number to write 884 * @mask: bit mask of bits to clear 885 * @set: bit mask of bits to set 886 */ 887 int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum, 888 u16 mask, u16 set) 889 { 890 int err; 891 892 mutex_lock(&bus->mdio_lock); 893 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set); 894 mutex_unlock(&bus->mdio_lock); 895 896 return err; 897 } 898 EXPORT_SYMBOL_GPL(mdiobus_modify_changed); 899 900 /** 901 * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio 902 * device register and returning if it changed 903 * @bus: the mii_bus struct 904 * @addr: the phy address 905 * @devad: device address to read 906 * @regnum: register number to write 907 * @mask: bit mask of bits to clear 908 * @set: bit mask of bits to set 909 */ 910 int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad, 911 u32 regnum, u16 mask, u16 set) 912 { 913 int err; 914 915 mutex_lock(&bus->mdio_lock); 916 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set); 917 mutex_unlock(&bus->mdio_lock); 918 919 return err; 920 } 921 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed); 922 923 /** 924 * mdio_bus_match - determine if given MDIO driver supports the given 925 * MDIO device 926 * @dev: target MDIO device 927 * @drv: given MDIO driver 928 * 929 * Description: Given a MDIO device, and a MDIO driver, return 1 if 930 * the driver supports the device. Otherwise, return 0. This may 931 * require calling the devices own match function, since different classes 932 * of MDIO devices have different match criteria. 933 */ 934 static int mdio_bus_match(struct device *dev, const struct device_driver *drv) 935 { 936 const struct mdio_driver *mdiodrv = to_mdio_driver(drv); 937 struct mdio_device *mdio = to_mdio_device(dev); 938 939 /* Both the driver and device must type-match */ 940 if (!(mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) != 941 !(mdio->flags & MDIO_DEVICE_FLAG_PHY)) 942 return 0; 943 944 if (of_driver_match_device(dev, drv)) 945 return 1; 946 947 if (mdio->bus_match) 948 return mdio->bus_match(dev, drv); 949 950 return 0; 951 } 952 953 static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env) 954 { 955 int rc; 956 957 /* Some devices have extra OF data and an OF-style MODALIAS */ 958 rc = of_device_uevent_modalias(dev, env); 959 if (rc != -ENODEV) 960 return rc; 961 962 return 0; 963 } 964 965 static struct attribute *mdio_bus_device_statistics_attrs[] = { 966 &dev_attr_mdio_bus_device_transfers.attr.attr, 967 &dev_attr_mdio_bus_device_errors.attr.attr, 968 &dev_attr_mdio_bus_device_writes.attr.attr, 969 &dev_attr_mdio_bus_device_reads.attr.attr, 970 NULL, 971 }; 972 973 static const struct attribute_group mdio_bus_device_statistics_group = { 974 .name = "statistics", 975 .attrs = mdio_bus_device_statistics_attrs, 976 }; 977 978 static const struct attribute_group *mdio_bus_dev_groups[] = { 979 &mdio_bus_device_statistics_group, 980 NULL, 981 }; 982 983 const struct bus_type mdio_bus_type = { 984 .name = "mdio_bus", 985 .dev_groups = mdio_bus_dev_groups, 986 .match = mdio_bus_match, 987 .uevent = mdio_uevent, 988 }; 989 EXPORT_SYMBOL(mdio_bus_type); 990 991 static int __init mdio_bus_init(void) 992 { 993 int ret; 994 995 ret = class_register(&mdio_bus_class); 996 if (!ret) { 997 ret = bus_register(&mdio_bus_type); 998 if (ret) 999 class_unregister(&mdio_bus_class); 1000 } 1001 1002 return ret; 1003 } 1004 1005 static void __exit mdio_bus_exit(void) 1006 { 1007 class_unregister(&mdio_bus_class); 1008 bus_unregister(&mdio_bus_type); 1009 } 1010 1011 subsys_initcall(mdio_bus_init); 1012 module_exit(mdio_bus_exit); 1013 1014 MODULE_LICENSE("GPL"); 1015 MODULE_DESCRIPTION("MDIO bus/device layer"); 1016