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