GNU Linux-libre 4.19.314-gnu1
[releases.git] / drivers / net / phy / mdio_device.c
1 /* Framework for MDIO devices, other than PHYs.
2  *
3  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
4  *
5  * This program is free software; you can redistribute  it and/or modify it
6  * under  the terms of  the GNU General  Public License as published by the
7  * Free Software Foundation;  either version 2 of the  License, or (at your
8  * option) any later version.
9  *
10  */
11
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #include <linux/errno.h>
15 #include <linux/gpio.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/init.h>
18 #include <linux/interrupt.h>
19 #include <linux/kernel.h>
20 #include <linux/mdio.h>
21 #include <linux/mii.h>
22 #include <linux/module.h>
23 #include <linux/phy.h>
24 #include <linux/slab.h>
25 #include <linux/string.h>
26 #include <linux/unistd.h>
27 #include <linux/delay.h>
28
29 void mdio_device_free(struct mdio_device *mdiodev)
30 {
31         put_device(&mdiodev->dev);
32 }
33 EXPORT_SYMBOL(mdio_device_free);
34
35 static void mdio_device_release(struct device *dev)
36 {
37         kfree(to_mdio_device(dev));
38 }
39
40 int mdio_device_bus_match(struct device *dev, struct device_driver *drv)
41 {
42         struct mdio_device *mdiodev = to_mdio_device(dev);
43         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
51 struct 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->device_free = mdio_device_free;
64         mdiodev->device_remove = mdio_device_remove;
65         mdiodev->bus = bus;
66         mdiodev->addr = addr;
67
68         dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
69
70         device_initialize(&mdiodev->dev);
71
72         return mdiodev;
73 }
74 EXPORT_SYMBOL(mdio_device_create);
75
76 /**
77  * mdio_device_register - Register the mdio device on the MDIO bus
78  * @mdiodev: mdio_device structure to be added to the MDIO bus
79  */
80 int mdio_device_register(struct mdio_device *mdiodev)
81 {
82         int err;
83
84         dev_dbg(&mdiodev->dev, "mdio_device_register\n");
85
86         err = mdiobus_register_device(mdiodev);
87         if (err)
88                 return err;
89
90         err = device_add(&mdiodev->dev);
91         if (err) {
92                 pr_err("MDIO %d failed to add\n", mdiodev->addr);
93                 goto out;
94         }
95
96         return 0;
97
98  out:
99         mdiobus_unregister_device(mdiodev);
100         return err;
101 }
102 EXPORT_SYMBOL(mdio_device_register);
103
104 /**
105  * mdio_device_remove - Remove a previously registered mdio device from the
106  *                      MDIO bus
107  * @mdiodev: mdio_device structure to remove
108  *
109  * This doesn't free the mdio_device itself, it merely reverses the effects
110  * of mdio_device_register(). Use mdio_device_free() to free the device
111  * after calling this function.
112  */
113 void mdio_device_remove(struct mdio_device *mdiodev)
114 {
115         device_del(&mdiodev->dev);
116         mdiobus_unregister_device(mdiodev);
117 }
118 EXPORT_SYMBOL(mdio_device_remove);
119
120 void mdio_device_reset(struct mdio_device *mdiodev, int value)
121 {
122         unsigned int d;
123
124         if (!mdiodev->reset)
125                 return;
126
127         gpiod_set_value(mdiodev->reset, value);
128
129         d = value ? mdiodev->reset_assert_delay : mdiodev->reset_deassert_delay;
130         if (d)
131                 usleep_range(d, d + max_t(unsigned int, d / 10, 100));
132 }
133 EXPORT_SYMBOL(mdio_device_reset);
134
135 /**
136  * mdio_probe - probe an MDIO device
137  * @dev: device to probe
138  *
139  * Description: Take care of setting up the mdio_device structure
140  * and calling the driver to probe the device.
141  */
142 static int mdio_probe(struct device *dev)
143 {
144         struct mdio_device *mdiodev = to_mdio_device(dev);
145         struct device_driver *drv = mdiodev->dev.driver;
146         struct mdio_driver *mdiodrv = to_mdio_driver(drv);
147         int err = 0;
148
149         if (mdiodrv->probe) {
150                 /* Deassert the reset signal */
151                 mdio_device_reset(mdiodev, 0);
152
153                 err = mdiodrv->probe(mdiodev);
154                 if (err) {
155                         /* Assert the reset signal */
156                         mdio_device_reset(mdiodev, 1);
157                 }
158         }
159
160         return err;
161 }
162
163 static int mdio_remove(struct device *dev)
164 {
165         struct mdio_device *mdiodev = to_mdio_device(dev);
166         struct device_driver *drv = mdiodev->dev.driver;
167         struct mdio_driver *mdiodrv = to_mdio_driver(drv);
168
169         if (mdiodrv->remove) {
170                 mdiodrv->remove(mdiodev);
171
172                 /* Assert the reset signal */
173                 mdio_device_reset(mdiodev, 1);
174         }
175
176         return 0;
177 }
178
179 static void mdio_shutdown(struct device *dev)
180 {
181         struct mdio_device *mdiodev = to_mdio_device(dev);
182         struct device_driver *drv = mdiodev->dev.driver;
183         struct mdio_driver *mdiodrv = to_mdio_driver(drv);
184
185         if (mdiodrv->shutdown)
186                 mdiodrv->shutdown(mdiodev);
187 }
188
189 /**
190  * mdio_driver_register - register an mdio_driver with the MDIO layer
191  * @new_driver: new mdio_driver to register
192  */
193 int mdio_driver_register(struct mdio_driver *drv)
194 {
195         struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
196         int retval;
197
198         pr_debug("mdio_driver_register: %s\n", mdiodrv->driver.name);
199
200         mdiodrv->driver.bus = &mdio_bus_type;
201         mdiodrv->driver.probe = mdio_probe;
202         mdiodrv->driver.remove = mdio_remove;
203         mdiodrv->driver.shutdown = mdio_shutdown;
204
205         retval = driver_register(&mdiodrv->driver);
206         if (retval) {
207                 pr_err("%s: Error %d in registering driver\n",
208                        mdiodrv->driver.name, retval);
209
210                 return retval;
211         }
212
213         return 0;
214 }
215 EXPORT_SYMBOL(mdio_driver_register);
216
217 void mdio_driver_unregister(struct mdio_driver *drv)
218 {
219         struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
220
221         driver_unregister(&mdiodrv->driver);
222 }
223 EXPORT_SYMBOL(mdio_driver_unregister);