Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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#include "mdio-private.h"
26
27void mdio_device_free(struct mdio_device *mdiodev)
28{
29 put_device(&mdiodev->dev);
30}
31EXPORT_SYMBOL(mdio_device_free);
32
33static void mdio_device_release(struct device *dev)
34{
35 fwnode_handle_put(dev->fwnode);
36 kfree(to_mdio_device(dev));
37}
38
39static int mdio_device_bus_match(struct device *dev,
40 const struct device_driver *drv)
41{
42 struct mdio_device *mdiodev = to_mdio_device(dev);
43 const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
44
45 if (mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY)
46 return 0;
47
48 return strcmp(mdiodev->modalias, drv->name) == 0;
49}
50
51struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr)
52{
53 struct mdio_device *mdiodev;
54
55 /* We allocate the device, and initialize the default values */
56 mdiodev = kzalloc(sizeof(*mdiodev), GFP_KERNEL);
57 if (!mdiodev)
58 return ERR_PTR(-ENOMEM);
59
60 mdiodev->dev.release = mdio_device_release;
61 mdiodev->dev.parent = &bus->dev;
62 mdiodev->dev.bus = &mdio_bus_type;
63 mdiodev->bus_match = mdio_device_bus_match;
64 mdiodev->device_free = mdio_device_free;
65 mdiodev->device_remove = mdio_device_remove;
66 mdiodev->bus = bus;
67 mdiodev->addr = addr;
68 mdiodev->reset_state = -1;
69
70 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
71
72 device_initialize(&mdiodev->dev);
73
74 return mdiodev;
75}
76EXPORT_SYMBOL(mdio_device_create);
77
78/**
79 * mdio_device_register - Register the mdio device on the MDIO bus
80 * @mdiodev: mdio_device structure to be added to the MDIO bus
81 *
82 * Return: Zero if successful, negative error code on failure
83 */
84int mdio_device_register(struct mdio_device *mdiodev)
85{
86 int err;
87
88 dev_dbg(&mdiodev->dev, "%s\n", __func__);
89
90 err = mdiobus_register_device(mdiodev);
91 if (err)
92 return err;
93
94 err = device_add(&mdiodev->dev);
95 if (err) {
96 pr_err("MDIO %d failed to add\n", mdiodev->addr);
97 goto out;
98 }
99
100 return 0;
101
102 out:
103 mdiobus_unregister_device(mdiodev);
104 return err;
105}
106EXPORT_SYMBOL(mdio_device_register);
107
108/**
109 * mdio_device_remove - Remove a previously registered mdio device from the
110 * MDIO bus
111 * @mdiodev: mdio_device structure to remove
112 *
113 * This doesn't free the mdio_device itself, it merely reverses the effects
114 * of mdio_device_register(). Use mdio_device_free() to free the device
115 * after calling this function.
116 */
117void mdio_device_remove(struct mdio_device *mdiodev)
118{
119 device_del(&mdiodev->dev);
120 mdiobus_unregister_device(mdiodev);
121}
122EXPORT_SYMBOL(mdio_device_remove);
123
124/**
125 * mdio_device_register_reset - Read and initialize the reset properties of
126 * an mdio device
127 * @mdiodev: mdio_device structure
128 *
129 * Return: Zero if successful, negative error code on failure
130 */
131int mdio_device_register_reset(struct mdio_device *mdiodev)
132{
133 struct reset_control *reset;
134
135 /* Deassert the optional reset signal */
136 mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
137 "reset", GPIOD_OUT_LOW);
138 if (IS_ERR(mdiodev->reset_gpio))
139 return PTR_ERR(mdiodev->reset_gpio);
140
141 if (mdiodev->reset_gpio)
142 gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
143
144 reset = reset_control_get_optional_exclusive(&mdiodev->dev, "phy");
145 if (IS_ERR(reset)) {
146 gpiod_put(mdiodev->reset_gpio);
147 mdiodev->reset_gpio = NULL;
148 return PTR_ERR(reset);
149 }
150
151 mdiodev->reset_ctrl = reset;
152
153 /* Read optional firmware properties */
154 device_property_read_u32(&mdiodev->dev, "reset-assert-us",
155 &mdiodev->reset_assert_delay);
156 device_property_read_u32(&mdiodev->dev, "reset-deassert-us",
157 &mdiodev->reset_deassert_delay);
158
159 return 0;
160}
161
162/**
163 * mdio_device_unregister_reset - uninitialize the reset properties of
164 * an mdio device
165 * @mdiodev: mdio_device structure
166 */
167void mdio_device_unregister_reset(struct mdio_device *mdiodev)
168{
169 gpiod_put(mdiodev->reset_gpio);
170 mdiodev->reset_gpio = NULL;
171 reset_control_put(mdiodev->reset_ctrl);
172 mdiodev->reset_ctrl = NULL;
173 mdiodev->reset_assert_delay = 0;
174 mdiodev->reset_deassert_delay = 0;
175}
176
177void mdio_device_reset(struct mdio_device *mdiodev, int value)
178{
179 unsigned int d;
180
181 if (!mdiodev->reset_gpio && !mdiodev->reset_ctrl)
182 return;
183
184 if (mdiodev->reset_state == value)
185 return;
186
187 if (mdiodev->reset_gpio)
188 gpiod_set_value_cansleep(mdiodev->reset_gpio, value);
189
190 if (mdiodev->reset_ctrl) {
191 if (value)
192 reset_control_assert(mdiodev->reset_ctrl);
193 else
194 reset_control_deassert(mdiodev->reset_ctrl);
195 }
196
197 d = value ? mdiodev->reset_assert_delay : mdiodev->reset_deassert_delay;
198 if (d)
199 fsleep(d);
200
201 mdiodev->reset_state = value;
202}
203EXPORT_SYMBOL(mdio_device_reset);
204
205/**
206 * mdio_probe - probe an MDIO device
207 * @dev: device to probe
208 *
209 * Description: Take care of setting up the mdio_device structure
210 * and calling the driver to probe the device.
211 *
212 * Return: Zero if successful, negative error code on failure
213 */
214static int mdio_probe(struct device *dev)
215{
216 struct mdio_device *mdiodev = to_mdio_device(dev);
217 struct device_driver *drv = mdiodev->dev.driver;
218 struct mdio_driver *mdiodrv = to_mdio_driver(drv);
219 int err = 0;
220
221 /* Deassert the reset signal */
222 mdio_device_reset(mdiodev, 0);
223
224 if (mdiodrv->probe) {
225 err = mdiodrv->probe(mdiodev);
226 if (err) {
227 /* Assert the reset signal */
228 mdio_device_reset(mdiodev, 1);
229 }
230 }
231
232 return err;
233}
234
235static int mdio_remove(struct device *dev)
236{
237 struct mdio_device *mdiodev = to_mdio_device(dev);
238 struct device_driver *drv = mdiodev->dev.driver;
239 struct mdio_driver *mdiodrv = to_mdio_driver(drv);
240
241 if (mdiodrv->remove)
242 mdiodrv->remove(mdiodev);
243
244 /* Assert the reset signal */
245 mdio_device_reset(mdiodev, 1);
246
247 return 0;
248}
249
250static void mdio_shutdown(struct device *dev)
251{
252 struct mdio_device *mdiodev = to_mdio_device(dev);
253 struct device_driver *drv = mdiodev->dev.driver;
254 struct mdio_driver *mdiodrv = to_mdio_driver(drv);
255
256 if (mdiodrv->shutdown)
257 mdiodrv->shutdown(mdiodev);
258}
259
260/**
261 * mdio_driver_register - register an mdio_driver with the MDIO layer
262 * @drv: new mdio_driver to register
263 *
264 * Return: Zero if successful, negative error code on failure
265 */
266int mdio_driver_register(struct mdio_driver *drv)
267{
268 struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
269 int retval;
270
271 pr_debug("%s: %s\n", __func__, mdiodrv->driver.name);
272
273 mdiodrv->driver.bus = &mdio_bus_type;
274 mdiodrv->driver.probe = mdio_probe;
275 mdiodrv->driver.remove = mdio_remove;
276 mdiodrv->driver.shutdown = mdio_shutdown;
277
278 retval = driver_register(&mdiodrv->driver);
279 if (retval) {
280 pr_err("%s: Error %d in registering driver\n",
281 mdiodrv->driver.name, retval);
282
283 return retval;
284 }
285
286 return 0;
287}
288EXPORT_SYMBOL(mdio_driver_register);
289
290void mdio_driver_unregister(struct mdio_driver *drv)
291{
292 struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
293
294 driver_unregister(&mdiodrv->driver);
295}
296EXPORT_SYMBOL(mdio_driver_unregister);