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 
mdio_device_free(struct mdio_device * mdiodev)26 void mdio_device_free(struct mdio_device *mdiodev)
27 {
28 	put_device(&mdiodev->dev);
29 }
30 EXPORT_SYMBOL(mdio_device_free);
31 
mdio_device_release(struct device * dev)32 static void mdio_device_release(struct device *dev)
33 {
34 	fwnode_handle_put(dev->fwnode);
35 	kfree(to_mdio_device(dev));
36 }
37 
mdio_device_bus_match(struct device * dev,const struct device_driver * drv)38 int 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 
mdio_device_create(struct mii_bus * bus,int addr)49 struct 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 }
73 EXPORT_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  */
mdio_device_register(struct mdio_device * mdiodev)79 int 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 }
101 EXPORT_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  */
mdio_device_remove(struct mdio_device * mdiodev)112 void mdio_device_remove(struct mdio_device *mdiodev)
113 {
114 	device_del(&mdiodev->dev);
115 	mdiobus_unregister_device(mdiodev);
116 }
117 EXPORT_SYMBOL(mdio_device_remove);
118 
mdio_device_reset(struct mdio_device * mdiodev,int value)119 void 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 }
145 EXPORT_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  */
mdio_probe(struct device * dev)154 static 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 
mdio_remove(struct device * dev)175 static 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 
mdio_shutdown(struct device * dev)190 static 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  */
mdio_driver_register(struct mdio_driver * drv)204 int 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 }
226 EXPORT_SYMBOL(mdio_driver_register);
227 
mdio_driver_unregister(struct mdio_driver * drv)228 void mdio_driver_unregister(struct mdio_driver *drv)
229 {
230 	struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
231 
232 	driver_unregister(&mdiodrv->driver);
233 }
234 EXPORT_SYMBOL(mdio_driver_unregister);
235