Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /* MDIO Bus interface
3 : : *
4 : : * Author: Andy Fleming
5 : : *
6 : : * Copyright (c) 2004 Freescale Semiconductor, Inc.
7 : : */
8 : :
9 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 : :
11 : : #include <linux/kernel.h>
12 : : #include <linux/string.h>
13 : : #include <linux/errno.h>
14 : : #include <linux/unistd.h>
15 : : #include <linux/slab.h>
16 : : #include <linux/interrupt.h>
17 : : #include <linux/init.h>
18 : : #include <linux/delay.h>
19 : : #include <linux/device.h>
20 : : #include <linux/gpio.h>
21 : : #include <linux/gpio/consumer.h>
22 : : #include <linux/of_device.h>
23 : : #include <linux/of_mdio.h>
24 : : #include <linux/of_gpio.h>
25 : : #include <linux/netdevice.h>
26 : : #include <linux/etherdevice.h>
27 : : #include <linux/reset.h>
28 : : #include <linux/skbuff.h>
29 : : #include <linux/spinlock.h>
30 : : #include <linux/mm.h>
31 : : #include <linux/module.h>
32 : : #include <linux/mii.h>
33 : : #include <linux/ethtool.h>
34 : : #include <linux/phy.h>
35 : : #include <linux/io.h>
36 : : #include <linux/uaccess.h>
37 : :
38 : : #define CREATE_TRACE_POINTS
39 : : #include <trace/events/mdio.h>
40 : :
41 : : #include "mdio-boardinfo.h"
42 : :
43 : 0 : static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
44 : : {
45 : : int error;
46 : :
47 : : /* Deassert the optional reset signal */
48 : 0 : mdiodev->reset_gpio = gpiod_get_optional(&mdiodev->dev,
49 : : "reset", GPIOD_OUT_LOW);
50 : : error = PTR_ERR_OR_ZERO(mdiodev->reset_gpio);
51 : 0 : if (error)
52 : : return error;
53 : :
54 : 0 : if (mdiodev->reset_gpio)
55 : 0 : gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
56 : :
57 : : return 0;
58 : : }
59 : :
60 : 0 : static int mdiobus_register_reset(struct mdio_device *mdiodev)
61 : : {
62 : : struct reset_control *reset = NULL;
63 : :
64 : 0 : if (mdiodev->dev.of_node)
65 : : reset = of_reset_control_get_exclusive(mdiodev->dev.of_node,
66 : : "phy");
67 : 0 : if (IS_ERR(reset)) {
68 : 0 : if (PTR_ERR(reset) == -ENOENT || PTR_ERR(reset) == -ENOTSUPP)
69 : : reset = NULL;
70 : : else
71 : : return PTR_ERR(reset);
72 : : }
73 : :
74 : 0 : mdiodev->reset_ctrl = reset;
75 : :
76 : 0 : return 0;
77 : : }
78 : :
79 : 0 : int mdiobus_register_device(struct mdio_device *mdiodev)
80 : : {
81 : : int err;
82 : :
83 : 0 : if (mdiodev->bus->mdio_map[mdiodev->addr])
84 : : return -EBUSY;
85 : :
86 : 0 : if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
87 : 0 : err = mdiobus_register_gpiod(mdiodev);
88 : 0 : if (err)
89 : : return err;
90 : :
91 : 0 : err = mdiobus_register_reset(mdiodev);
92 : 0 : if (err)
93 : : return err;
94 : :
95 : : /* Assert the reset signal */
96 : 0 : mdio_device_reset(mdiodev, 1);
97 : : }
98 : :
99 : 0 : mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
100 : :
101 : 0 : return 0;
102 : : }
103 : : EXPORT_SYMBOL(mdiobus_register_device);
104 : :
105 : 0 : int mdiobus_unregister_device(struct mdio_device *mdiodev)
106 : : {
107 : 0 : if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
108 : : return -EINVAL;
109 : :
110 : 0 : reset_control_put(mdiodev->reset_ctrl);
111 : :
112 : 0 : mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
113 : :
114 : 0 : return 0;
115 : : }
116 : : EXPORT_SYMBOL(mdiobus_unregister_device);
117 : :
118 : 0 : struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
119 : : {
120 : 0 : struct mdio_device *mdiodev = bus->mdio_map[addr];
121 : :
122 : 0 : if (!mdiodev)
123 : : return NULL;
124 : :
125 : 0 : if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
126 : : return NULL;
127 : :
128 : 0 : return container_of(mdiodev, struct phy_device, mdio);
129 : : }
130 : : EXPORT_SYMBOL(mdiobus_get_phy);
131 : :
132 : 0 : bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
133 : : {
134 : 0 : return bus->mdio_map[addr];
135 : : }
136 : : EXPORT_SYMBOL(mdiobus_is_registered_device);
137 : :
138 : : /**
139 : : * mdiobus_alloc_size - allocate a mii_bus structure
140 : : * @size: extra amount of memory to allocate for private storage.
141 : : * If non-zero, then bus->priv is points to that memory.
142 : : *
143 : : * Description: called by a bus driver to allocate an mii_bus
144 : : * structure to fill in.
145 : : */
146 : 3 : struct mii_bus *mdiobus_alloc_size(size_t size)
147 : : {
148 : : struct mii_bus *bus;
149 : : size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
150 : : size_t alloc_size;
151 : : int i;
152 : :
153 : : /* If we alloc extra space, it should be aligned */
154 : 3 : if (size)
155 : 0 : alloc_size = aligned_size + size;
156 : : else
157 : : alloc_size = sizeof(*bus);
158 : :
159 : 3 : bus = kzalloc(alloc_size, GFP_KERNEL);
160 : 3 : if (!bus)
161 : : return NULL;
162 : :
163 : 3 : bus->state = MDIOBUS_ALLOCATED;
164 : 3 : if (size)
165 : 0 : bus->priv = (void *)bus + aligned_size;
166 : :
167 : : /* Initialise the interrupts to polling */
168 : 3 : for (i = 0; i < PHY_MAX_ADDR; i++)
169 : 3 : bus->irq[i] = PHY_POLL;
170 : :
171 : : return bus;
172 : : }
173 : : EXPORT_SYMBOL(mdiobus_alloc_size);
174 : :
175 : 0 : static void _devm_mdiobus_free(struct device *dev, void *res)
176 : : {
177 : 0 : mdiobus_free(*(struct mii_bus **)res);
178 : 0 : }
179 : :
180 : 0 : static int devm_mdiobus_match(struct device *dev, void *res, void *data)
181 : : {
182 : : struct mii_bus **r = res;
183 : :
184 : 0 : if (WARN_ON(!r || !*r))
185 : : return 0;
186 : :
187 : 0 : return *r == data;
188 : : }
189 : :
190 : : /**
191 : : * devm_mdiobus_alloc_size - Resource-managed mdiobus_alloc_size()
192 : : * @dev: Device to allocate mii_bus for
193 : : * @sizeof_priv: Space to allocate for private structure.
194 : : *
195 : : * Managed mdiobus_alloc_size. mii_bus allocated with this function is
196 : : * automatically freed on driver detach.
197 : : *
198 : : * If an mii_bus allocated with this function needs to be freed separately,
199 : : * devm_mdiobus_free() must be used.
200 : : *
201 : : * RETURNS:
202 : : * Pointer to allocated mii_bus on success, NULL on failure.
203 : : */
204 : 0 : struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv)
205 : : {
206 : : struct mii_bus **ptr, *bus;
207 : :
208 : : ptr = devres_alloc(_devm_mdiobus_free, sizeof(*ptr), GFP_KERNEL);
209 : 0 : if (!ptr)
210 : : return NULL;
211 : :
212 : : /* use raw alloc_dr for kmalloc caller tracing */
213 : 0 : bus = mdiobus_alloc_size(sizeof_priv);
214 : 0 : if (bus) {
215 : 0 : *ptr = bus;
216 : 0 : devres_add(dev, ptr);
217 : : } else {
218 : 0 : devres_free(ptr);
219 : : }
220 : :
221 : 0 : return bus;
222 : : }
223 : : EXPORT_SYMBOL_GPL(devm_mdiobus_alloc_size);
224 : :
225 : : /**
226 : : * devm_mdiobus_free - Resource-managed mdiobus_free()
227 : : * @dev: Device this mii_bus belongs to
228 : : * @bus: the mii_bus associated with the device
229 : : *
230 : : * Free mii_bus allocated with devm_mdiobus_alloc_size().
231 : : */
232 : 0 : void devm_mdiobus_free(struct device *dev, struct mii_bus *bus)
233 : : {
234 : : int rc;
235 : :
236 : 0 : rc = devres_release(dev, _devm_mdiobus_free,
237 : : devm_mdiobus_match, bus);
238 : 0 : WARN_ON(rc);
239 : 0 : }
240 : : EXPORT_SYMBOL_GPL(devm_mdiobus_free);
241 : :
242 : : /**
243 : : * mdiobus_release - mii_bus device release callback
244 : : * @d: the target struct device that contains the mii_bus
245 : : *
246 : : * Description: called when the last reference to an mii_bus is
247 : : * dropped, to free the underlying memory.
248 : : */
249 : 0 : static void mdiobus_release(struct device *d)
250 : : {
251 : 0 : struct mii_bus *bus = to_mii_bus(d);
252 : 0 : BUG_ON(bus->state != MDIOBUS_RELEASED &&
253 : : /* for compatibility with error handling in drivers */
254 : : bus->state != MDIOBUS_ALLOCATED);
255 : 0 : kfree(bus);
256 : 0 : }
257 : :
258 : : static struct class mdio_bus_class = {
259 : : .name = "mdio_bus",
260 : : .dev_release = mdiobus_release,
261 : : };
262 : :
263 : : #if IS_ENABLED(CONFIG_OF_MDIO)
264 : : /**
265 : : * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
266 : : * @mdio_bus_np: Pointer to the mii_bus.
267 : : *
268 : : * Returns a reference to the mii_bus, or NULL if none found. The
269 : : * embedded struct device will have its reference count incremented,
270 : : * and this must be put once the bus is finished with.
271 : : *
272 : : * Because the association of a device_node and mii_bus is made via
273 : : * of_mdiobus_register(), the mii_bus cannot be found before it is
274 : : * registered with of_mdiobus_register().
275 : : *
276 : : */
277 : 0 : struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
278 : : {
279 : : struct device *d;
280 : :
281 : 0 : if (!mdio_bus_np)
282 : : return NULL;
283 : :
284 : : d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
285 : 0 : return d ? to_mii_bus(d) : NULL;
286 : : }
287 : : EXPORT_SYMBOL(of_mdio_find_bus);
288 : :
289 : : /* Walk the list of subnodes of a mdio bus and look for a node that
290 : : * matches the mdio device's address with its 'reg' property. If
291 : : * found, set the of_node pointer for the mdio device. This allows
292 : : * auto-probed phy devices to be supplied with information passed in
293 : : * via DT.
294 : : */
295 : 0 : static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
296 : : struct mdio_device *mdiodev)
297 : : {
298 : 0 : struct device *dev = &mdiodev->dev;
299 : : struct device_node *child;
300 : :
301 : 0 : if (dev->of_node || !bus->dev.of_node)
302 : : return;
303 : :
304 : 0 : for_each_available_child_of_node(bus->dev.of_node, child) {
305 : : int addr;
306 : :
307 : 0 : addr = of_mdio_parse_addr(dev, child);
308 : 0 : if (addr < 0)
309 : 0 : continue;
310 : :
311 : 0 : if (addr == mdiodev->addr) {
312 : 0 : dev->of_node = child;
313 : 0 : dev->fwnode = of_fwnode_handle(child);
314 : 0 : return;
315 : : }
316 : : }
317 : : }
318 : : #else /* !IS_ENABLED(CONFIG_OF_MDIO) */
319 : : static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
320 : : struct mdio_device *mdiodev)
321 : : {
322 : : }
323 : : #endif
324 : :
325 : : /**
326 : : * mdiobus_create_device_from_board_info - create a full MDIO device given
327 : : * a mdio_board_info structure
328 : : * @bus: MDIO bus to create the devices on
329 : : * @bi: mdio_board_info structure describing the devices
330 : : *
331 : : * Returns 0 on success or < 0 on error.
332 : : */
333 : 0 : static int mdiobus_create_device(struct mii_bus *bus,
334 : : struct mdio_board_info *bi)
335 : : {
336 : : struct mdio_device *mdiodev;
337 : : int ret = 0;
338 : :
339 : 0 : mdiodev = mdio_device_create(bus, bi->mdio_addr);
340 : 0 : if (IS_ERR(mdiodev))
341 : : return -ENODEV;
342 : :
343 : 0 : strncpy(mdiodev->modalias, bi->modalias,
344 : : sizeof(mdiodev->modalias));
345 : 0 : mdiodev->bus_match = mdio_device_bus_match;
346 : 0 : mdiodev->dev.platform_data = (void *)bi->platform_data;
347 : :
348 : 0 : ret = mdio_device_register(mdiodev);
349 : 0 : if (ret)
350 : 0 : mdio_device_free(mdiodev);
351 : :
352 : 0 : return ret;
353 : : }
354 : :
355 : : /**
356 : : * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
357 : : * @bus: target mii_bus
358 : : * @owner: module containing bus accessor functions
359 : : *
360 : : * Description: Called by a bus driver to bring up all the PHYs
361 : : * on a given bus, and attach them to the bus. Drivers should use
362 : : * mdiobus_register() rather than __mdiobus_register() unless they
363 : : * need to pass a specific owner module. MDIO devices which are not
364 : : * PHYs will not be brought up by this function. They are expected to
365 : : * to be explicitly listed in DT and instantiated by of_mdiobus_register().
366 : : *
367 : : * Returns 0 on success or < 0 on error.
368 : : */
369 : 3 : int __mdiobus_register(struct mii_bus *bus, struct module *owner)
370 : : {
371 : : struct mdio_device *mdiodev;
372 : : int i, err;
373 : : struct gpio_desc *gpiod;
374 : :
375 : 3 : if (NULL == bus || NULL == bus->name ||
376 : 3 : NULL == bus->read || NULL == bus->write)
377 : : return -EINVAL;
378 : :
379 : 3 : BUG_ON(bus->state != MDIOBUS_ALLOCATED &&
380 : : bus->state != MDIOBUS_UNREGISTERED);
381 : :
382 : 3 : bus->owner = owner;
383 : 3 : bus->dev.parent = bus->parent;
384 : 3 : bus->dev.class = &mdio_bus_class;
385 : 3 : bus->dev.groups = NULL;
386 : 3 : dev_set_name(&bus->dev, "%s", bus->id);
387 : :
388 : 3 : err = device_register(&bus->dev);
389 : 3 : if (err) {
390 : 0 : pr_err("mii_bus %s failed to register\n", bus->id);
391 : 0 : return -EINVAL;
392 : : }
393 : :
394 : 3 : mutex_init(&bus->mdio_lock);
395 : :
396 : : /* de-assert bus level PHY GPIO reset */
397 : 3 : gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_LOW);
398 : 3 : if (IS_ERR(gpiod)) {
399 : 0 : dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n",
400 : : bus->id);
401 : 0 : device_del(&bus->dev);
402 : 0 : return PTR_ERR(gpiod);
403 : 3 : } else if (gpiod) {
404 : 0 : bus->reset_gpiod = gpiod;
405 : :
406 : 0 : gpiod_set_value_cansleep(gpiod, 1);
407 : 0 : udelay(bus->reset_delay_us);
408 : 0 : gpiod_set_value_cansleep(gpiod, 0);
409 : : }
410 : :
411 : 3 : if (bus->reset)
412 : 0 : bus->reset(bus);
413 : :
414 : 3 : for (i = 0; i < PHY_MAX_ADDR; i++) {
415 : 3 : if ((bus->phy_mask & (1 << i)) == 0) {
416 : : struct phy_device *phydev;
417 : :
418 : 3 : phydev = mdiobus_scan(bus, i);
419 : 3 : if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV)) {
420 : : err = PTR_ERR(phydev);
421 : : goto error;
422 : : }
423 : : }
424 : : }
425 : :
426 : 3 : mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
427 : :
428 : 3 : bus->state = MDIOBUS_REGISTERED;
429 : 3 : pr_info("%s: probed\n", bus->name);
430 : 3 : return 0;
431 : :
432 : : error:
433 : 0 : while (--i >= 0) {
434 : 0 : mdiodev = bus->mdio_map[i];
435 : 0 : if (!mdiodev)
436 : 0 : continue;
437 : :
438 : 0 : mdiodev->device_remove(mdiodev);
439 : 0 : mdiodev->device_free(mdiodev);
440 : : }
441 : :
442 : : /* Put PHYs in RESET to save power */
443 : 0 : if (bus->reset_gpiod)
444 : 0 : gpiod_set_value_cansleep(bus->reset_gpiod, 1);
445 : :
446 : 0 : device_del(&bus->dev);
447 : 0 : return err;
448 : : }
449 : : EXPORT_SYMBOL(__mdiobus_register);
450 : :
451 : 0 : void mdiobus_unregister(struct mii_bus *bus)
452 : : {
453 : : struct mdio_device *mdiodev;
454 : : int i;
455 : :
456 : 0 : BUG_ON(bus->state != MDIOBUS_REGISTERED);
457 : 0 : bus->state = MDIOBUS_UNREGISTERED;
458 : :
459 : 0 : for (i = 0; i < PHY_MAX_ADDR; i++) {
460 : 0 : mdiodev = bus->mdio_map[i];
461 : 0 : if (!mdiodev)
462 : 0 : continue;
463 : :
464 : 0 : if (mdiodev->reset_gpio)
465 : 0 : gpiod_put(mdiodev->reset_gpio);
466 : :
467 : 0 : mdiodev->device_remove(mdiodev);
468 : 0 : mdiodev->device_free(mdiodev);
469 : : }
470 : :
471 : : /* Put PHYs in RESET to save power */
472 : 0 : if (bus->reset_gpiod)
473 : 0 : gpiod_set_value_cansleep(bus->reset_gpiod, 1);
474 : :
475 : 0 : device_del(&bus->dev);
476 : 0 : }
477 : : EXPORT_SYMBOL(mdiobus_unregister);
478 : :
479 : : /**
480 : : * mdiobus_free - free a struct mii_bus
481 : : * @bus: mii_bus to free
482 : : *
483 : : * This function releases the reference to the underlying device
484 : : * object in the mii_bus. If this is the last reference, the mii_bus
485 : : * will be freed.
486 : : */
487 : 0 : void mdiobus_free(struct mii_bus *bus)
488 : : {
489 : : /* For compatibility with error handling in drivers. */
490 : 0 : if (bus->state == MDIOBUS_ALLOCATED) {
491 : 0 : kfree(bus);
492 : 0 : return;
493 : : }
494 : :
495 : 0 : BUG_ON(bus->state != MDIOBUS_UNREGISTERED);
496 : 0 : bus->state = MDIOBUS_RELEASED;
497 : :
498 : 0 : put_device(&bus->dev);
499 : : }
500 : : EXPORT_SYMBOL(mdiobus_free);
501 : :
502 : : /**
503 : : * mdiobus_scan - scan a bus for MDIO devices.
504 : : * @bus: mii_bus to scan
505 : : * @addr: address on bus to scan
506 : : *
507 : : * This function scans the MDIO bus, looking for devices which can be
508 : : * identified using a vendor/product ID in registers 2 and 3. Not all
509 : : * MDIO devices have such registers, but PHY devices typically
510 : : * do. Hence this function assumes anything found is a PHY, or can be
511 : : * treated as a PHY. Other MDIO devices, such as switches, will
512 : : * probably not be found during the scan.
513 : : */
514 : 3 : struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr)
515 : : {
516 : : struct phy_device *phydev;
517 : : int err;
518 : :
519 : 3 : phydev = get_phy_device(bus, addr, false);
520 : 3 : if (IS_ERR(phydev))
521 : : return phydev;
522 : :
523 : : /*
524 : : * For DT, see if the auto-probed phy has a correspoding child
525 : : * in the bus node, and set the of_node pointer in this case.
526 : : */
527 : 0 : of_mdiobus_link_mdiodev(bus, &phydev->mdio);
528 : :
529 : 0 : err = phy_device_register(phydev);
530 : 0 : if (err) {
531 : 0 : phy_device_free(phydev);
532 : 0 : return ERR_PTR(-ENODEV);
533 : : }
534 : :
535 : : return phydev;
536 : : }
537 : : EXPORT_SYMBOL(mdiobus_scan);
538 : :
539 : : /**
540 : : * __mdiobus_read - Unlocked version of the mdiobus_read function
541 : : * @bus: the mii_bus struct
542 : : * @addr: the phy address
543 : : * @regnum: register number to read
544 : : *
545 : : * Read a MDIO bus register. Caller must hold the mdio bus lock.
546 : : *
547 : : * NOTE: MUST NOT be called from interrupt context.
548 : : */
549 : 3 : int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
550 : : {
551 : : int retval;
552 : :
553 : 3 : WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
554 : :
555 : 3 : retval = bus->read(bus, addr, regnum);
556 : :
557 : 3 : trace_mdio_access(bus, 1, addr, regnum, retval, retval);
558 : :
559 : 3 : return retval;
560 : : }
561 : : EXPORT_SYMBOL(__mdiobus_read);
562 : :
563 : : /**
564 : : * __mdiobus_write - Unlocked version of the mdiobus_write function
565 : : * @bus: the mii_bus struct
566 : : * @addr: the phy address
567 : : * @regnum: register number to write
568 : : * @val: value to write to @regnum
569 : : *
570 : : * Write a MDIO bus register. Caller must hold the mdio bus lock.
571 : : *
572 : : * NOTE: MUST NOT be called from interrupt context.
573 : : */
574 : 0 : int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
575 : : {
576 : : int err;
577 : :
578 : 0 : WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock));
579 : :
580 : 0 : err = bus->write(bus, addr, regnum, val);
581 : :
582 : 0 : trace_mdio_access(bus, 0, addr, regnum, val, err);
583 : :
584 : 0 : return err;
585 : : }
586 : : EXPORT_SYMBOL(__mdiobus_write);
587 : :
588 : : /**
589 : : * mdiobus_read_nested - Nested version of the mdiobus_read function
590 : : * @bus: the mii_bus struct
591 : : * @addr: the phy address
592 : : * @regnum: register number to read
593 : : *
594 : : * In case of nested MDIO bus access avoid lockdep false positives by
595 : : * using mutex_lock_nested().
596 : : *
597 : : * NOTE: MUST NOT be called from interrupt context,
598 : : * because the bus read/write functions may wait for an interrupt
599 : : * to conclude the operation.
600 : : */
601 : 0 : int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
602 : : {
603 : : int retval;
604 : :
605 : 0 : BUG_ON(in_interrupt());
606 : :
607 : 0 : mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
608 : 0 : retval = __mdiobus_read(bus, addr, regnum);
609 : 0 : mutex_unlock(&bus->mdio_lock);
610 : :
611 : 0 : return retval;
612 : : }
613 : : EXPORT_SYMBOL(mdiobus_read_nested);
614 : :
615 : : /**
616 : : * mdiobus_read - Convenience function for reading a given MII mgmt register
617 : : * @bus: the mii_bus struct
618 : : * @addr: the phy address
619 : : * @regnum: register number to read
620 : : *
621 : : * NOTE: MUST NOT be called from interrupt context,
622 : : * because the bus read/write functions may wait for an interrupt
623 : : * to conclude the operation.
624 : : */
625 : 3 : int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
626 : : {
627 : : int retval;
628 : :
629 : 3 : BUG_ON(in_interrupt());
630 : :
631 : 3 : mutex_lock(&bus->mdio_lock);
632 : 3 : retval = __mdiobus_read(bus, addr, regnum);
633 : 3 : mutex_unlock(&bus->mdio_lock);
634 : :
635 : 3 : return retval;
636 : : }
637 : : EXPORT_SYMBOL(mdiobus_read);
638 : :
639 : : /**
640 : : * mdiobus_write_nested - Nested version of the mdiobus_write function
641 : : * @bus: the mii_bus struct
642 : : * @addr: the phy address
643 : : * @regnum: register number to write
644 : : * @val: value to write to @regnum
645 : : *
646 : : * In case of nested MDIO bus access avoid lockdep false positives by
647 : : * using mutex_lock_nested().
648 : : *
649 : : * NOTE: MUST NOT be called from interrupt context,
650 : : * because the bus read/write functions may wait for an interrupt
651 : : * to conclude the operation.
652 : : */
653 : 0 : int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
654 : : {
655 : : int err;
656 : :
657 : 0 : BUG_ON(in_interrupt());
658 : :
659 : 0 : mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
660 : 0 : err = __mdiobus_write(bus, addr, regnum, val);
661 : 0 : mutex_unlock(&bus->mdio_lock);
662 : :
663 : 0 : return err;
664 : : }
665 : : EXPORT_SYMBOL(mdiobus_write_nested);
666 : :
667 : : /**
668 : : * mdiobus_write - Convenience function for writing a given MII mgmt register
669 : : * @bus: the mii_bus struct
670 : : * @addr: the phy address
671 : : * @regnum: register number to write
672 : : * @val: value to write to @regnum
673 : : *
674 : : * NOTE: MUST NOT be called from interrupt context,
675 : : * because the bus read/write functions may wait for an interrupt
676 : : * to conclude the operation.
677 : : */
678 : 0 : int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
679 : : {
680 : : int err;
681 : :
682 : 0 : BUG_ON(in_interrupt());
683 : :
684 : 0 : mutex_lock(&bus->mdio_lock);
685 : 0 : err = __mdiobus_write(bus, addr, regnum, val);
686 : 0 : mutex_unlock(&bus->mdio_lock);
687 : :
688 : 0 : return err;
689 : : }
690 : : EXPORT_SYMBOL(mdiobus_write);
691 : :
692 : : /**
693 : : * mdio_bus_match - determine if given MDIO driver supports the given
694 : : * MDIO device
695 : : * @dev: target MDIO device
696 : : * @drv: given MDIO driver
697 : : *
698 : : * Description: Given a MDIO device, and a MDIO driver, return 1 if
699 : : * the driver supports the device. Otherwise, return 0. This may
700 : : * require calling the devices own match function, since different classes
701 : : * of MDIO devices have different match criteria.
702 : : */
703 : 0 : static int mdio_bus_match(struct device *dev, struct device_driver *drv)
704 : : {
705 : : struct mdio_device *mdio = to_mdio_device(dev);
706 : :
707 : 0 : if (of_driver_match_device(dev, drv))
708 : : return 1;
709 : :
710 : 0 : if (mdio->bus_match)
711 : 0 : return mdio->bus_match(dev, drv);
712 : :
713 : : return 0;
714 : : }
715 : :
716 : 0 : static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env)
717 : : {
718 : : int rc;
719 : :
720 : : /* Some devices have extra OF data and an OF-style MODALIAS */
721 : 0 : rc = of_device_uevent_modalias(dev, env);
722 : 0 : if (rc != -ENODEV)
723 : 0 : return rc;
724 : :
725 : : return 0;
726 : : }
727 : :
728 : : struct bus_type mdio_bus_type = {
729 : : .name = "mdio_bus",
730 : : .match = mdio_bus_match,
731 : : .uevent = mdio_uevent,
732 : : };
733 : : EXPORT_SYMBOL(mdio_bus_type);
734 : :
735 : 3 : int __init mdio_bus_init(void)
736 : : {
737 : : int ret;
738 : :
739 : 3 : ret = class_register(&mdio_bus_class);
740 : 3 : if (!ret) {
741 : 3 : ret = bus_register(&mdio_bus_type);
742 : 3 : if (ret)
743 : 0 : class_unregister(&mdio_bus_class);
744 : : }
745 : :
746 : 3 : return ret;
747 : : }
748 : : EXPORT_SYMBOL_GPL(mdio_bus_init);
749 : :
750 : : #if IS_ENABLED(CONFIG_PHYLIB)
751 : 0 : void mdio_bus_exit(void)
752 : : {
753 : 0 : class_unregister(&mdio_bus_class);
754 : 0 : bus_unregister(&mdio_bus_type);
755 : 0 : }
756 : : EXPORT_SYMBOL_GPL(mdio_bus_exit);
757 : : #else
758 : : module_init(mdio_bus_init);
759 : : /* no module_exit, intentional */
760 : : MODULE_LICENSE("GPL");
761 : : MODULE_DESCRIPTION("MDIO bus/device layer");
762 : : #endif
|
