mdio_bus.c 18.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
S
Sergei Shtylyov 已提交
2
/* MDIO Bus interface
3 4 5 6 7
 *
 * Author: Andy Fleming
 *
 * Copyright (c) 2004 Freescale Semiconductor, Inc.
 */
J
Joe Perches 已提交
8 9 10

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

11 12 13 14 15 16 17 18
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/unistd.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/delay.h>
19
#include <linux/device.h>
20 21
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
22
#include <linux/of_device.h>
23
#include <linux/of_mdio.h>
24
#include <linux/of_gpio.h>
25 26
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
27
#include <linux/reset.h>
28 29 30 31 32 33 34
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/phy.h>
S
Sergei Shtylyov 已提交
35 36
#include <linux/io.h>
#include <linux/uaccess.h>
37

38 39 40
#define CREATE_TRACE_POINTS
#include <trace/events/mdio.h>

41 42
#include "mdio-boardinfo.h"

43
static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
44
{
45
	int error;
46 47

	/* Deassert the optional reset signal */
48 49 50 51 52 53 54 55
	mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
						 "reset", GPIOD_OUT_LOW);
	error = PTR_ERR_OR_ZERO(mdiodev->reset_gpio);
	if (error)
		return error;

	if (mdiodev->reset_gpio)
		gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
56

57 58 59 60 61 62 63 64 65 66
	return 0;
}

static int mdiobus_register_reset(struct mdio_device *mdiodev)
{
	struct reset_control *reset = NULL;

	if (mdiodev->dev.of_node)
		reset = devm_reset_control_get_exclusive(&mdiodev->dev,
							 "phy");
67
	if (IS_ERR(reset)) {
68
		if (PTR_ERR(reset) == -ENOENT || PTR_ERR(reset) == -ENOTSUPP)
69 70 71 72
			reset = NULL;
		else
			return PTR_ERR(reset);
	}
73 74

	mdiodev->reset_ctrl = reset;
75

76 77 78 79 80 81 82 83 84 85 86 87 88 89
	return 0;
}

int mdiobus_register_device(struct mdio_device *mdiodev)
{
	int err;

	if (mdiodev->bus->mdio_map[mdiodev->addr])
		return -EBUSY;

	if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
		err = mdiobus_register_gpiod(mdiodev);
		if (err)
			return err;
90 91 92 93 94 95 96

		err = mdiobus_register_reset(mdiodev);
		if (err)
			return err;

		/* Assert the reset signal */
		mdio_device_reset(mdiodev, 1);
97 98
	}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;

	return 0;
}
EXPORT_SYMBOL(mdiobus_register_device);

int mdiobus_unregister_device(struct mdio_device *mdiodev)
{
	if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
		return -EINVAL;

	mdiodev->bus->mdio_map[mdiodev->addr] = NULL;

	return 0;
}
EXPORT_SYMBOL(mdiobus_unregister_device);

struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
{
	struct mdio_device *mdiodev = bus->mdio_map[addr];

	if (!mdiodev)
		return NULL;

	if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
		return NULL;

	return container_of(mdiodev, struct phy_device, mdio);
}
EXPORT_SYMBOL(mdiobus_get_phy);

bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
{
	return bus->mdio_map[addr];
}
EXPORT_SYMBOL(mdiobus_is_registered_device);

136
/**
137
 * mdiobus_alloc_size - allocate a mii_bus structure
138 139
 * @size: extra amount of memory to allocate for private storage.
 * If non-zero, then bus->priv is points to that memory.
140 141 142 143
 *
 * Description: called by a bus driver to allocate an mii_bus
 * structure to fill in.
 */
144
struct mii_bus *mdiobus_alloc_size(size_t size)
145
{
146
	struct mii_bus *bus;
147 148
	size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
	size_t alloc_size;
149
	int i;
150 151 152 153 154 155

	/* If we alloc extra space, it should be aligned */
	if (size)
		alloc_size = aligned_size + size;
	else
		alloc_size = sizeof(*bus);
156

157
	bus = kzalloc(alloc_size, GFP_KERNEL);
158 159 160 161 162 163
	if (!bus)
		return NULL;

	bus->state = MDIOBUS_ALLOCATED;
	if (size)
		bus->priv = (void *)bus + aligned_size;
164

165 166 167 168
	/* Initialise the interrupts to polling */
	for (i = 0; i < PHY_MAX_ADDR; i++)
		bus->irq[i] = PHY_POLL;

169
	return bus;
170
}
171
EXPORT_SYMBOL(mdiobus_alloc_size);
172

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
static void _devm_mdiobus_free(struct device *dev, void *res)
{
	mdiobus_free(*(struct mii_bus **)res);
}

static int devm_mdiobus_match(struct device *dev, void *res, void *data)
{
	struct mii_bus **r = res;

	if (WARN_ON(!r || !*r))
		return 0;

	return *r == data;
}

/**
 * devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size()
 * @dev:		Device to allocate mii_bus for
 * @sizeof_priv:	Space to allocate for private structure.
 *
 * Managed mdiobus_alloc_size. mii_bus allocated with this function is
 * automatically freed on driver detach.
 *
 * If an mii_bus allocated with this function needs to be freed separately,
 * devm_mdiobus_free() must be used.
 *
 * RETURNS:
 * Pointer to allocated mii_bus on success, NULL on failure.
 */
struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
{
	struct mii_bus **ptr, *bus;

	ptr = devres_alloc(_devm_mdiobus_free, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return NULL;

	/* use raw alloc_dr for kmalloc caller tracing */
	bus = mdiobus_alloc_size(sizeof_priv);
	if (bus) {
		*ptr = bus;
		devres_add(dev, ptr);
	} else {
		devres_free(ptr);
	}

	return bus;
}
221
EXPORT_SYMBOL_GPL(devm_mdiobus_alloc_size);
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239

/**
 * devm_mdiobus_free - Resource-managed mdiobus_free()
 * @dev:		Device this mii_bus belongs to
 * @bus:		the mii_bus associated with the device
 *
 * Free mii_bus allocated with devm_mdiobus_alloc_size().
 */
void devm_mdiobus_free(struct device *dev, struct mii_bus *bus)
{
	int rc;

	rc = devres_release(dev, _devm_mdiobus_free,
			    devm_mdiobus_match, bus);
	WARN_ON(rc);
}
EXPORT_SYMBOL_GPL(devm_mdiobus_free);

240 241
/**
 * mdiobus_release - mii_bus device release callback
R
Randy Dunlap 已提交
242
 * @d: the target struct device that contains the mii_bus
243 244 245 246 247 248 249
 *
 * Description: called when the last reference to an mii_bus is
 * dropped, to free the underlying memory.
 */
static void mdiobus_release(struct device *d)
{
	struct mii_bus *bus = to_mii_bus(d);
K
Krzysztof Halasa 已提交
250 251 252
	BUG_ON(bus->state != MDIOBUS_RELEASED &&
	       /* for compatibility with error handling in drivers */
	       bus->state != MDIOBUS_ALLOCATED);
253 254 255 256 257 258 259 260
	kfree(bus);
}

static struct class mdio_bus_class = {
	.name		= "mdio_bus",
	.dev_release	= mdiobus_release,
};

261
#if IS_ENABLED(CONFIG_OF_MDIO)
262 263
/**
 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
264
 * @mdio_bus_np: Pointer to the mii_bus.
265
 *
266 267 268
 * Returns a reference to the mii_bus, or NULL if none found.  The
 * embedded struct device will have its reference count incremented,
 * and this must be put once the bus is finished with.
269 270 271 272 273 274 275 276 277 278 279 280 281
 *
 * Because the association of a device_node and mii_bus is made via
 * of_mdiobus_register(), the mii_bus cannot be found before it is
 * registered with of_mdiobus_register().
 *
 */
struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
{
	struct device *d;

	if (!mdio_bus_np)
		return NULL;

282
	d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
283 284 285
	return d ? to_mii_bus(d) : NULL;
}
EXPORT_SYMBOL(of_mdio_find_bus);
286

287 288 289 290 291
/* Walk the list of subnodes of a mdio bus and look for a node that
 * matches the mdio device's address with its 'reg' property. If
 * found, set the of_node pointer for the mdio device. This allows
 * auto-probed phy devices to be supplied with information passed in
 * via DT.
292
 */
293 294
static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
				    struct mdio_device *mdiodev)
295
{
296
	struct device *dev = &mdiodev->dev;
297 298
	struct device_node *child;

A
Andrew Lunn 已提交
299
	if (dev->of_node || !bus->dev.of_node)
300 301
		return;

A
Andrew Lunn 已提交
302
	for_each_available_child_of_node(bus->dev.of_node, child) {
303 304
		int addr;

J
Jon Mason 已提交
305 306
		addr = of_mdio_parse_addr(dev, child);
		if (addr < 0)
307 308
			continue;

309
		if (addr == mdiodev->addr) {
310
			dev->of_node = child;
311
			dev->fwnode = of_fwnode_handle(child);
312 313 314 315 316
			return;
		}
	}
}
#else /* !IS_ENABLED(CONFIG_OF_MDIO) */
317 318
static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
					   struct mdio_device *mdiodev)
319 320
{
}
321 322
#endif

323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
/**
 * mdiobus_create_device_from_board_info - create a full MDIO device given
 * a mdio_board_info structure
 * @bus: MDIO bus to create the devices on
 * @bi: mdio_board_info structure describing the devices
 *
 * Returns 0 on success or < 0 on error.
 */
static int mdiobus_create_device(struct mii_bus *bus,
				 struct mdio_board_info *bi)
{
	struct mdio_device *mdiodev;
	int ret = 0;

	mdiodev = mdio_device_create(bus, bi->mdio_addr);
	if (IS_ERR(mdiodev))
		return -ENODEV;

	strncpy(mdiodev->modalias, bi->modalias,
		sizeof(mdiodev->modalias));
	mdiodev->bus_match = mdio_device_bus_match;
	mdiodev->dev.platform_data = (void *)bi->platform_data;

	ret = mdio_device_register(mdiodev);
	if (ret)
		mdio_device_free(mdiodev);

	return ret;
}

353
/**
354
 * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
355
 * @bus: target mii_bus
356
 * @owner: module containing bus accessor functions
A
Andy Fleming 已提交
357
 *
358
 * Description: Called by a bus driver to bring up all the PHYs
359 360
 *   on a given bus, and attach them to the bus. Drivers should use
 *   mdiobus_register() rather than __mdiobus_register() unless they
361 362 363
 *   need to pass a specific owner module. MDIO devices which are not
 *   PHYs will not be brought up by this function. They are expected to
 *   to be explicitly listed in DT and instantiated by of_mdiobus_register().
364 365
 *
 * Returns 0 on success or < 0 on error.
A
Andy Fleming 已提交
366
 */
R
Russell King 已提交
367
int __mdiobus_register(struct mii_bus *bus, struct module *owner)
A
Andy Fleming 已提交
368
{
369
	struct mdio_device *mdiodev;
K
Krzysztof Halasa 已提交
370
	int i, err;
371
	struct gpio_desc *gpiod;
A
Andy Fleming 已提交
372 373

	if (NULL == bus || NULL == bus->name ||
S
Sergei Shtylyov 已提交
374
	    NULL == bus->read || NULL == bus->write)
A
Andy Fleming 已提交
375 376
		return -EINVAL;

377 378 379
	BUG_ON(bus->state != MDIOBUS_ALLOCATED &&
	       bus->state != MDIOBUS_UNREGISTERED);

R
Russell King 已提交
380
	bus->owner = owner;
381 382 383
	bus->dev.parent = bus->parent;
	bus->dev.class = &mdio_bus_class;
	bus->dev.groups = NULL;
384
	dev_set_name(&bus->dev, "%s", bus->id);
385 386 387

	err = device_register(&bus->dev);
	if (err) {
J
Joe Perches 已提交
388
		pr_err("mii_bus %s failed to register\n", bus->id);
389 390 391
		return -EINVAL;
	}

392 393
	mutex_init(&bus->mdio_lock);

394
	/* de-assert bus level PHY GPIO reset */
395
	gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_LOW);
396
	if (IS_ERR(gpiod)) {
397 398
		dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n",
			bus->id);
399
		device_del(&bus->dev);
400 401
		return PTR_ERR(gpiod);
	} else	if (gpiod) {
402 403 404 405 406
		bus->reset_gpiod = gpiod;

		gpiod_set_value_cansleep(gpiod, 1);
		udelay(bus->reset_delay_us);
		gpiod_set_value_cansleep(gpiod, 0);
407 408
	}

409 410 411
	if (bus->reset)
		bus->reset(bus);

A
Andy Fleming 已提交
412
	for (i = 0; i < PHY_MAX_ADDR; i++) {
413 414
		if ((bus->phy_mask & (1 << i)) == 0) {
			struct phy_device *phydev;
A
Andy Fleming 已提交
415

416
			phydev = mdiobus_scan(bus, i);
417
			if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV)) {
418
				err = PTR_ERR(phydev);
K
Krzysztof Halasa 已提交
419 420
				goto error;
			}
421
		}
A
Andy Fleming 已提交
422 423
	}

424
	mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
425

K
Krzysztof Halasa 已提交
426
	bus->state = MDIOBUS_REGISTERED;
A
Andy Fleming 已提交
427
	pr_info("%s: probed\n", bus->name);
K
Krzysztof Halasa 已提交
428
	return 0;
A
Andy Fleming 已提交
429

K
Krzysztof Halasa 已提交
430 431
error:
	while (--i >= 0) {
432 433 434 435 436 437
		mdiodev = bus->mdio_map[i];
		if (!mdiodev)
			continue;

		mdiodev->device_remove(mdiodev);
		mdiodev->device_free(mdiodev);
K
Krzysztof Halasa 已提交
438
	}
439 440

	/* Put PHYs in RESET to save power */
441 442
	if (bus->reset_gpiod)
		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
443

K
Krzysztof Halasa 已提交
444
	device_del(&bus->dev);
A
Andy Fleming 已提交
445 446
	return err;
}
R
Russell King 已提交
447
EXPORT_SYMBOL(__mdiobus_register);
A
Andy Fleming 已提交
448 449 450

void mdiobus_unregister(struct mii_bus *bus)
{
451
	struct mdio_device *mdiodev;
A
Andy Fleming 已提交
452 453
	int i;

454 455 456
	BUG_ON(bus->state != MDIOBUS_REGISTERED);
	bus->state = MDIOBUS_UNREGISTERED;

A
Andy Fleming 已提交
457
	for (i = 0; i < PHY_MAX_ADDR; i++) {
458 459 460 461
		mdiodev = bus->mdio_map[i];
		if (!mdiodev)
			continue;

462 463
		if (mdiodev->reset_gpio)
			gpiod_put(mdiodev->reset_gpio);
464

465 466
		mdiodev->device_remove(mdiodev);
		mdiodev->device_free(mdiodev);
A
Andy Fleming 已提交
467
	}
468 469

	/* Put PHYs in RESET to save power */
470 471
	if (bus->reset_gpiod)
		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
472

473
	device_del(&bus->dev);
A
Andy Fleming 已提交
474 475 476
}
EXPORT_SYMBOL(mdiobus_unregister);

477 478 479 480
/**
 * mdiobus_free - free a struct mii_bus
 * @bus: mii_bus to free
 *
481 482 483
 * This function releases the reference to the underlying device
 * object in the mii_bus.  If this is the last reference, the mii_bus
 * will be freed.
484 485 486
 */
void mdiobus_free(struct mii_bus *bus)
{
S
Sergei Shtylyov 已提交
487
	/* For compatibility with error handling in drivers. */
488 489 490 491 492 493 494 495 496
	if (bus->state == MDIOBUS_ALLOCATED) {
		kfree(bus);
		return;
	}

	BUG_ON(bus->state != MDIOBUS_UNREGISTERED);
	bus->state = MDIOBUS_RELEASED;

	put_device(&bus->dev);
497 498 499
}
EXPORT_SYMBOL(mdiobus_free);

500 501 502 503 504 505 506 507 508 509 510 511
/**
 * mdiobus_scan - scan a bus for MDIO devices.
 * @bus: mii_bus to scan
 * @addr: address on bus to scan
 *
 * This function scans the MDIO bus, looking for devices which can be
 * identified using a vendor/product ID in registers 2 and 3. Not all
 * MDIO devices have such registers, but PHY devices typically
 * do. Hence this function assumes anything found is a PHY, or can be
 * treated as a PHY. Other MDIO devices, such as switches, will
 * probably not be found during the scan.
 */
512 513 514 515 516
struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr)
{
	struct phy_device *phydev;
	int err;

517
	phydev = get_phy_device(bus, addr, false);
518
	if (IS_ERR(phydev))
519 520
		return phydev;

521 522 523 524
	/*
	 * For DT, see if the auto-probed phy has a correspoding child
	 * in the bus node, and set the of_node pointer in this case.
	 */
525
	of_mdiobus_link_mdiodev(bus, &phydev->mdio);
526

527
	err = phy_device_register(phydev);
528 529
	if (err) {
		phy_device_free(phydev);
530
		return ERR_PTR(-ENODEV);
531 532 533 534 535 536
	}

	return phydev;
}
EXPORT_SYMBOL(mdiobus_scan);

537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
/**
 * __mdiobus_read - Unlocked version of the mdiobus_read function
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to read
 *
 * Read a MDIO bus register. Caller must hold the mdio bus lock.
 *
 * NOTE: MUST NOT be called from interrupt context.
 */
int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
{
	int retval;

	WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));

	retval = bus->read(bus, addr, regnum);

	trace_mdio_access(bus, 1, addr, regnum, retval, retval);

	return retval;
}
EXPORT_SYMBOL(__mdiobus_read);

/**
 * __mdiobus_write - Unlocked version of the mdiobus_write function
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * Write a MDIO bus register. Caller must hold the mdio bus lock.
 *
 * NOTE: MUST NOT be called from interrupt context.
 */
int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
{
	int err;

	WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));

	err = bus->write(bus, addr, regnum, val);

	trace_mdio_access(bus, 0, addr, regnum, val, err);

	return err;
}
EXPORT_SYMBOL(__mdiobus_write);

586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
/**
 * mdiobus_read_nested - Nested version of the mdiobus_read function
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to read
 *
 * In case of nested MDIO bus access avoid lockdep false positives by
 * using mutex_lock_nested().
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
{
	int retval;

	BUG_ON(in_interrupt());

605
	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
606
	retval = __mdiobus_read(bus, addr, regnum);
607 608 609 610 611 612
	mutex_unlock(&bus->mdio_lock);

	return retval;
}
EXPORT_SYMBOL(mdiobus_read_nested);

613 614 615 616 617 618 619 620 621 622
/**
 * mdiobus_read - Convenience function for reading a given MII mgmt register
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to read
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
623
int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
624 625 626 627 628 629
{
	int retval;

	BUG_ON(in_interrupt());

	mutex_lock(&bus->mdio_lock);
630
	retval = __mdiobus_read(bus, addr, regnum);
631 632 633 634 635 636
	mutex_unlock(&bus->mdio_lock);

	return retval;
}
EXPORT_SYMBOL(mdiobus_read);

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
/**
 * mdiobus_write_nested - Nested version of the mdiobus_write function
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * In case of nested MDIO bus access avoid lockdep false positives by
 * using mutex_lock_nested().
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
{
	int err;

	BUG_ON(in_interrupt());

657
	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
658
	err = __mdiobus_write(bus, addr, regnum, val);
659 660 661 662 663 664
	mutex_unlock(&bus->mdio_lock);

	return err;
}
EXPORT_SYMBOL(mdiobus_write_nested);

665 666 667 668 669 670 671 672 673 674 675
/**
 * mdiobus_write - Convenience function for writing a given MII mgmt register
 * @bus: the mii_bus struct
 * @addr: the phy address
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
676
int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
677 678 679 680 681 682
{
	int err;

	BUG_ON(in_interrupt());

	mutex_lock(&bus->mdio_lock);
683
	err = __mdiobus_write(bus, addr, regnum, val);
684 685 686 687 688 689
	mutex_unlock(&bus->mdio_lock);

	return err;
}
EXPORT_SYMBOL(mdiobus_write);

690
/**
691 692 693 694
 * mdio_bus_match - determine if given MDIO driver supports the given
 *		    MDIO device
 * @dev: target MDIO device
 * @drv: given MDIO driver
695
 *
696 697 698 699
 * Description: Given a MDIO device, and a MDIO driver, return 1 if
 *   the driver supports the device.  Otherwise, return 0. This may
 *   require calling the devices own match function, since different classes
 *   of MDIO devices have different match criteria.
700 701 702
 */
static int mdio_bus_match(struct device *dev, struct device_driver *drv)
{
703
	struct mdio_device *mdio = to_mdio_device(dev);
704

705 706 707
	if (of_driver_match_device(dev, drv))
		return 1;

708 709
	if (mdio->bus_match)
		return mdio->bus_match(dev, drv);
710

711
	return 0;
712 713
}

714 715 716 717 718 719 720 721 722 723 724 725
static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	int rc;

	/* Some devices have extra OF data and an OF-style MODALIAS */
	rc = of_device_uevent_modalias(dev, env);
	if (rc != -ENODEV)
		return rc;

	return 0;
}

726 727 728
struct bus_type mdio_bus_type = {
	.name		= "mdio_bus",
	.match		= mdio_bus_match,
729
	.uevent		= mdio_uevent,
730
};
731
EXPORT_SYMBOL(mdio_bus_type);
732

733
int __init mdio_bus_init(void)
734
{
735 736 737 738 739 740 741 742 743 744
	int ret;

	ret = class_register(&mdio_bus_class);
	if (!ret) {
		ret = bus_register(&mdio_bus_type);
		if (ret)
			class_unregister(&mdio_bus_class);
	}

	return ret;
745
}
746
EXPORT_SYMBOL_GPL(mdio_bus_init);
747

748
#if IS_ENABLED(CONFIG_PHYLIB)
749
void mdio_bus_exit(void)
A
Andy Fleming 已提交
750
{
751
	class_unregister(&mdio_bus_class);
A
Andy Fleming 已提交
752 753
	bus_unregister(&mdio_bus_type);
}
754 755 756 757 758 759 760
EXPORT_SYMBOL_GPL(mdio_bus_exit);
#else
module_init(mdio_bus_init);
/* no module_exit, intentional */
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MDIO bus/device layer");
#endif