1// SPDX-License-Identifier: GPL-2.0+
  2/* Framework for MDIO devices, other than PHYs.
  3 *
  4 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
  5 */
  6
  7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8
  9#include <linux/delay.h>
 10#include <linux/errno.h>
 11#include <linux/gpio.h>
 12#include <linux/gpio/consumer.h>
 13#include <linux/init.h>
 14#include <linux/interrupt.h>
 15#include <linux/kernel.h>
 16#include <linux/mdio.h>
 17#include <linux/mii.h>
 18#include <linux/module.h>
 19#include <linux/phy.h>
 20#include <linux/reset.h>
 21#include <linux/slab.h>
 22#include <linux/string.h>
 23#include <linux/unistd.h>
 24#include <linux/property.h>
 25
 26void mdio_device_free(struct mdio_device *mdiodev)
 27{
 28	put_device(&mdiodev->dev);
 29}
 30EXPORT_SYMBOL(mdio_device_free);
 31
 32static void mdio_device_release(struct device *dev)
 33{
 34	fwnode_handle_put(dev->fwnode);
 35	kfree(to_mdio_device(dev));
 36}
 37
 38int mdio_device_bus_match(struct device *dev, const struct device_driver *drv)
 39{
 40	struct mdio_device *mdiodev = to_mdio_device(dev);
 41	const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
 42
 43	if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)
 44		return 0;
 45
 46	return strcmp(mdiodev->modalias, drv->name) == 0;
 47}
 48
 49struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr)
 50{
 51	struct mdio_device *mdiodev;
 52
 53	/* We allocate the device, and initialize the default values */
 54	mdiodev = kzalloc(sizeof(*mdiodev), GFP_KERNEL);
 55	if (!mdiodev)
 56		return ERR_PTR(-ENOMEM);
 57
 58	mdiodev->dev.release = mdio_device_release;
 59	mdiodev->dev.parent = &bus->dev;
 60	mdiodev->dev.bus = &mdio_bus_type;
 61	mdiodev->device_free = mdio_device_free;
 62	mdiodev->device_remove = mdio_device_remove;
 63	mdiodev->bus = bus;
 64	mdiodev->addr = addr;
 65	mdiodev->reset_state = -1;
 66
 67	dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
 68
 69	device_initialize(&mdiodev->dev);
 70
 71	return mdiodev;
 72}
 73EXPORT_SYMBOL(mdio_device_create);
 74
 75/**
 76 * mdio_device_register - Register the mdio device on the MDIO bus
 77 * @mdiodev: mdio_device structure to be added to the MDIO bus
 78 */
 79int mdio_device_register(struct mdio_device *mdiodev)
 80{
 81	int err;
 82
 83	dev_dbg(&mdiodev->dev, "%s\n", __func__);
 84
 85	err = mdiobus_register_device(mdiodev);
 86	if (err)
 87		return err;
 88
 89	err = device_add(&mdiodev->dev);
 90	if (err) {
 91		pr_err("MDIO %d failed to add\n", mdiodev->addr);
 92		goto out;
 93	}
 94
 95	return 0;
 96
 97 out:
 98	mdiobus_unregister_device(mdiodev);
 99	return err;
100}
101EXPORT_SYMBOL(mdio_device_register);
102
103/**
104 * mdio_device_remove - Remove a previously registered mdio device from the
105 *			MDIO bus
106 * @mdiodev: mdio_device structure to remove
107 *
108 * This doesn't free the mdio_device itself, it merely reverses the effects
109 * of mdio_device_register(). Use mdio_device_free() to free the device
110 * after calling this function.
111 */
112void mdio_device_remove(struct mdio_device *mdiodev)
113{
114	device_del(&mdiodev->dev);
115	mdiobus_unregister_device(mdiodev);
116}
117EXPORT_SYMBOL(mdio_device_remove);
118
119void mdio_device_reset(struct mdio_device *mdiodev, int value)
120{
121	unsigned int d;
122
123	if (!mdiodev->reset_gpio && !mdiodev->reset_ctrl)
124		return;
125
126	if (mdiodev->reset_state == value)
127		return;
128
129	if (mdiodev->reset_gpio)
130		gpiod_set_value_cansleep(mdiodev->reset_gpio, value);
131
132	if (mdiodev->reset_ctrl) {
133		if (value)
134			reset_control_assert(mdiodev->reset_ctrl);
135		else
136			reset_control_deassert(mdiodev->reset_ctrl);
137	}
138
139	d = value ? mdiodev->reset_assert_delay : mdiodev->reset_deassert_delay;
140	if (d)
141		fsleep(d);
142
143	mdiodev->reset_state = value;
144}
145EXPORT_SYMBOL(mdio_device_reset);
146
147/**
148 * mdio_probe - probe an MDIO device
149 * @dev: device to probe
150 *
151 * Description: Take care of setting up the mdio_device structure
152 * and calling the driver to probe the device.
153 */
154static int mdio_probe(struct device *dev)
155{
156	struct mdio_device *mdiodev = to_mdio_device(dev);
157	struct device_driver *drv = mdiodev->dev.driver;
158	struct mdio_driver *mdiodrv = to_mdio_driver(drv);
159	int err = 0;
160
161	/* Deassert the reset signal */
162	mdio_device_reset(mdiodev, 0);
163
164	if (mdiodrv->probe) {
165		err = mdiodrv->probe(mdiodev);
166		if (err) {
167			/* Assert the reset signal */
168			mdio_device_reset(mdiodev, 1);
169		}
170	}
171
172	return err;
173}
174
175static int mdio_remove(struct device *dev)
176{
177	struct mdio_device *mdiodev = to_mdio_device(dev);
178	struct device_driver *drv = mdiodev->dev.driver;
179	struct mdio_driver *mdiodrv = to_mdio_driver(drv);
180
181	if (mdiodrv->remove)
182		mdiodrv->remove(mdiodev);
183
184	/* Assert the reset signal */
185	mdio_device_reset(mdiodev, 1);
186
187	return 0;
188}
189
190static void mdio_shutdown(struct device *dev)
191{
192	struct mdio_device *mdiodev = to_mdio_device(dev);
193	struct device_driver *drv = mdiodev->dev.driver;
194	struct mdio_driver *mdiodrv = to_mdio_driver(drv);
195
196	if (mdiodrv->shutdown)
197		mdiodrv->shutdown(mdiodev);
198}
199
200/**
201 * mdio_driver_register - register an mdio_driver with the MDIO layer
202 * @drv: new mdio_driver to register
203 */
204int mdio_driver_register(struct mdio_driver *drv)
205{
206	struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
207	int retval;
208
209	pr_debug("%s: %s\n", __func__, mdiodrv->driver.name);
210
211	mdiodrv->driver.bus = &mdio_bus_type;
212	mdiodrv->driver.probe = mdio_probe;
213	mdiodrv->driver.remove = mdio_remove;
214	mdiodrv->driver.shutdown = mdio_shutdown;
215
216	retval = driver_register(&mdiodrv->driver);
217	if (retval) {
218		pr_err("%s: Error %d in registering driver\n",
219		       mdiodrv->driver.name, retval);
220
221		return retval;
222	}
223
224	return 0;
225}
226EXPORT_SYMBOL(mdio_driver_register);
227
228void mdio_driver_unregister(struct mdio_driver *drv)
229{
230	struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
231
232	driver_unregister(&mdiodrv->driver);
233}
234EXPORT_SYMBOL(mdio_driver_unregister);