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/delay.h>
  12#include <linux/device.h>
  13#include <linux/errno.h>
  14#include <linux/etherdevice.h>
  15#include <linux/ethtool.h>
  16#include <linux/gpio/consumer.h>
  17#include <linux/init.h>
  18#include <linux/interrupt.h>
  19#include <linux/io.h>
  20#include <linux/kernel.h>
  21#include <linux/micrel_phy.h>
  22#include <linux/mii.h>
  23#include <linux/mm.h>
  24#include <linux/module.h>
  25#include <linux/netdevice.h>
  26#include <linux/of_device.h>
  27#include <linux/of_mdio.h>
  28#include <linux/phy.h>
  29#include <linux/reset.h>
  30#include <linux/skbuff.h>
  31#include <linux/slab.h>
  32#include <linux/spinlock.h>
  33#include <linux/string.h>
 
 
 
 
 
  34#include <linux/uaccess.h>
  35#include <linux/unistd.h>
  36
  37#define CREATE_TRACE_POINTS
  38#include <trace/events/mdio.h>
  39
  40#include "mdio-boardinfo.h"
  41
  42static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
  43{
  44	/* Deassert the optional reset signal */
  45	mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
  46						 "reset", GPIOD_OUT_LOW);
  47	if (IS_ERR(mdiodev->reset_gpio))
  48		return PTR_ERR(mdiodev->reset_gpio);
  49
  50	if (mdiodev->reset_gpio)
  51		gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
  52
  53	return 0;
  54}
  55
  56static int mdiobus_register_reset(struct mdio_device *mdiodev)
  57{
  58	struct reset_control *reset;
  59
  60	reset = reset_control_get_optional_exclusive(&mdiodev->dev, "phy");
  61	if (IS_ERR(reset))
  62		return PTR_ERR(reset);
  63
  64	mdiodev->reset_ctrl = reset;
  65
  66	return 0;
  67}
  68
  69int mdiobus_register_device(struct mdio_device *mdiodev)
  70{
  71	int err;
  72
  73	if (mdiodev->bus->mdio_map[mdiodev->addr])
  74		return -EBUSY;
  75
  76	if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
  77		err = mdiobus_register_gpiod(mdiodev);
  78		if (err)
  79			return err;
  80
  81		err = mdiobus_register_reset(mdiodev);
  82		if (err)
  83			return err;
  84
  85		/* Assert the reset signal */
  86		mdio_device_reset(mdiodev, 1);
  87	}
  88
  89	mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
  90
  91	return 0;
  92}
  93EXPORT_SYMBOL(mdiobus_register_device);
  94
  95int mdiobus_unregister_device(struct mdio_device *mdiodev)
  96{
  97	if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
  98		return -EINVAL;
  99
 100	reset_control_put(mdiodev->reset_ctrl);
 101
 102	mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
 103
 104	return 0;
 105}
 106EXPORT_SYMBOL(mdiobus_unregister_device);
 107
 108static struct mdio_device *mdiobus_find_device(struct mii_bus *bus, int addr)
 109{
 110	bool addr_valid = addr >= 0 && addr < ARRAY_SIZE(bus->mdio_map);
 111
 112	if (WARN_ONCE(!addr_valid, "addr %d out of range\n", addr))
 113		return NULL;
 114
 115	return bus->mdio_map[addr];
 116}
 117
 118struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
 119{
 120	struct mdio_device *mdiodev;
 121
 122	mdiodev = mdiobus_find_device(bus, addr);
 123	if (!mdiodev)
 124		return NULL;
 125
 126	if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
 127		return NULL;
 128
 129	return container_of(mdiodev, struct phy_device, mdio);
 130}
 131EXPORT_SYMBOL(mdiobus_get_phy);
 132
 133bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
 134{
 135	return mdiobus_find_device(bus, addr) != NULL;
 136}
 137EXPORT_SYMBOL(mdiobus_is_registered_device);
 138
 139/**
 140 * mdiobus_alloc_size - allocate a mii_bus structure
 141 * @size: extra amount of memory to allocate for private storage.
 142 * If non-zero, then bus->priv is points to that memory.
 143 *
 144 * Description: called by a bus driver to allocate an mii_bus
 145 * structure to fill in.
 146 */
 147struct mii_bus *mdiobus_alloc_size(size_t size)
 148{
 149	struct mii_bus *bus;
 150	size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
 151	size_t alloc_size;
 152	int i;
 153
 154	/* If we alloc extra space, it should be aligned */
 155	if (size)
 156		alloc_size = aligned_size + size;
 157	else
 158		alloc_size = sizeof(*bus);
 159
 160	bus = kzalloc(alloc_size, GFP_KERNEL);
 161	if (!bus)
 162		return NULL;
 163
 164	bus->state = MDIOBUS_ALLOCATED;
 165	if (size)
 166		bus->priv = (void *)bus + aligned_size;
 167
 168	/* Initialise the interrupts to polling and 64-bit seqcounts */
 169	for (i = 0; i < PHY_MAX_ADDR; i++) {
 170		bus->irq[i] = PHY_POLL;
 171		u64_stats_init(&bus->stats[i].syncp);
 172	}
 173
 174	return bus;
 175}
 176EXPORT_SYMBOL(mdiobus_alloc_size);
 177
 178/**
 179 * mdiobus_release - mii_bus device release callback
 180 * @d: the target struct device that contains the mii_bus
 181 *
 182 * Description: called when the last reference to an mii_bus is
 183 * dropped, to free the underlying memory.
 184 */
 185static void mdiobus_release(struct device *d)
 186{
 187	struct mii_bus *bus = to_mii_bus(d);
 188
 189	WARN(bus->state != MDIOBUS_RELEASED &&
 190	     /* for compatibility with error handling in drivers */
 191	     bus->state != MDIOBUS_ALLOCATED,
 192	     "%s: not in RELEASED or ALLOCATED state\n",
 193	     bus->id);
 194
 195	if (bus->state == MDIOBUS_RELEASED)
 196		fwnode_handle_put(dev_fwnode(d));
 197
 198	kfree(bus);
 199}
 200
 201struct mdio_bus_stat_attr {
 202	int addr;
 203	unsigned int field_offset;
 204};
 205
 206static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset)
 207{
 208	const char *p = (const char *)s + offset;
 209	unsigned int start;
 210	u64 val = 0;
 211
 212	do {
 213		start = u64_stats_fetch_begin(&s->syncp);
 214		val = u64_stats_read((const u64_stats_t *)p);
 215	} while (u64_stats_fetch_retry(&s->syncp, start));
 216
 217	return val;
 218}
 219
 220static u64 mdio_bus_get_global_stat(struct mii_bus *bus, unsigned int offset)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 221{
 222	unsigned int i;
 223	u64 val = 0;
 224
 225	for (i = 0; i < PHY_MAX_ADDR; i++)
 226		val += mdio_bus_get_stat(&bus->stats[i], offset);
 
 
 
 
 
 
 
 
 
 
 227
 228	return val;
 229}
 
 230
 231static ssize_t mdio_bus_stat_field_show(struct device *dev,
 232					struct device_attribute *attr,
 233					char *buf)
 
 
 
 
 
 234{
 235	struct mii_bus *bus = to_mii_bus(dev);
 236	struct mdio_bus_stat_attr *sattr;
 237	struct dev_ext_attribute *eattr;
 238	u64 val;
 239
 240	eattr = container_of(attr, struct dev_ext_attribute, attr);
 241	sattr = eattr->var;
 242
 243	if (sattr->addr < 0)
 244		val = mdio_bus_get_global_stat(bus, sattr->field_offset);
 245	else
 246		val = mdio_bus_get_stat(&bus->stats[sattr->addr],
 247					sattr->field_offset);
 248
 249	return sysfs_emit(buf, "%llu\n", val);
 
 
 250}
 
 251
 252static ssize_t mdio_bus_device_stat_field_show(struct device *dev,
 253					       struct device_attribute *attr,
 254					       char *buf)
 255{
 256	struct mdio_device *mdiodev = to_mdio_device(dev);
 257	struct mii_bus *bus = mdiodev->bus;
 258	struct mdio_bus_stat_attr *sattr;
 259	struct dev_ext_attribute *eattr;
 260	int addr = mdiodev->addr;
 261	u64 val;
 262
 263	eattr = container_of(attr, struct dev_ext_attribute, attr);
 264	sattr = eattr->var;
 265
 266	val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset);
 267
 268	return sysfs_emit(buf, "%llu\n", val);
 269}
 270
 271#define MDIO_BUS_STATS_ATTR_DECL(field, file)				\
 272static struct dev_ext_attribute dev_attr_mdio_bus_##field = {		\
 273	.attr = { .attr = { .name = file, .mode = 0444 },		\
 274		     .show = mdio_bus_stat_field_show,			\
 275	},								\
 276	.var = &((struct mdio_bus_stat_attr) {				\
 277		-1, offsetof(struct mdio_bus_stats, field)		\
 278	}),								\
 279};									\
 280static struct dev_ext_attribute dev_attr_mdio_bus_device_##field = {	\
 281	.attr = { .attr = { .name = file, .mode = 0444 },		\
 282		     .show = mdio_bus_device_stat_field_show,		\
 283	},								\
 284	.var = &((struct mdio_bus_stat_attr) {				\
 285		-1, offsetof(struct mdio_bus_stats, field)		\
 286	}),								\
 287};
 288
 289#define MDIO_BUS_STATS_ATTR(field)					\
 290	MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
 291
 292MDIO_BUS_STATS_ATTR(transfers);
 293MDIO_BUS_STATS_ATTR(errors);
 294MDIO_BUS_STATS_ATTR(writes);
 295MDIO_BUS_STATS_ATTR(reads);
 296
 297#define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file)		\
 298static struct dev_ext_attribute dev_attr_mdio_bus_addr_##field##_##addr = { \
 299	.attr = { .attr = { .name = file, .mode = 0444 },		\
 300		     .show = mdio_bus_stat_field_show,			\
 301	},								\
 302	.var = &((struct mdio_bus_stat_attr) {				\
 303		addr, offsetof(struct mdio_bus_stats, field)		\
 304	}),								\
 305}
 306
 307#define MDIO_BUS_STATS_ADDR_ATTR(field, addr)				\
 308	MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr,			\
 309				 __stringify(field) "_" __stringify(addr))
 310
 311#define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr)			\
 312	MDIO_BUS_STATS_ADDR_ATTR(transfers, addr);			\
 313	MDIO_BUS_STATS_ADDR_ATTR(errors, addr);				\
 314	MDIO_BUS_STATS_ADDR_ATTR(writes, addr);				\
 315	MDIO_BUS_STATS_ADDR_ATTR(reads, addr)				\
 316
 317MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0);
 318MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1);
 319MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2);
 320MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3);
 321MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4);
 322MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5);
 323MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6);
 324MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7);
 325MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8);
 326MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9);
 327MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10);
 328MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11);
 329MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12);
 330MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13);
 331MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14);
 332MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15);
 333MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16);
 334MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17);
 335MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18);
 336MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19);
 337MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20);
 338MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21);
 339MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22);
 340MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23);
 341MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24);
 342MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25);
 343MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26);
 344MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27);
 345MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28);
 346MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29);
 347MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30);
 348MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31);
 349
 350#define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr)				\
 351	&dev_attr_mdio_bus_addr_transfers_##addr.attr.attr,		\
 352	&dev_attr_mdio_bus_addr_errors_##addr.attr.attr,		\
 353	&dev_attr_mdio_bus_addr_writes_##addr.attr.attr,		\
 354	&dev_attr_mdio_bus_addr_reads_##addr.attr.attr			\
 355
 356static struct attribute *mdio_bus_statistics_attrs[] = {
 357	&dev_attr_mdio_bus_transfers.attr.attr,
 358	&dev_attr_mdio_bus_errors.attr.attr,
 359	&dev_attr_mdio_bus_writes.attr.attr,
 360	&dev_attr_mdio_bus_reads.attr.attr,
 361	MDIO_BUS_STATS_ADDR_ATTR_GROUP(0),
 362	MDIO_BUS_STATS_ADDR_ATTR_GROUP(1),
 363	MDIO_BUS_STATS_ADDR_ATTR_GROUP(2),
 364	MDIO_BUS_STATS_ADDR_ATTR_GROUP(3),
 365	MDIO_BUS_STATS_ADDR_ATTR_GROUP(4),
 366	MDIO_BUS_STATS_ADDR_ATTR_GROUP(5),
 367	MDIO_BUS_STATS_ADDR_ATTR_GROUP(6),
 368	MDIO_BUS_STATS_ADDR_ATTR_GROUP(7),
 369	MDIO_BUS_STATS_ADDR_ATTR_GROUP(8),
 370	MDIO_BUS_STATS_ADDR_ATTR_GROUP(9),
 371	MDIO_BUS_STATS_ADDR_ATTR_GROUP(10),
 372	MDIO_BUS_STATS_ADDR_ATTR_GROUP(11),
 373	MDIO_BUS_STATS_ADDR_ATTR_GROUP(12),
 374	MDIO_BUS_STATS_ADDR_ATTR_GROUP(13),
 375	MDIO_BUS_STATS_ADDR_ATTR_GROUP(14),
 376	MDIO_BUS_STATS_ADDR_ATTR_GROUP(15),
 377	MDIO_BUS_STATS_ADDR_ATTR_GROUP(16),
 378	MDIO_BUS_STATS_ADDR_ATTR_GROUP(17),
 379	MDIO_BUS_STATS_ADDR_ATTR_GROUP(18),
 380	MDIO_BUS_STATS_ADDR_ATTR_GROUP(19),
 381	MDIO_BUS_STATS_ADDR_ATTR_GROUP(20),
 382	MDIO_BUS_STATS_ADDR_ATTR_GROUP(21),
 383	MDIO_BUS_STATS_ADDR_ATTR_GROUP(22),
 384	MDIO_BUS_STATS_ADDR_ATTR_GROUP(23),
 385	MDIO_BUS_STATS_ADDR_ATTR_GROUP(24),
 386	MDIO_BUS_STATS_ADDR_ATTR_GROUP(25),
 387	MDIO_BUS_STATS_ADDR_ATTR_GROUP(26),
 388	MDIO_BUS_STATS_ADDR_ATTR_GROUP(27),
 389	MDIO_BUS_STATS_ADDR_ATTR_GROUP(28),
 390	MDIO_BUS_STATS_ADDR_ATTR_GROUP(29),
 391	MDIO_BUS_STATS_ADDR_ATTR_GROUP(30),
 392	MDIO_BUS_STATS_ADDR_ATTR_GROUP(31),
 393	NULL,
 394};
 395
 396static const struct attribute_group mdio_bus_statistics_group = {
 397	.name	= "statistics",
 398	.attrs	= mdio_bus_statistics_attrs,
 399};
 400
 401static const struct attribute_group *mdio_bus_groups[] = {
 402	&mdio_bus_statistics_group,
 403	NULL,
 404};
 405
 406static struct class mdio_bus_class = {
 407	.name		= "mdio_bus",
 408	.dev_release	= mdiobus_release,
 409	.dev_groups	= mdio_bus_groups,
 410};
 411
 412/**
 413 * mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
 414 * @mdio_name: The name of a mdiobus.
 415 *
 416 * Returns a reference to the mii_bus, or NULL if none found.  The
 417 * embedded struct device will have its reference count incremented,
 418 * and this must be put_deviced'ed once the bus is finished with.
 419 */
 420struct mii_bus *mdio_find_bus(const char *mdio_name)
 421{
 422	struct device *d;
 423
 424	d = class_find_device_by_name(&mdio_bus_class, mdio_name);
 425	return d ? to_mii_bus(d) : NULL;
 426}
 427EXPORT_SYMBOL(mdio_find_bus);
 428
 429#if IS_ENABLED(CONFIG_OF_MDIO)
 430/**
 431 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
 432 * @mdio_bus_np: Pointer to the mii_bus.
 433 *
 434 * Returns a reference to the mii_bus, or NULL if none found.  The
 435 * embedded struct device will have its reference count incremented,
 436 * and this must be put once the bus is finished with.
 437 *
 438 * Because the association of a device_node and mii_bus is made via
 439 * of_mdiobus_register(), the mii_bus cannot be found before it is
 440 * registered with of_mdiobus_register().
 441 *
 442 */
 443struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
 444{
 445	struct device *d;
 446
 447	if (!mdio_bus_np)
 448		return NULL;
 449
 450	d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
 
 
 451	return d ? to_mii_bus(d) : NULL;
 452}
 453EXPORT_SYMBOL(of_mdio_find_bus);
 454
 455/* Walk the list of subnodes of a mdio bus and look for a node that
 456 * matches the mdio device's address with its 'reg' property. If
 457 * found, set the of_node pointer for the mdio device. This allows
 458 * auto-probed phy devices to be supplied with information passed in
 459 * via DT.
 460 * If a PHY package is found, PHY is searched also there.
 461 */
 462static int of_mdiobus_find_phy(struct device *dev, struct mdio_device *mdiodev,
 463			       struct device_node *np)
 464{
 
 465	struct device_node *child;
 466
 467	for_each_available_child_of_node(np, child) {
 468		int addr;
 469
 470		if (of_node_name_eq(child, "ethernet-phy-package")) {
 471			/* Validate PHY package reg presence */
 472			if (!of_property_present(child, "reg")) {
 473				of_node_put(child);
 474				return -EINVAL;
 475			}
 476
 477			if (!of_mdiobus_find_phy(dev, mdiodev, child)) {
 478				/* The refcount for the PHY package will be
 479				 * incremented later when PHY join the Package.
 480				 */
 481				of_node_put(child);
 482				return 0;
 483			}
 484
 
 
 
 
 485			continue;
 486		}
 487
 488		addr = of_mdio_parse_addr(dev, child);
 489		if (addr < 0)
 
 
 490			continue;
 
 491
 492		if (addr == mdiodev->addr) {
 493			device_set_node(dev, of_fwnode_handle(child));
 494			/* The refcount on "child" is passed to the mdio
 495			 * device. Do _not_ use of_node_put(child) here.
 496			 */
 497			return 0;
 498		}
 499	}
 500
 501	return -ENODEV;
 502}
 503
 504static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
 505				    struct mdio_device *mdiodev)
 506{
 507	struct device *dev = &mdiodev->dev;
 508
 509	if (dev->of_node || !bus->dev.of_node)
 510		return;
 511
 512	of_mdiobus_find_phy(dev, mdiodev, bus->dev.of_node);
 513}
 514#else /* !IS_ENABLED(CONFIG_OF_MDIO) */
 515static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
 516					   struct mdio_device *mdiodev)
 517{
 518}
 519#endif
 520
 521/**
 522 * mdiobus_create_device - create a full MDIO device given
 523 * a mdio_board_info structure
 524 * @bus: MDIO bus to create the devices on
 525 * @bi: mdio_board_info structure describing the devices
 526 *
 527 * Returns 0 on success or < 0 on error.
 528 */
 529static int mdiobus_create_device(struct mii_bus *bus,
 530				 struct mdio_board_info *bi)
 531{
 532	struct mdio_device *mdiodev;
 533	int ret = 0;
 534
 535	mdiodev = mdio_device_create(bus, bi->mdio_addr);
 536	if (IS_ERR(mdiodev))
 537		return -ENODEV;
 538
 539	strscpy(mdiodev->modalias, bi->modalias,
 540		sizeof(mdiodev->modalias));
 541	mdiodev->bus_match = mdio_device_bus_match;
 542	mdiodev->dev.platform_data = (void *)bi->platform_data;
 543
 544	ret = mdio_device_register(mdiodev);
 545	if (ret)
 546		mdio_device_free(mdiodev);
 547
 548	return ret;
 549}
 550
 551static struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr, bool c45)
 552{
 553	struct phy_device *phydev = ERR_PTR(-ENODEV);
 554	int err;
 555
 556	phydev = get_phy_device(bus, addr, c45);
 557	if (IS_ERR(phydev))
 558		return phydev;
 559
 560	/* For DT, see if the auto-probed phy has a corresponding child
 561	 * in the bus node, and set the of_node pointer in this case.
 562	 */
 563	of_mdiobus_link_mdiodev(bus, &phydev->mdio);
 564
 565	err = phy_device_register(phydev);
 566	if (err) {
 567		phy_device_free(phydev);
 568		return ERR_PTR(-ENODEV);
 569	}
 570
 571	return phydev;
 572}
 573
 574/**
 575 * mdiobus_scan_c22 - scan one address on a bus for C22 MDIO devices.
 576 * @bus: mii_bus to scan
 577 * @addr: address on bus to scan
 578 *
 579 * This function scans one address on the MDIO bus, looking for
 580 * devices which can be identified using a vendor/product ID in
 581 * registers 2 and 3. Not all MDIO devices have such registers, but
 582 * PHY devices typically do. Hence this function assumes anything
 583 * found is a PHY, or can be treated as a PHY. Other MDIO devices,
 584 * such as switches, will probably not be found during the scan.
 585 */
 586struct phy_device *mdiobus_scan_c22(struct mii_bus *bus, int addr)
 587{
 588	return mdiobus_scan(bus, addr, false);
 589}
 590EXPORT_SYMBOL(mdiobus_scan_c22);
 591
 592/**
 593 * mdiobus_scan_c45 - scan one address on a bus for C45 MDIO devices.
 594 * @bus: mii_bus to scan
 595 * @addr: address on bus to scan
 596 *
 597 * This function scans one address on the MDIO bus, looking for
 598 * devices which can be identified using a vendor/product ID in
 599 * registers 2 and 3. Not all MDIO devices have such registers, but
 600 * PHY devices typically do. Hence this function assumes anything
 601 * found is a PHY, or can be treated as a PHY. Other MDIO devices,
 602 * such as switches, will probably not be found during the scan.
 603 */
 604static struct phy_device *mdiobus_scan_c45(struct mii_bus *bus, int addr)
 605{
 606	return mdiobus_scan(bus, addr, true);
 607}
 608
 609static int mdiobus_scan_bus_c22(struct mii_bus *bus)
 610{
 611	int i;
 612
 613	for (i = 0; i < PHY_MAX_ADDR; i++) {
 614		if ((bus->phy_mask & BIT(i)) == 0) {
 615			struct phy_device *phydev;
 616
 617			phydev = mdiobus_scan_c22(bus, i);
 618			if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
 619				return PTR_ERR(phydev);
 620		}
 621	}
 622	return 0;
 623}
 624
 625static int mdiobus_scan_bus_c45(struct mii_bus *bus)
 626{
 627	int i;
 628
 629	for (i = 0; i < PHY_MAX_ADDR; i++) {
 630		if ((bus->phy_mask & BIT(i)) == 0) {
 631			struct phy_device *phydev;
 632
 633			/* Don't scan C45 if we already have a C22 device */
 634			if (bus->mdio_map[i])
 635				continue;
 636
 637			phydev = mdiobus_scan_c45(bus, i);
 638			if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
 639				return PTR_ERR(phydev);
 640		}
 641	}
 642	return 0;
 643}
 644
 645/* There are some C22 PHYs which do bad things when where is a C45
 646 * transaction on the bus, like accepting a read themselves, and
 647 * stomping over the true devices reply, to performing a write to
 648 * themselves which was intended for another device. Now that C22
 649 * devices have been found, see if any of them are bad for C45, and if we
 650 * should skip the C45 scan.
 651 */
 652static bool mdiobus_prevent_c45_scan(struct mii_bus *bus)
 653{
 654	int i;
 655
 656	for (i = 0; i < PHY_MAX_ADDR; i++) {
 657		struct phy_device *phydev;
 658		u32 oui;
 659
 660		phydev = mdiobus_get_phy(bus, i);
 661		if (!phydev)
 662			continue;
 663		oui = phydev->phy_id >> 10;
 664
 665		if (oui == MICREL_OUI)
 666			return true;
 667	}
 668	return false;
 669}
 670
 671/**
 672 * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
 673 * @bus: target mii_bus
 674 * @owner: module containing bus accessor functions
 675 *
 676 * Description: Called by a bus driver to bring up all the PHYs
 677 *   on a given bus, and attach them to the bus. Drivers should use
 678 *   mdiobus_register() rather than __mdiobus_register() unless they
 679 *   need to pass a specific owner module. MDIO devices which are not
 680 *   PHYs will not be brought up by this function. They are expected
 681 *   to be explicitly listed in DT and instantiated by of_mdiobus_register().
 682 *
 683 * Returns 0 on success or < 0 on error.
 684 */
 685int __mdiobus_register(struct mii_bus *bus, struct module *owner)
 686{
 687	struct mdio_device *mdiodev;
 688	struct gpio_desc *gpiod;
 689	bool prevent_c45_scan;
 690	int i, err;
 691
 692	if (!bus || !bus->name)
 693		return -EINVAL;
 694
 695	/* An access method always needs both read and write operations */
 696	if (!!bus->read != !!bus->write || !!bus->read_c45 != !!bus->write_c45)
 697		return -EINVAL;
 698
 699	/* At least one method is mandatory */
 700	if (!bus->read && !bus->read_c45)
 701		return -EINVAL;
 702
 703	if (bus->parent && bus->parent->of_node)
 704		bus->parent->of_node->fwnode.flags |=
 705					FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD;
 706
 707	WARN(bus->state != MDIOBUS_ALLOCATED &&
 708	     bus->state != MDIOBUS_UNREGISTERED,
 709	     "%s: not in ALLOCATED or UNREGISTERED state\n", bus->id);
 710
 711	bus->owner = owner;
 712	bus->dev.parent = bus->parent;
 713	bus->dev.class = &mdio_bus_class;
 714	bus->dev.groups = NULL;
 715	dev_set_name(&bus->dev, "%s", bus->id);
 716
 717	/* If the bus state is allocated, we're registering a fresh bus
 718	 * that may have a fwnode associated with it. Grab a reference
 719	 * to the fwnode. This will be dropped when the bus is released.
 720	 * If the bus was set to unregistered, it means that the bus was
 721	 * previously registered, and we've already grabbed a reference.
 722	 */
 723	if (bus->state == MDIOBUS_ALLOCATED)
 724		fwnode_handle_get(dev_fwnode(&bus->dev));
 725
 726	/* We need to set state to MDIOBUS_UNREGISTERED to correctly release
 727	 * the device in mdiobus_free()
 728	 *
 729	 * State will be updated later in this function in case of success
 730	 */
 731	bus->state = MDIOBUS_UNREGISTERED;
 732
 733	err = device_register(&bus->dev);
 734	if (err) {
 735		pr_err("mii_bus %s failed to register\n", bus->id);
 
 736		return -EINVAL;
 737	}
 738
 739	mutex_init(&bus->mdio_lock);
 740	mutex_init(&bus->shared_lock);
 741
 742	/* assert bus level PHY GPIO reset */
 743	gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_HIGH);
 744	if (IS_ERR(gpiod)) {
 745		err = dev_err_probe(&bus->dev, PTR_ERR(gpiod),
 746				    "mii_bus %s couldn't get reset GPIO\n",
 747				    bus->id);
 748		device_del(&bus->dev);
 749		return err;
 750	} else	if (gpiod) {
 751		bus->reset_gpiod = gpiod;
 752		fsleep(bus->reset_delay_us);
 753		gpiod_set_value_cansleep(gpiod, 0);
 754		if (bus->reset_post_delay_us > 0)
 755			fsleep(bus->reset_post_delay_us);
 756	}
 757
 758	if (bus->reset) {
 759		err = bus->reset(bus);
 760		if (err)
 761			goto error_reset_gpiod;
 762	}
 763
 764	if (bus->read) {
 765		err = mdiobus_scan_bus_c22(bus);
 766		if (err)
 767			goto error;
 768	}
 769
 770	prevent_c45_scan = mdiobus_prevent_c45_scan(bus);
 771
 772	if (!prevent_c45_scan && bus->read_c45) {
 773		err = mdiobus_scan_bus_c45(bus);
 774		if (err)
 775			goto error;
 
 
 776	}
 777
 778	mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
 779
 780	bus->state = MDIOBUS_REGISTERED;
 781	dev_dbg(&bus->dev, "probed\n");
 782	return 0;
 783
 784error:
 785	for (i = 0; i < PHY_MAX_ADDR; i++) {
 786		mdiodev = bus->mdio_map[i];
 787		if (!mdiodev)
 788			continue;
 789
 790		mdiodev->device_remove(mdiodev);
 791		mdiodev->device_free(mdiodev);
 792	}
 793error_reset_gpiod:
 794	/* Put PHYs in RESET to save power */
 795	if (bus->reset_gpiod)
 796		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
 797
 798	device_del(&bus->dev);
 799	return err;
 800}
 801EXPORT_SYMBOL(__mdiobus_register);
 802
 803void mdiobus_unregister(struct mii_bus *bus)
 804{
 805	struct mdio_device *mdiodev;
 806	int i;
 807
 808	if (WARN_ON_ONCE(bus->state != MDIOBUS_REGISTERED))
 809		return;
 810	bus->state = MDIOBUS_UNREGISTERED;
 811
 812	for (i = 0; i < PHY_MAX_ADDR; i++) {
 813		mdiodev = bus->mdio_map[i];
 814		if (!mdiodev)
 815			continue;
 816
 817		if (mdiodev->reset_gpio)
 818			gpiod_put(mdiodev->reset_gpio);
 819
 820		mdiodev->device_remove(mdiodev);
 821		mdiodev->device_free(mdiodev);
 822	}
 823
 824	/* Put PHYs in RESET to save power */
 825	if (bus->reset_gpiod)
 826		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
 827
 828	device_del(&bus->dev);
 829}
 830EXPORT_SYMBOL(mdiobus_unregister);
 831
 832/**
 833 * mdiobus_free - free a struct mii_bus
 834 * @bus: mii_bus to free
 835 *
 836 * This function releases the reference to the underlying device
 837 * object in the mii_bus.  If this is the last reference, the mii_bus
 838 * will be freed.
 839 */
 840void mdiobus_free(struct mii_bus *bus)
 841{
 842	/* For compatibility with error handling in drivers. */
 843	if (bus->state == MDIOBUS_ALLOCATED) {
 844		kfree(bus);
 845		return;
 846	}
 847
 848	WARN(bus->state != MDIOBUS_UNREGISTERED,
 849	     "%s: not in UNREGISTERED state\n", bus->id);
 850	bus->state = MDIOBUS_RELEASED;
 851
 852	put_device(&bus->dev);
 853}
 854EXPORT_SYMBOL(mdiobus_free);
 855
 856static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret)
 857{
 858	preempt_disable();
 859	u64_stats_update_begin(&stats->syncp);
 860
 861	u64_stats_inc(&stats->transfers);
 862	if (ret < 0) {
 863		u64_stats_inc(&stats->errors);
 864		goto out;
 865	}
 866
 867	if (op)
 868		u64_stats_inc(&stats->reads);
 869	else
 870		u64_stats_inc(&stats->writes);
 871out:
 872	u64_stats_update_end(&stats->syncp);
 873	preempt_enable();
 874}
 875
 876/**
 877 * __mdiobus_read - Unlocked version of the mdiobus_read function
 878 * @bus: the mii_bus struct
 879 * @addr: the phy address
 880 * @regnum: register number to read
 881 *
 882 * Read a MDIO bus register. Caller must hold the mdio bus lock.
 883 *
 884 * NOTE: MUST NOT be called from interrupt context.
 885 */
 886int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
 887{
 888	int retval;
 889
 890	lockdep_assert_held_once(&bus->mdio_lock);
 891
 892	if (bus->read)
 893		retval = bus->read(bus, addr, regnum);
 894	else
 895		retval = -EOPNOTSUPP;
 896
 897	trace_mdio_access(bus, 1, addr, regnum, retval, retval);
 898	mdiobus_stats_acct(&bus->stats[addr], true, retval);
 899
 900	return retval;
 901}
 902EXPORT_SYMBOL(__mdiobus_read);
 903
 904/**
 905 * __mdiobus_write - Unlocked version of the mdiobus_write function
 906 * @bus: the mii_bus struct
 907 * @addr: the phy address
 908 * @regnum: register number to write
 909 * @val: value to write to @regnum
 910 *
 911 * Write a MDIO bus register. Caller must hold the mdio bus lock.
 912 *
 913 * NOTE: MUST NOT be called from interrupt context.
 914 */
 915int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
 916{
 917	int err;
 918
 919	lockdep_assert_held_once(&bus->mdio_lock);
 920
 921	if (bus->write)
 922		err = bus->write(bus, addr, regnum, val);
 923	else
 924		err = -EOPNOTSUPP;
 925
 926	trace_mdio_access(bus, 0, addr, regnum, val, err);
 927	mdiobus_stats_acct(&bus->stats[addr], false, err);
 928
 929	return err;
 930}
 931EXPORT_SYMBOL(__mdiobus_write);
 932
 933/**
 934 * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function
 935 * @bus: the mii_bus struct
 936 * @addr: the phy address
 937 * @regnum: register number to modify
 938 * @mask: bit mask of bits to clear
 939 * @set: bit mask of bits to set
 940 *
 941 * Read, modify, and if any change, write the register value back to the
 942 * device. Any error returns a negative number.
 943 *
 944 * NOTE: MUST NOT be called from interrupt context.
 945 */
 946int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
 947			     u16 mask, u16 set)
 948{
 949	int new, ret;
 950
 951	ret = __mdiobus_read(bus, addr, regnum);
 952	if (ret < 0)
 953		return ret;
 954
 955	new = (ret & ~mask) | set;
 956	if (new == ret)
 957		return 0;
 958
 959	ret = __mdiobus_write(bus, addr, regnum, new);
 960
 961	return ret < 0 ? ret : 1;
 962}
 963EXPORT_SYMBOL_GPL(__mdiobus_modify_changed);
 964
 965/**
 966 * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function
 967 * @bus: the mii_bus struct
 968 * @addr: the phy address
 969 * @devad: device address to read
 970 * @regnum: register number to read
 971 *
 972 * Read a MDIO bus register. Caller must hold the mdio bus lock.
 973 *
 974 * NOTE: MUST NOT be called from interrupt context.
 975 */
 976int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
 977{
 978	int retval;
 979
 980	lockdep_assert_held_once(&bus->mdio_lock);
 981
 982	if (bus->read_c45)
 983		retval = bus->read_c45(bus, addr, devad, regnum);
 984	else
 985		retval = -EOPNOTSUPP;
 986
 987	trace_mdio_access(bus, 1, addr, regnum, retval, retval);
 988	mdiobus_stats_acct(&bus->stats[addr], true, retval);
 989
 990	return retval;
 991}
 992EXPORT_SYMBOL(__mdiobus_c45_read);
 993
 994/**
 995 * __mdiobus_c45_write - Unlocked version of the mdiobus_write function
 996 * @bus: the mii_bus struct
 997 * @addr: the phy address
 998 * @devad: device address to read
 999 * @regnum: register number to write
1000 * @val: value to write to @regnum
1001 *
1002 * Write a MDIO bus register. Caller must hold the mdio bus lock.
1003 *
1004 * NOTE: MUST NOT be called from interrupt context.
 
 
 
 
 
1005 */
1006int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1007			u16 val)
1008{
 
1009	int err;
1010
1011	lockdep_assert_held_once(&bus->mdio_lock);
1012
1013	if (bus->write_c45)
1014		err = bus->write_c45(bus, addr, devad, regnum, val);
1015	else
1016		err = -EOPNOTSUPP;
1017
1018	trace_mdio_access(bus, 0, addr, regnum, val, err);
1019	mdiobus_stats_acct(&bus->stats[addr], false, err);
1020
1021	return err;
1022}
1023EXPORT_SYMBOL(__mdiobus_c45_write);
1024
1025/**
1026 * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function
1027 * @bus: the mii_bus struct
1028 * @addr: the phy address
1029 * @devad: device address to read
1030 * @regnum: register number to modify
1031 * @mask: bit mask of bits to clear
1032 * @set: bit mask of bits to set
1033 *
1034 * Read, modify, and if any change, write the register value back to the
1035 * device. Any error returns a negative number.
1036 *
1037 * NOTE: MUST NOT be called from interrupt context.
1038 */
1039static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr,
1040					int devad, u32 regnum, u16 mask,
1041					u16 set)
1042{
1043	int new, ret;
1044
1045	ret = __mdiobus_c45_read(bus, addr, devad, regnum);
1046	if (ret < 0)
1047		return ret;
1048
1049	new = (ret & ~mask) | set;
1050	if (new == ret)
1051		return 0;
 
 
1052
1053	ret = __mdiobus_c45_write(bus, addr, devad, regnum, new);
 
 
 
 
1054
1055	return ret < 0 ? ret : 1;
1056}
 
1057
1058/**
1059 * mdiobus_read_nested - Nested version of the mdiobus_read function
1060 * @bus: the mii_bus struct
1061 * @addr: the phy address
1062 * @regnum: register number to read
1063 *
1064 * In case of nested MDIO bus access avoid lockdep false positives by
1065 * using mutex_lock_nested().
1066 *
1067 * NOTE: MUST NOT be called from interrupt context,
1068 * because the bus read/write functions may wait for an interrupt
1069 * to conclude the operation.
1070 */
1071int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
1072{
1073	int retval;
1074
1075	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1076	retval = __mdiobus_read(bus, addr, regnum);
 
 
1077	mutex_unlock(&bus->mdio_lock);
1078
1079	return retval;
1080}
1081EXPORT_SYMBOL(mdiobus_read_nested);
1082
1083/**
1084 * mdiobus_read - Convenience function for reading a given MII mgmt register
1085 * @bus: the mii_bus struct
1086 * @addr: the phy address
1087 * @regnum: register number to read
1088 *
1089 * NOTE: MUST NOT be called from interrupt context,
1090 * because the bus read/write functions may wait for an interrupt
1091 * to conclude the operation.
1092 */
1093int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
1094{
1095	int retval;
1096
1097	mutex_lock(&bus->mdio_lock);
1098	retval = __mdiobus_read(bus, addr, regnum);
1099	mutex_unlock(&bus->mdio_lock);
1100
1101	return retval;
1102}
1103EXPORT_SYMBOL(mdiobus_read);
1104
1105/**
1106 * mdiobus_c45_read - Convenience function for reading a given MII mgmt register
1107 * @bus: the mii_bus struct
1108 * @addr: the phy address
1109 * @devad: device address to read
1110 * @regnum: register number to read
1111 *
1112 * NOTE: MUST NOT be called from interrupt context,
1113 * because the bus read/write functions may wait for an interrupt
1114 * to conclude the operation.
1115 */
1116int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
1117{
1118	int retval;
1119
1120	mutex_lock(&bus->mdio_lock);
1121	retval = __mdiobus_c45_read(bus, addr, devad, regnum);
1122	mutex_unlock(&bus->mdio_lock);
1123
1124	return retval;
1125}
1126EXPORT_SYMBOL(mdiobus_c45_read);
1127
1128/**
1129 * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function
1130 * @bus: the mii_bus struct
1131 * @addr: the phy address
1132 * @devad: device address to read
1133 * @regnum: register number to read
1134 *
1135 * In case of nested MDIO bus access avoid lockdep false positives by
1136 * using mutex_lock_nested().
1137 *
1138 * NOTE: MUST NOT be called from interrupt context,
1139 * because the bus read/write functions may wait for an interrupt
1140 * to conclude the operation.
1141 */
1142int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad,
1143			    u32 regnum)
1144{
1145	int retval;
1146
1147	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1148	retval = __mdiobus_c45_read(bus, addr, devad, regnum);
1149	mutex_unlock(&bus->mdio_lock);
1150
1151	return retval;
1152}
1153EXPORT_SYMBOL(mdiobus_c45_read_nested);
1154
1155/**
1156 * mdiobus_write_nested - Nested version of the mdiobus_write function
1157 * @bus: the mii_bus struct
1158 * @addr: the phy address
1159 * @regnum: register number to write
1160 * @val: value to write to @regnum
1161 *
1162 * In case of nested MDIO bus access avoid lockdep false positives by
1163 * using mutex_lock_nested().
1164 *
1165 * NOTE: MUST NOT be called from interrupt context,
1166 * because the bus read/write functions may wait for an interrupt
1167 * to conclude the operation.
1168 */
1169int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1170{
1171	int err;
1172
1173	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1174	err = __mdiobus_write(bus, addr, regnum, val);
 
 
1175	mutex_unlock(&bus->mdio_lock);
1176
1177	return err;
1178}
1179EXPORT_SYMBOL(mdiobus_write_nested);
1180
1181/**
1182 * mdiobus_write - Convenience function for writing a given MII mgmt register
1183 * @bus: the mii_bus struct
1184 * @addr: the phy address
1185 * @regnum: register number to write
1186 * @val: value to write to @regnum
1187 *
1188 * NOTE: MUST NOT be called from interrupt context,
1189 * because the bus read/write functions may wait for an interrupt
1190 * to conclude the operation.
1191 */
1192int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1193{
1194	int err;
1195
1196	mutex_lock(&bus->mdio_lock);
1197	err = __mdiobus_write(bus, addr, regnum, val);
1198	mutex_unlock(&bus->mdio_lock);
1199
1200	return err;
1201}
1202EXPORT_SYMBOL(mdiobus_write);
1203
1204/**
1205 * mdiobus_c45_write - Convenience function for writing a given MII mgmt register
1206 * @bus: the mii_bus struct
1207 * @addr: the phy address
1208 * @devad: device address to read
1209 * @regnum: register number to write
1210 * @val: value to write to @regnum
1211 *
1212 * NOTE: MUST NOT be called from interrupt context,
1213 * because the bus read/write functions may wait for an interrupt
1214 * to conclude the operation.
1215 */
1216int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1217		      u16 val)
1218{
1219	int err;
1220
1221	mutex_lock(&bus->mdio_lock);
1222	err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
1223	mutex_unlock(&bus->mdio_lock);
1224
1225	return err;
1226}
1227EXPORT_SYMBOL(mdiobus_c45_write);
1228
1229/**
1230 * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function
1231 * @bus: the mii_bus struct
1232 * @addr: the phy address
1233 * @devad: device address to read
1234 * @regnum: register number to write
1235 * @val: value to write to @regnum
1236 *
1237 * In case of nested MDIO bus access avoid lockdep false positives by
1238 * using mutex_lock_nested().
1239 *
1240 * NOTE: MUST NOT be called from interrupt context,
1241 * because the bus read/write functions may wait for an interrupt
1242 * to conclude the operation.
1243 */
1244int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad,
1245			     u32 regnum, u16 val)
1246{
1247	int err;
1248
1249	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1250	err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
1251	mutex_unlock(&bus->mdio_lock);
1252
1253	return err;
1254}
1255EXPORT_SYMBOL(mdiobus_c45_write_nested);
1256
1257/*
1258 * __mdiobus_modify - Convenience function for modifying a given mdio device
1259 *	register
1260 * @bus: the mii_bus struct
1261 * @addr: the phy address
1262 * @regnum: register number to write
1263 * @mask: bit mask of bits to clear
1264 * @set: bit mask of bits to set
1265 */
1266int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
1267		     u16 set)
1268{
1269	int err;
1270
1271	err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1272
1273	return err < 0 ? err : 0;
1274}
1275EXPORT_SYMBOL_GPL(__mdiobus_modify);
1276
1277/**
1278 * mdiobus_modify - Convenience function for modifying a given mdio device
1279 *	register
1280 * @bus: the mii_bus struct
1281 * @addr: the phy address
1282 * @regnum: register number to write
1283 * @mask: bit mask of bits to clear
1284 * @set: bit mask of bits to set
1285 */
1286int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)
1287{
1288	int err;
1289
1290	mutex_lock(&bus->mdio_lock);
1291	err = __mdiobus_modify(bus, addr, regnum, mask, set);
1292	mutex_unlock(&bus->mdio_lock);
1293
1294	return err;
1295}
1296EXPORT_SYMBOL_GPL(mdiobus_modify);
1297
1298/**
1299 * mdiobus_c45_modify - Convenience function for modifying a given mdio device
1300 *	register
1301 * @bus: the mii_bus struct
1302 * @addr: the phy address
1303 * @devad: device address to read
1304 * @regnum: register number to write
1305 * @mask: bit mask of bits to clear
1306 * @set: bit mask of bits to set
1307 */
1308int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum,
1309		       u16 mask, u16 set)
1310{
1311	int err;
1312
1313	mutex_lock(&bus->mdio_lock);
1314	err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum,
1315					   mask, set);
1316	mutex_unlock(&bus->mdio_lock);
1317
1318	return err < 0 ? err : 0;
1319}
1320EXPORT_SYMBOL_GPL(mdiobus_c45_modify);
1321
1322/**
1323 * mdiobus_modify_changed - Convenience function for modifying a given mdio
1324 *	device register and returning if it changed
1325 * @bus: the mii_bus struct
1326 * @addr: the phy address
1327 * @regnum: register number to write
1328 * @mask: bit mask of bits to clear
1329 * @set: bit mask of bits to set
1330 */
1331int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
1332			   u16 mask, u16 set)
1333{
1334	int err;
1335
1336	mutex_lock(&bus->mdio_lock);
1337	err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1338	mutex_unlock(&bus->mdio_lock);
1339
1340	return err;
1341}
1342EXPORT_SYMBOL_GPL(mdiobus_modify_changed);
1343
1344/**
1345 * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio
1346 *	device register and returning if it changed
1347 * @bus: the mii_bus struct
1348 * @addr: the phy address
1349 * @devad: device address to read
1350 * @regnum: register number to write
1351 * @mask: bit mask of bits to clear
1352 * @set: bit mask of bits to set
1353 */
1354int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad,
1355			       u32 regnum, u16 mask, u16 set)
1356{
1357	int err;
1358
1359	mutex_lock(&bus->mdio_lock);
1360	err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set);
1361	mutex_unlock(&bus->mdio_lock);
1362
1363	return err;
1364}
1365EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
1366
1367/**
1368 * mdio_bus_match - determine if given MDIO driver supports the given
1369 *		    MDIO device
1370 * @dev: target MDIO device
1371 * @drv: given MDIO driver
1372 *
1373 * Description: Given a MDIO device, and a MDIO driver, return 1 if
1374 *   the driver supports the device.  Otherwise, return 0. This may
1375 *   require calling the devices own match function, since different classes
1376 *   of MDIO devices have different match criteria.
1377 */
1378static int mdio_bus_match(struct device *dev, const struct device_driver *drv)
1379{
1380	const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
1381	struct mdio_device *mdio = to_mdio_device(dev);
1382
1383	/* Both the driver and device must type-match */
1384	if (!(mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) !=
1385	    !(mdio->flags & MDIO_DEVICE_FLAG_PHY))
1386		return 0;
1387
1388	if (of_driver_match_device(dev, drv))
1389		return 1;
1390
1391	if (mdio->bus_match)
1392		return mdio->bus_match(dev, drv);
1393
1394	return 0;
1395}
1396
1397static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env)
 
1398{
1399	int rc;
1400
1401	/* Some devices have extra OF data and an OF-style MODALIAS */
1402	rc = of_device_uevent_modalias(dev, env);
1403	if (rc != -ENODEV)
1404		return rc;
1405
1406	return 0;
1407}
1408
1409static struct attribute *mdio_bus_device_statistics_attrs[] = {
1410	&dev_attr_mdio_bus_device_transfers.attr.attr,
1411	&dev_attr_mdio_bus_device_errors.attr.attr,
1412	&dev_attr_mdio_bus_device_writes.attr.attr,
1413	&dev_attr_mdio_bus_device_reads.attr.attr,
1414	NULL,
1415};
1416
1417static const struct attribute_group mdio_bus_device_statistics_group = {
1418	.name	= "statistics",
1419	.attrs	= mdio_bus_device_statistics_attrs,
1420};
1421
1422static const struct attribute_group *mdio_bus_dev_groups[] = {
1423	&mdio_bus_device_statistics_group,
1424	NULL,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1425};
1426
1427const struct bus_type mdio_bus_type = {
 
 
 
 
 
 
 
 
1428	.name		= "mdio_bus",
1429	.dev_groups	= mdio_bus_dev_groups,
1430	.match		= mdio_bus_match,
1431	.uevent		= mdio_uevent,
1432};
1433EXPORT_SYMBOL(mdio_bus_type);
1434
1435int __init mdio_bus_init(void)
1436{
1437	int ret;
1438
1439	ret = class_register(&mdio_bus_class);
1440	if (!ret) {
1441		ret = bus_register(&mdio_bus_type);
1442		if (ret)
1443			class_unregister(&mdio_bus_class);
1444	}
1445
1446	return ret;
1447}
1448
1449#if IS_ENABLED(CONFIG_PHYLIB)
1450void mdio_bus_exit(void)
1451{
1452	class_unregister(&mdio_bus_class);
1453	bus_unregister(&mdio_bus_type);
1454}
1455EXPORT_SYMBOL_GPL(mdio_bus_exit);
1456#else
1457module_init(mdio_bus_init);
1458/* no module_exit, intentional */
1459MODULE_LICENSE("GPL");
1460MODULE_DESCRIPTION("MDIO bus/device layer");
1461#endif