Branch data Line data Source code
1 : : /* MDIO Bus interface
2 : : *
3 : : * Author: Andy Fleming
4 : : *
5 : : * Copyright (c) 2004 Freescale Semiconductor, Inc.
6 : : *
7 : : * This program is free software; you can redistribute it and/or modify it
8 : : * under the terms of the GNU General Public License as published by the
9 : : * Free Software Foundation; either version 2 of the License, or (at your
10 : : * option) any later version.
11 : : *
12 : : */
13 : :
14 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 : :
16 : : #include <linux/kernel.h>
17 : : #include <linux/string.h>
18 : : #include <linux/errno.h>
19 : : #include <linux/unistd.h>
20 : : #include <linux/slab.h>
21 : : #include <linux/interrupt.h>
22 : : #include <linux/init.h>
23 : : #include <linux/delay.h>
24 : : #include <linux/device.h>
25 : : #include <linux/of_device.h>
26 : : #include <linux/of_mdio.h>
27 : : #include <linux/netdevice.h>
28 : : #include <linux/etherdevice.h>
29 : : #include <linux/skbuff.h>
30 : : #include <linux/spinlock.h>
31 : : #include <linux/mm.h>
32 : : #include <linux/module.h>
33 : : #include <linux/mii.h>
34 : : #include <linux/ethtool.h>
35 : : #include <linux/phy.h>
36 : : #include <linux/io.h>
37 : : #include <linux/uaccess.h>
38 : :
39 : : #include <asm/irq.h>
40 : :
41 : : /**
42 : : * mdiobus_alloc_size - allocate a mii_bus structure
43 : : * @size: extra amount of memory to allocate for private storage.
44 : : * If non-zero, then bus->priv is points to that memory.
45 : : *
46 : : * Description: called by a bus driver to allocate an mii_bus
47 : : * structure to fill in.
48 : : */
49 : 0 : struct mii_bus *mdiobus_alloc_size(size_t size)
50 : : {
51 : : struct mii_bus *bus;
52 : : size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
53 : : size_t alloc_size;
54 : :
55 : : /* If we alloc extra space, it should be aligned */
56 [ # # ]: 0 : if (size)
57 : 0 : alloc_size = aligned_size + size;
58 : : else
59 : : alloc_size = sizeof(*bus);
60 : :
61 : : bus = kzalloc(alloc_size, GFP_KERNEL);
62 [ # # ]: 0 : if (bus) {
63 : 0 : bus->state = MDIOBUS_ALLOCATED;
64 [ # # ]: 0 : if (size)
65 : 0 : bus->priv = (void *)bus + aligned_size;
66 : : }
67 : :
68 : 0 : return bus;
69 : : }
70 : : EXPORT_SYMBOL(mdiobus_alloc_size);
71 : :
72 : : /**
73 : : * mdiobus_release - mii_bus device release callback
74 : : * @d: the target struct device that contains the mii_bus
75 : : *
76 : : * Description: called when the last reference to an mii_bus is
77 : : * dropped, to free the underlying memory.
78 : : */
79 : 0 : static void mdiobus_release(struct device *d)
80 : : {
81 : 0 : struct mii_bus *bus = to_mii_bus(d);
82 [ # # ]: 0 : BUG_ON(bus->state != MDIOBUS_RELEASED &&
83 : : /* for compatibility with error handling in drivers */
84 : : bus->state != MDIOBUS_ALLOCATED);
85 : 0 : kfree(bus);
86 : 0 : }
87 : :
88 : : static struct class mdio_bus_class = {
89 : : .name = "mdio_bus",
90 : : .dev_release = mdiobus_release,
91 : : };
92 : :
93 : : #if IS_ENABLED(CONFIG_OF_MDIO)
94 : : /* Helper function for of_mdio_find_bus */
95 : 0 : static int of_mdio_bus_match(struct device *dev, const void *mdio_bus_np)
96 : : {
97 : 0 : return dev->of_node == mdio_bus_np;
98 : : }
99 : : /**
100 : : * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
101 : : * @mdio_bus_np: Pointer to the mii_bus.
102 : : *
103 : : * Returns a pointer to the mii_bus, or NULL if none found.
104 : : *
105 : : * Because the association of a device_node and mii_bus is made via
106 : : * of_mdiobus_register(), the mii_bus cannot be found before it is
107 : : * registered with of_mdiobus_register().
108 : : *
109 : : */
110 : 0 : struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
111 : : {
112 : : struct device *d;
113 : :
114 [ # # ]: 0 : if (!mdio_bus_np)
115 : : return NULL;
116 : :
117 : 0 : d = class_find_device(&mdio_bus_class, NULL, mdio_bus_np,
118 : : of_mdio_bus_match);
119 : :
120 [ # # ]: 0 : return d ? to_mii_bus(d) : NULL;
121 : : }
122 : : EXPORT_SYMBOL(of_mdio_find_bus);
123 : : #endif
124 : :
125 : : /**
126 : : * mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
127 : : * @bus: target mii_bus
128 : : *
129 : : * Description: Called by a bus driver to bring up all the PHYs
130 : : * on a given bus, and attach them to the bus.
131 : : *
132 : : * Returns 0 on success or < 0 on error.
133 : : */
134 : 0 : int mdiobus_register(struct mii_bus *bus)
135 : : {
136 : : int i, err;
137 : :
138 [ # # ][ # # ]: 0 : if (NULL == bus || NULL == bus->name ||
[ # # ]
139 [ # # ]: 0 : NULL == bus->read || NULL == bus->write)
140 : : return -EINVAL;
141 : :
142 [ # # ]: 0 : BUG_ON(bus->state != MDIOBUS_ALLOCATED &&
143 : : bus->state != MDIOBUS_UNREGISTERED);
144 : :
145 : 0 : bus->dev.parent = bus->parent;
146 : 0 : bus->dev.class = &mdio_bus_class;
147 : 0 : bus->dev.groups = NULL;
148 : 0 : dev_set_name(&bus->dev, "%s", bus->id);
149 : :
150 : 0 : err = device_register(&bus->dev);
151 [ # # ]: 0 : if (err) {
152 : 0 : pr_err("mii_bus %s failed to register\n", bus->id);
153 : 0 : put_device(&bus->dev);
154 : 0 : return -EINVAL;
155 : : }
156 : :
157 : 0 : mutex_init(&bus->mdio_lock);
158 : :
159 [ # # ]: 0 : if (bus->reset)
160 : 0 : bus->reset(bus);
161 : :
162 [ # # ]: 0 : for (i = 0; i < PHY_MAX_ADDR; i++) {
163 [ # # ]: 0 : if ((bus->phy_mask & (1 << i)) == 0) {
164 : : struct phy_device *phydev;
165 : :
166 : 0 : phydev = mdiobus_scan(bus, i);
167 [ # # ]: 0 : if (IS_ERR(phydev)) {
168 : : err = PTR_ERR(phydev);
169 : : goto error;
170 : : }
171 : : }
172 : : }
173 : :
174 : 0 : bus->state = MDIOBUS_REGISTERED;
175 : 0 : pr_info("%s: probed\n", bus->name);
176 : 0 : return 0;
177 : :
178 : : error:
179 [ # # ]: 0 : while (--i >= 0) {
180 [ # # ]: 0 : if (bus->phy_map[i])
181 : 0 : device_unregister(&bus->phy_map[i]->dev);
182 : : }
183 : 0 : device_del(&bus->dev);
184 : 0 : return err;
185 : : }
186 : : EXPORT_SYMBOL(mdiobus_register);
187 : :
188 : 0 : void mdiobus_unregister(struct mii_bus *bus)
189 : : {
190 : : int i;
191 : :
192 [ # # ]: 0 : BUG_ON(bus->state != MDIOBUS_REGISTERED);
193 : 0 : bus->state = MDIOBUS_UNREGISTERED;
194 : :
195 : 0 : device_del(&bus->dev);
196 [ # # ]: 0 : for (i = 0; i < PHY_MAX_ADDR; i++) {
197 [ # # ]: 0 : if (bus->phy_map[i])
198 : 0 : device_unregister(&bus->phy_map[i]->dev);
199 : 0 : bus->phy_map[i] = NULL;
200 : : }
201 : 0 : }
202 : : EXPORT_SYMBOL(mdiobus_unregister);
203 : :
204 : : /**
205 : : * mdiobus_free - free a struct mii_bus
206 : : * @bus: mii_bus to free
207 : : *
208 : : * This function releases the reference to the underlying device
209 : : * object in the mii_bus. If this is the last reference, the mii_bus
210 : : * will be freed.
211 : : */
212 : 0 : void mdiobus_free(struct mii_bus *bus)
213 : : {
214 : : /* For compatibility with error handling in drivers. */
215 [ # # ]: 0 : if (bus->state == MDIOBUS_ALLOCATED) {
216 : 0 : kfree(bus);
217 : 0 : return;
218 : : }
219 : :
220 [ # # ]: 0 : BUG_ON(bus->state != MDIOBUS_UNREGISTERED);
221 : 0 : bus->state = MDIOBUS_RELEASED;
222 : :
223 : 0 : put_device(&bus->dev);
224 : : }
225 : : EXPORT_SYMBOL(mdiobus_free);
226 : :
227 : 0 : struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr)
228 : : {
229 : : struct phy_device *phydev;
230 : : int err;
231 : :
232 : 0 : phydev = get_phy_device(bus, addr, false);
233 [ # # ][ # # ]: 0 : if (IS_ERR(phydev) || phydev == NULL)
234 : : return phydev;
235 : :
236 : 0 : err = phy_device_register(phydev);
237 [ # # ]: 0 : if (err) {
238 : 0 : phy_device_free(phydev);
239 : 0 : return NULL;
240 : : }
241 : :
242 : : return phydev;
243 : : }
244 : : EXPORT_SYMBOL(mdiobus_scan);
245 : :
246 : : /**
247 : : * mdiobus_read - Convenience function for reading a given MII mgmt register
248 : : * @bus: the mii_bus struct
249 : : * @addr: the phy address
250 : : * @regnum: register number to read
251 : : *
252 : : * NOTE: MUST NOT be called from interrupt context,
253 : : * because the bus read/write functions may wait for an interrupt
254 : : * to conclude the operation.
255 : : */
256 : 0 : int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
257 : : {
258 : : int retval;
259 : :
260 [ - + ]: 65868 : BUG_ON(in_interrupt());
261 : :
262 : 65868 : mutex_lock(&bus->mdio_lock);
263 : 65868 : retval = bus->read(bus, addr, regnum);
264 : 65868 : mutex_unlock(&bus->mdio_lock);
265 : :
266 : 65868 : return retval;
267 : : }
268 : : EXPORT_SYMBOL(mdiobus_read);
269 : :
270 : : /**
271 : : * mdiobus_write - Convenience function for writing a given MII mgmt register
272 : : * @bus: the mii_bus struct
273 : : * @addr: the phy address
274 : : * @regnum: register number to write
275 : : * @val: value to write to @regnum
276 : : *
277 : : * NOTE: MUST NOT be called from interrupt context,
278 : : * because the bus read/write functions may wait for an interrupt
279 : : * to conclude the operation.
280 : : */
281 : 0 : int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
282 : : {
283 : : int err;
284 : :
285 [ # # ]: 0 : BUG_ON(in_interrupt());
286 : :
287 : 0 : mutex_lock(&bus->mdio_lock);
288 : 0 : err = bus->write(bus, addr, regnum, val);
289 : 0 : mutex_unlock(&bus->mdio_lock);
290 : :
291 : 0 : return err;
292 : : }
293 : : EXPORT_SYMBOL(mdiobus_write);
294 : :
295 : : /**
296 : : * mdio_bus_match - determine if given PHY driver supports the given PHY device
297 : : * @dev: target PHY device
298 : : * @drv: given PHY driver
299 : : *
300 : : * Description: Given a PHY device, and a PHY driver, return 1 if
301 : : * the driver supports the device. Otherwise, return 0.
302 : : */
303 : 0 : static int mdio_bus_match(struct device *dev, struct device_driver *drv)
304 : : {
305 : 0 : struct phy_device *phydev = to_phy_device(dev);
306 : : struct phy_driver *phydrv = to_phy_driver(drv);
307 : :
308 [ # # ]: 0 : if (of_driver_match_device(dev, drv))
309 : : return 1;
310 : :
311 [ # # ]: 0 : if (phydrv->match_phy_device)
312 : 0 : return phydrv->match_phy_device(phydev);
313 : :
314 : 0 : return (phydrv->phy_id & phydrv->phy_id_mask) ==
315 : 0 : (phydev->phy_id & phydrv->phy_id_mask);
316 : : }
317 : :
318 : : #ifdef CONFIG_PM
319 : :
320 : 0 : static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
321 : : {
322 : 0 : struct device_driver *drv = phydev->dev.driver;
323 : : struct phy_driver *phydrv = to_phy_driver(drv);
324 : 0 : struct net_device *netdev = phydev->attached_dev;
325 : :
326 [ # # ][ # # ]: 0 : if (!drv || !phydrv->suspend)
327 : : return false;
328 : :
329 : : /* PHY not attached? May suspend. */
330 [ # # ]: 0 : if (!netdev)
331 : : return true;
332 : :
333 : : /* Don't suspend PHY if the attched netdev parent may wakeup.
334 : : * The parent may point to a PCI device, as in tg3 driver.
335 : : */
336 [ # # ][ # # ]: 0 : if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
337 : : return false;
338 : :
339 : : /* Also don't suspend PHY if the netdev itself may wakeup. This
340 : : * is the case for devices w/o underlaying pwr. mgmt. aware bus,
341 : : * e.g. SoC devices.
342 : : */
343 [ # # ]: 0 : if (device_may_wakeup(&netdev->dev))
344 : : return false;
345 : :
346 : : return true;
347 : : }
348 : :
349 : 0 : static int mdio_bus_suspend(struct device *dev)
350 : : {
351 : 0 : struct phy_driver *phydrv = to_phy_driver(dev->driver);
352 : 0 : struct phy_device *phydev = to_phy_device(dev);
353 : :
354 : : /* We must stop the state machine manually, otherwise it stops out of
355 : : * control, possibly with the phydev->lock held. Upon resume, netdev
356 : : * may call phy routines that try to grab the same lock, and that may
357 : : * lead to a deadlock.
358 : : */
359 [ # # ][ # # ]: 0 : if (phydev->attached_dev && phydev->adjust_link)
360 : 0 : phy_stop_machine(phydev);
361 : :
362 [ # # ]: 0 : if (!mdio_bus_phy_may_suspend(phydev))
363 : : return 0;
364 : :
365 : 0 : return phydrv->suspend(phydev);
366 : : }
367 : :
368 : 0 : static int mdio_bus_resume(struct device *dev)
369 : : {
370 : 0 : struct phy_driver *phydrv = to_phy_driver(dev->driver);
371 : 0 : struct phy_device *phydev = to_phy_device(dev);
372 : : int ret;
373 : :
374 [ # # ]: 0 : if (!mdio_bus_phy_may_suspend(phydev))
375 : : goto no_resume;
376 : :
377 : 0 : ret = phydrv->resume(phydev);
378 [ # # ]: 0 : if (ret < 0)
379 : : return ret;
380 : :
381 : : no_resume:
382 [ # # ][ # # ]: 0 : if (phydev->attached_dev && phydev->adjust_link)
383 : 0 : phy_start_machine(phydev);
384 : :
385 : : return 0;
386 : : }
387 : :
388 : 0 : static int mdio_bus_restore(struct device *dev)
389 : : {
390 : 0 : struct phy_device *phydev = to_phy_device(dev);
391 : 0 : struct net_device *netdev = phydev->attached_dev;
392 : : int ret;
393 : :
394 [ # # ]: 0 : if (!netdev)
395 : : return 0;
396 : :
397 : 0 : ret = phy_init_hw(phydev);
398 [ # # ]: 0 : if (ret < 0)
399 : : return ret;
400 : :
401 : : /* The PHY needs to renegotiate. */
402 : 0 : phydev->link = 0;
403 : 0 : phydev->state = PHY_UP;
404 : :
405 : 0 : phy_start_machine(phydev);
406 : :
407 : 0 : return 0;
408 : : }
409 : :
410 : : static const struct dev_pm_ops mdio_bus_pm_ops = {
411 : : .suspend = mdio_bus_suspend,
412 : : .resume = mdio_bus_resume,
413 : : .freeze = mdio_bus_suspend,
414 : : .thaw = mdio_bus_resume,
415 : : .restore = mdio_bus_restore,
416 : : };
417 : :
418 : : #define MDIO_BUS_PM_OPS (&mdio_bus_pm_ops)
419 : :
420 : : #else
421 : :
422 : : #define MDIO_BUS_PM_OPS NULL
423 : :
424 : : #endif /* CONFIG_PM */
425 : :
426 : : static ssize_t
427 : 0 : phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
428 : : {
429 : : struct phy_device *phydev = to_phy_device(dev);
430 : :
431 : 0 : return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
432 : : }
433 : : static DEVICE_ATTR_RO(phy_id);
434 : :
435 : : static struct attribute *mdio_dev_attrs[] = {
436 : : &dev_attr_phy_id.attr,
437 : : NULL,
438 : : };
439 : : ATTRIBUTE_GROUPS(mdio_dev);
440 : :
441 : : struct bus_type mdio_bus_type = {
442 : : .name = "mdio_bus",
443 : : .match = mdio_bus_match,
444 : : .pm = MDIO_BUS_PM_OPS,
445 : : .dev_groups = mdio_dev_groups,
446 : : };
447 : : EXPORT_SYMBOL(mdio_bus_type);
448 : :
449 : 0 : int __init mdio_bus_init(void)
450 : : {
451 : : int ret;
452 : :
453 : 0 : ret = class_register(&mdio_bus_class);
454 [ # # ]: 0 : if (!ret) {
455 : 0 : ret = bus_register(&mdio_bus_type);
456 [ # # ]: 0 : if (ret)
457 : 0 : class_unregister(&mdio_bus_class);
458 : : }
459 : :
460 : 0 : return ret;
461 : : }
462 : :
463 : 0 : void mdio_bus_exit(void)
464 : : {
465 : 0 : class_unregister(&mdio_bus_class);
466 : 0 : bus_unregister(&mdio_bus_type);
467 : 0 : }
|
