tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
29void mdio_device_free(struct mdio_device *mdiodev)
30{
31 put_device(&mdiodev->dev);
32}
33EXPORT_SYMBOL(mdio_device_free);
34
35static void mdio_device_release(struct device *dev)
36{
37 kfree(to_mdio_device(dev));
38}
39
40int 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
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->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}
74EXPORT_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 */
80int 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}
102EXPORT_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 */
113void mdio_device_remove(struct mdio_device *mdiodev)
114{
115 device_del(&mdiodev->dev);
116 mdiobus_unregister_device(mdiodev);
117}
118EXPORT_SYMBOL(mdio_device_remove);
119
120void 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}
133EXPORT_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 */
142static 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
163static 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/**
180 * mdio_driver_register - register an mdio_driver with the MDIO layer
181 * @new_driver: new mdio_driver to register
182 */
183int mdio_driver_register(struct mdio_driver *drv)
184{
185 struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
186 int retval;
187
188 pr_debug("mdio_driver_register: %s\n", mdiodrv->driver.name);
189
190 mdiodrv->driver.bus = &mdio_bus_type;
191 mdiodrv->driver.probe = mdio_probe;
192 mdiodrv->driver.remove = mdio_remove;
193
194 retval = driver_register(&mdiodrv->driver);
195 if (retval) {
196 pr_err("%s: Error %d in registering driver\n",
197 mdiodrv->driver.name, retval);
198
199 return retval;
200 }
201
202 return 0;
203}
204EXPORT_SYMBOL(mdio_driver_register);
205
206void mdio_driver_unregister(struct mdio_driver *drv)
207{
208 struct mdio_driver_common *mdiodrv = &drv->mdiodrv;
209
210 driver_unregister(&mdiodrv->driver);
211}
212EXPORT_SYMBOL(mdio_driver_unregister);