1 // SPDX-License-Identifier: GPL-2.0+
6 * Copyright (c) 2004 Freescale Semiconductor, Inc.
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <linux/delay.h>
12 #include <linux/device.h>
13 #include <linux/errno.h>
14 #include <linux/etherdevice.h>
15 #include <linux/ethtool.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/init.h>
18 #include <linux/interrupt.h>
20 #include <linux/kernel.h>
21 #include <linux/micrel_phy.h>
22 #include <linux/mii.h>
24 #include <linux/module.h>
25 #include <linux/netdevice.h>
26 #include <linux/of_device.h>
27 #include <linux/of_mdio.h>
28 #include <linux/phy.h>
29 #include <linux/reset.h>
30 #include <linux/skbuff.h>
31 #include <linux/slab.h>
32 #include <linux/spinlock.h>
33 #include <linux/string.h>
34 #include <linux/uaccess.h>
35 #include <linux/unistd.h>
37 #define CREATE_TRACE_POINTS
38 #include <trace/events/mdio.h>
40 #include "mdio-boardinfo.h"
42 static int mdiobus_register_gpiod(struct mdio_device
*mdiodev
)
44 /* Deassert the optional reset signal */
45 mdiodev
->reset_gpio
= gpiod_get_optional(&mdiodev
->dev
,
46 "reset", GPIOD_OUT_LOW
);
47 if (IS_ERR(mdiodev
->reset_gpio
))
48 return PTR_ERR(mdiodev
->reset_gpio
);
50 if (mdiodev
->reset_gpio
)
51 gpiod_set_consumer_name(mdiodev
->reset_gpio
, "PHY reset");
56 static int mdiobus_register_reset(struct mdio_device
*mdiodev
)
58 struct reset_control
*reset
;
60 reset
= reset_control_get_optional_exclusive(&mdiodev
->dev
, "phy");
62 return PTR_ERR(reset
);
64 mdiodev
->reset_ctrl
= reset
;
69 int mdiobus_register_device(struct mdio_device
*mdiodev
)
73 if (mdiodev
->bus
->mdio_map
[mdiodev
->addr
])
76 if (mdiodev
->flags
& MDIO_DEVICE_FLAG_PHY
) {
77 err
= mdiobus_register_gpiod(mdiodev
);
81 err
= mdiobus_register_reset(mdiodev
);
85 /* Assert the reset signal */
86 mdio_device_reset(mdiodev
, 1);
89 mdiodev
->bus
->mdio_map
[mdiodev
->addr
] = mdiodev
;
93 EXPORT_SYMBOL(mdiobus_register_device
);
95 int mdiobus_unregister_device(struct mdio_device
*mdiodev
)
97 if (mdiodev
->bus
->mdio_map
[mdiodev
->addr
] != mdiodev
)
100 reset_control_put(mdiodev
->reset_ctrl
);
102 mdiodev
->bus
->mdio_map
[mdiodev
->addr
] = NULL
;
106 EXPORT_SYMBOL(mdiobus_unregister_device
);
108 static struct mdio_device
*mdiobus_find_device(struct mii_bus
*bus
, int addr
)
110 bool addr_valid
= addr
>= 0 && addr
< ARRAY_SIZE(bus
->mdio_map
);
112 if (WARN_ONCE(!addr_valid
, "addr %d out of range\n", addr
))
115 return bus
->mdio_map
[addr
];
118 struct phy_device
*mdiobus_get_phy(struct mii_bus
*bus
, int addr
)
120 struct mdio_device
*mdiodev
;
122 mdiodev
= mdiobus_find_device(bus
, addr
);
126 if (!(mdiodev
->flags
& MDIO_DEVICE_FLAG_PHY
))
129 return container_of(mdiodev
, struct phy_device
, mdio
);
131 EXPORT_SYMBOL(mdiobus_get_phy
);
133 bool mdiobus_is_registered_device(struct mii_bus
*bus
, int addr
)
135 return mdiobus_find_device(bus
, addr
) != NULL
;
137 EXPORT_SYMBOL(mdiobus_is_registered_device
);
140 * mdiobus_alloc_size - allocate a mii_bus structure
141 * @size: extra amount of memory to allocate for private storage.
142 * If non-zero, then bus->priv is points to that memory.
144 * Description: called by a bus driver to allocate an mii_bus
145 * structure to fill in.
147 struct mii_bus
*mdiobus_alloc_size(size_t size
)
150 size_t aligned_size
= ALIGN(sizeof(*bus
), NETDEV_ALIGN
);
154 /* If we alloc extra space, it should be aligned */
156 alloc_size
= aligned_size
+ size
;
158 alloc_size
= sizeof(*bus
);
160 bus
= kzalloc(alloc_size
, GFP_KERNEL
);
164 bus
->state
= MDIOBUS_ALLOCATED
;
166 bus
->priv
= (void *)bus
+ aligned_size
;
168 /* Initialise the interrupts to polling and 64-bit seqcounts */
169 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
170 bus
->irq
[i
] = PHY_POLL
;
171 u64_stats_init(&bus
->stats
[i
].syncp
);
176 EXPORT_SYMBOL(mdiobus_alloc_size
);
179 * mdiobus_release - mii_bus device release callback
180 * @d: the target struct device that contains the mii_bus
182 * Description: called when the last reference to an mii_bus is
183 * dropped, to free the underlying memory.
185 static void mdiobus_release(struct device
*d
)
187 struct mii_bus
*bus
= to_mii_bus(d
);
189 WARN(bus
->state
!= MDIOBUS_RELEASED
&&
190 /* for compatibility with error handling in drivers */
191 bus
->state
!= MDIOBUS_ALLOCATED
,
192 "%s: not in RELEASED or ALLOCATED state\n",
195 if (bus
->state
== MDIOBUS_RELEASED
)
196 fwnode_handle_put(dev_fwnode(d
));
201 struct mdio_bus_stat_attr
{
203 unsigned int field_offset
;
206 static u64
mdio_bus_get_stat(struct mdio_bus_stats
*s
, unsigned int offset
)
208 const char *p
= (const char *)s
+ offset
;
213 start
= u64_stats_fetch_begin(&s
->syncp
);
214 val
= u64_stats_read((const u64_stats_t
*)p
);
215 } while (u64_stats_fetch_retry(&s
->syncp
, start
));
220 static u64
mdio_bus_get_global_stat(struct mii_bus
*bus
, unsigned int offset
)
225 for (i
= 0; i
< PHY_MAX_ADDR
; i
++)
226 val
+= mdio_bus_get_stat(&bus
->stats
[i
], offset
);
231 static ssize_t
mdio_bus_stat_field_show(struct device
*dev
,
232 struct device_attribute
*attr
,
235 struct mii_bus
*bus
= to_mii_bus(dev
);
236 struct mdio_bus_stat_attr
*sattr
;
237 struct dev_ext_attribute
*eattr
;
240 eattr
= container_of(attr
, struct dev_ext_attribute
, attr
);
244 val
= mdio_bus_get_global_stat(bus
, sattr
->field_offset
);
246 val
= mdio_bus_get_stat(&bus
->stats
[sattr
->addr
],
247 sattr
->field_offset
);
249 return sysfs_emit(buf
, "%llu\n", val
);
252 static ssize_t
mdio_bus_device_stat_field_show(struct device
*dev
,
253 struct device_attribute
*attr
,
256 struct mdio_device
*mdiodev
= to_mdio_device(dev
);
257 struct mii_bus
*bus
= mdiodev
->bus
;
258 struct mdio_bus_stat_attr
*sattr
;
259 struct dev_ext_attribute
*eattr
;
260 int addr
= mdiodev
->addr
;
263 eattr
= container_of(attr
, struct dev_ext_attribute
, attr
);
266 val
= mdio_bus_get_stat(&bus
->stats
[addr
], sattr
->field_offset
);
268 return sysfs_emit(buf
, "%llu\n", val
);
271 #define MDIO_BUS_STATS_ATTR_DECL(field, file) \
272 static struct dev_ext_attribute dev_attr_mdio_bus_##field = { \
273 .attr = { .attr = { .name = file, .mode = 0444 }, \
274 .show = mdio_bus_stat_field_show, \
276 .var = &((struct mdio_bus_stat_attr) { \
277 -1, offsetof(struct mdio_bus_stats, field) \
280 static struct dev_ext_attribute dev_attr_mdio_bus_device_##field = { \
281 .attr = { .attr = { .name = file, .mode = 0444 }, \
282 .show = mdio_bus_device_stat_field_show, \
284 .var = &((struct mdio_bus_stat_attr) { \
285 -1, offsetof(struct mdio_bus_stats, field) \
289 #define MDIO_BUS_STATS_ATTR(field) \
290 MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
292 MDIO_BUS_STATS_ATTR(transfers
);
293 MDIO_BUS_STATS_ATTR(errors
);
294 MDIO_BUS_STATS_ATTR(writes
);
295 MDIO_BUS_STATS_ATTR(reads
);
297 #define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file) \
298 static struct dev_ext_attribute dev_attr_mdio_bus_addr_##field##_##addr = { \
299 .attr = { .attr = { .name = file, .mode = 0444 }, \
300 .show = mdio_bus_stat_field_show, \
302 .var = &((struct mdio_bus_stat_attr) { \
303 addr, offsetof(struct mdio_bus_stats, field) \
307 #define MDIO_BUS_STATS_ADDR_ATTR(field, addr) \
308 MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, \
309 __stringify(field) "_" __stringify(addr))
311 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr) \
312 MDIO_BUS_STATS_ADDR_ATTR(transfers, addr); \
313 MDIO_BUS_STATS_ADDR_ATTR(errors, addr); \
314 MDIO_BUS_STATS_ADDR_ATTR(writes, addr); \
315 MDIO_BUS_STATS_ADDR_ATTR(reads, addr) \
317 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0);
318 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1);
319 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2);
320 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3);
321 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4);
322 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5);
323 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6);
324 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7);
325 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8);
326 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9);
327 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10);
328 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11);
329 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12);
330 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13);
331 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14);
332 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15);
333 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16);
334 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17);
335 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18);
336 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19);
337 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20);
338 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21);
339 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22);
340 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23);
341 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24);
342 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25);
343 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26);
344 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27);
345 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28);
346 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29);
347 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30);
348 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31);
350 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr) \
351 &dev_attr_mdio_bus_addr_transfers_##addr.attr.attr, \
352 &dev_attr_mdio_bus_addr_errors_##addr.attr.attr, \
353 &dev_attr_mdio_bus_addr_writes_##addr.attr.attr, \
354 &dev_attr_mdio_bus_addr_reads_##addr.attr.attr \
356 static struct attribute *mdio_bus_statistics_attrs[] = {
357 &dev_attr_mdio_bus_transfers
.attr
.attr
,
358 &dev_attr_mdio_bus_errors
.attr
.attr
,
359 &dev_attr_mdio_bus_writes
.attr
.attr
,
360 &dev_attr_mdio_bus_reads
.attr
.attr
,
361 MDIO_BUS_STATS_ADDR_ATTR_GROUP(0),
362 MDIO_BUS_STATS_ADDR_ATTR_GROUP(1),
363 MDIO_BUS_STATS_ADDR_ATTR_GROUP(2),
364 MDIO_BUS_STATS_ADDR_ATTR_GROUP(3),
365 MDIO_BUS_STATS_ADDR_ATTR_GROUP(4),
366 MDIO_BUS_STATS_ADDR_ATTR_GROUP(5),
367 MDIO_BUS_STATS_ADDR_ATTR_GROUP(6),
368 MDIO_BUS_STATS_ADDR_ATTR_GROUP(7),
369 MDIO_BUS_STATS_ADDR_ATTR_GROUP(8),
370 MDIO_BUS_STATS_ADDR_ATTR_GROUP(9),
371 MDIO_BUS_STATS_ADDR_ATTR_GROUP(10),
372 MDIO_BUS_STATS_ADDR_ATTR_GROUP(11),
373 MDIO_BUS_STATS_ADDR_ATTR_GROUP(12),
374 MDIO_BUS_STATS_ADDR_ATTR_GROUP(13),
375 MDIO_BUS_STATS_ADDR_ATTR_GROUP(14),
376 MDIO_BUS_STATS_ADDR_ATTR_GROUP(15),
377 MDIO_BUS_STATS_ADDR_ATTR_GROUP(16),
378 MDIO_BUS_STATS_ADDR_ATTR_GROUP(17),
379 MDIO_BUS_STATS_ADDR_ATTR_GROUP(18),
380 MDIO_BUS_STATS_ADDR_ATTR_GROUP(19),
381 MDIO_BUS_STATS_ADDR_ATTR_GROUP(20),
382 MDIO_BUS_STATS_ADDR_ATTR_GROUP(21),
383 MDIO_BUS_STATS_ADDR_ATTR_GROUP(22),
384 MDIO_BUS_STATS_ADDR_ATTR_GROUP(23),
385 MDIO_BUS_STATS_ADDR_ATTR_GROUP(24),
386 MDIO_BUS_STATS_ADDR_ATTR_GROUP(25),
387 MDIO_BUS_STATS_ADDR_ATTR_GROUP(26),
388 MDIO_BUS_STATS_ADDR_ATTR_GROUP(27),
389 MDIO_BUS_STATS_ADDR_ATTR_GROUP(28),
390 MDIO_BUS_STATS_ADDR_ATTR_GROUP(29),
391 MDIO_BUS_STATS_ADDR_ATTR_GROUP(30),
392 MDIO_BUS_STATS_ADDR_ATTR_GROUP(31),
396 static const struct attribute_group mdio_bus_statistics_group
= {
397 .name
= "statistics",
398 .attrs
= mdio_bus_statistics_attrs
,
401 static const struct attribute_group
*mdio_bus_groups
[] = {
402 &mdio_bus_statistics_group
,
406 static struct class mdio_bus_class
= {
408 .dev_release
= mdiobus_release
,
409 .dev_groups
= mdio_bus_groups
,
413 * mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
414 * @mdio_name: The name of a mdiobus.
416 * Returns a reference to the mii_bus, or NULL if none found. The
417 * embedded struct device will have its reference count incremented,
418 * and this must be put_deviced'ed once the bus is finished with.
420 struct mii_bus
*mdio_find_bus(const char *mdio_name
)
424 d
= class_find_device_by_name(&mdio_bus_class
, mdio_name
);
425 return d
? to_mii_bus(d
) : NULL
;
427 EXPORT_SYMBOL(mdio_find_bus
);
429 #if IS_ENABLED(CONFIG_OF_MDIO)
431 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
432 * @mdio_bus_np: Pointer to the mii_bus.
434 * Returns a reference to the mii_bus, or NULL if none found. The
435 * embedded struct device will have its reference count incremented,
436 * and this must be put once the bus is finished with.
438 * Because the association of a device_node and mii_bus is made via
439 * of_mdiobus_register(), the mii_bus cannot be found before it is
440 * registered with of_mdiobus_register().
443 struct mii_bus
*of_mdio_find_bus(struct device_node
*mdio_bus_np
)
450 d
= class_find_device_by_of_node(&mdio_bus_class
, mdio_bus_np
);
451 return d
? to_mii_bus(d
) : NULL
;
453 EXPORT_SYMBOL(of_mdio_find_bus
);
455 /* Walk the list of subnodes of a mdio bus and look for a node that
456 * matches the mdio device's address with its 'reg' property. If
457 * found, set the of_node pointer for the mdio device. This allows
458 * auto-probed phy devices to be supplied with information passed in
460 * If a PHY package is found, PHY is searched also there.
462 static int of_mdiobus_find_phy(struct device
*dev
, struct mdio_device
*mdiodev
,
463 struct device_node
*np
)
465 struct device_node
*child
;
467 for_each_available_child_of_node(np
, child
) {
470 if (of_node_name_eq(child
, "ethernet-phy-package")) {
471 /* Validate PHY package reg presence */
472 if (!of_property_present(child
, "reg")) {
477 if (!of_mdiobus_find_phy(dev
, mdiodev
, child
)) {
478 /* The refcount for the PHY package will be
479 * incremented later when PHY join the Package.
488 addr
= of_mdio_parse_addr(dev
, child
);
492 if (addr
== mdiodev
->addr
) {
493 device_set_node(dev
, of_fwnode_handle(child
));
494 /* The refcount on "child" is passed to the mdio
495 * device. Do _not_ use of_node_put(child) here.
504 static void of_mdiobus_link_mdiodev(struct mii_bus
*bus
,
505 struct mdio_device
*mdiodev
)
507 struct device
*dev
= &mdiodev
->dev
;
509 if (dev
->of_node
|| !bus
->dev
.of_node
)
512 of_mdiobus_find_phy(dev
, mdiodev
, bus
->dev
.of_node
);
514 #else /* !IS_ENABLED(CONFIG_OF_MDIO) */
515 static inline void of_mdiobus_link_mdiodev(struct mii_bus
*mdio
,
516 struct mdio_device
*mdiodev
)
522 * mdiobus_create_device - create a full MDIO device given
523 * a mdio_board_info structure
524 * @bus: MDIO bus to create the devices on
525 * @bi: mdio_board_info structure describing the devices
527 * Returns 0 on success or < 0 on error.
529 static int mdiobus_create_device(struct mii_bus
*bus
,
530 struct mdio_board_info
*bi
)
532 struct mdio_device
*mdiodev
;
535 mdiodev
= mdio_device_create(bus
, bi
->mdio_addr
);
539 strscpy(mdiodev
->modalias
, bi
->modalias
,
540 sizeof(mdiodev
->modalias
));
541 mdiodev
->bus_match
= mdio_device_bus_match
;
542 mdiodev
->dev
.platform_data
= (void *)bi
->platform_data
;
544 ret
= mdio_device_register(mdiodev
);
546 mdio_device_free(mdiodev
);
551 static struct phy_device
*mdiobus_scan(struct mii_bus
*bus
, int addr
, bool c45
)
553 struct phy_device
*phydev
= ERR_PTR(-ENODEV
);
556 phydev
= get_phy_device(bus
, addr
, c45
);
560 /* For DT, see if the auto-probed phy has a corresponding child
561 * in the bus node, and set the of_node pointer in this case.
563 of_mdiobus_link_mdiodev(bus
, &phydev
->mdio
);
565 err
= phy_device_register(phydev
);
567 phy_device_free(phydev
);
568 return ERR_PTR(-ENODEV
);
575 * mdiobus_scan_c22 - scan one address on a bus for C22 MDIO devices.
576 * @bus: mii_bus to scan
577 * @addr: address on bus to scan
579 * This function scans one address on the MDIO bus, looking for
580 * devices which can be identified using a vendor/product ID in
581 * registers 2 and 3. Not all MDIO devices have such registers, but
582 * PHY devices typically do. Hence this function assumes anything
583 * found is a PHY, or can be treated as a PHY. Other MDIO devices,
584 * such as switches, will probably not be found during the scan.
586 struct phy_device
*mdiobus_scan_c22(struct mii_bus
*bus
, int addr
)
588 return mdiobus_scan(bus
, addr
, false);
590 EXPORT_SYMBOL(mdiobus_scan_c22
);
593 * mdiobus_scan_c45 - scan one address on a bus for C45 MDIO devices.
594 * @bus: mii_bus to scan
595 * @addr: address on bus to scan
597 * This function scans one address on the MDIO bus, looking for
598 * devices which can be identified using a vendor/product ID in
599 * registers 2 and 3. Not all MDIO devices have such registers, but
600 * PHY devices typically do. Hence this function assumes anything
601 * found is a PHY, or can be treated as a PHY. Other MDIO devices,
602 * such as switches, will probably not be found during the scan.
604 static struct phy_device
*mdiobus_scan_c45(struct mii_bus
*bus
, int addr
)
606 return mdiobus_scan(bus
, addr
, true);
609 static int mdiobus_scan_bus_c22(struct mii_bus
*bus
)
613 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
614 if ((bus
->phy_mask
& BIT(i
)) == 0) {
615 struct phy_device
*phydev
;
617 phydev
= mdiobus_scan_c22(bus
, i
);
618 if (IS_ERR(phydev
) && (PTR_ERR(phydev
) != -ENODEV
))
619 return PTR_ERR(phydev
);
625 static int mdiobus_scan_bus_c45(struct mii_bus
*bus
)
629 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
630 if ((bus
->phy_mask
& BIT(i
)) == 0) {
631 struct phy_device
*phydev
;
633 /* Don't scan C45 if we already have a C22 device */
634 if (bus
->mdio_map
[i
])
637 phydev
= mdiobus_scan_c45(bus
, i
);
638 if (IS_ERR(phydev
) && (PTR_ERR(phydev
) != -ENODEV
))
639 return PTR_ERR(phydev
);
645 /* There are some C22 PHYs which do bad things when where is a C45
646 * transaction on the bus, like accepting a read themselves, and
647 * stomping over the true devices reply, to performing a write to
648 * themselves which was intended for another device. Now that C22
649 * devices have been found, see if any of them are bad for C45, and if we
650 * should skip the C45 scan.
652 static bool mdiobus_prevent_c45_scan(struct mii_bus
*bus
)
656 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
657 struct phy_device
*phydev
;
660 phydev
= mdiobus_get_phy(bus
, i
);
663 oui
= phydev
->phy_id
>> 10;
665 if (oui
== MICREL_OUI
)
672 * __mdiobus_register - bring up all the PHYs on a given bus and attach them to bus
673 * @bus: target mii_bus
674 * @owner: module containing bus accessor functions
676 * Description: Called by a bus driver to bring up all the PHYs
677 * on a given bus, and attach them to the bus. Drivers should use
678 * mdiobus_register() rather than __mdiobus_register() unless they
679 * need to pass a specific owner module. MDIO devices which are not
680 * PHYs will not be brought up by this function. They are expected
681 * to be explicitly listed in DT and instantiated by of_mdiobus_register().
683 * Returns 0 on success or < 0 on error.
685 int __mdiobus_register(struct mii_bus
*bus
, struct module
*owner
)
687 struct mdio_device
*mdiodev
;
688 struct gpio_desc
*gpiod
;
689 bool prevent_c45_scan
;
692 if (!bus
|| !bus
->name
)
695 /* An access method always needs both read and write operations */
696 if (!!bus
->read
!= !!bus
->write
|| !!bus
->read_c45
!= !!bus
->write_c45
)
699 /* At least one method is mandatory */
700 if (!bus
->read
&& !bus
->read_c45
)
703 if (bus
->parent
&& bus
->parent
->of_node
)
704 bus
->parent
->of_node
->fwnode
.flags
|=
705 FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD
;
707 WARN(bus
->state
!= MDIOBUS_ALLOCATED
&&
708 bus
->state
!= MDIOBUS_UNREGISTERED
,
709 "%s: not in ALLOCATED or UNREGISTERED state\n", bus
->id
);
712 bus
->dev
.parent
= bus
->parent
;
713 bus
->dev
.class = &mdio_bus_class
;
714 bus
->dev
.groups
= NULL
;
715 dev_set_name(&bus
->dev
, "%s", bus
->id
);
717 /* If the bus state is allocated, we're registering a fresh bus
718 * that may have a fwnode associated with it. Grab a reference
719 * to the fwnode. This will be dropped when the bus is released.
720 * If the bus was set to unregistered, it means that the bus was
721 * previously registered, and we've already grabbed a reference.
723 if (bus
->state
== MDIOBUS_ALLOCATED
)
724 fwnode_handle_get(dev_fwnode(&bus
->dev
));
726 /* We need to set state to MDIOBUS_UNREGISTERED to correctly release
727 * the device in mdiobus_free()
729 * State will be updated later in this function in case of success
731 bus
->state
= MDIOBUS_UNREGISTERED
;
733 err
= device_register(&bus
->dev
);
735 pr_err("mii_bus %s failed to register\n", bus
->id
);
739 mutex_init(&bus
->mdio_lock
);
740 mutex_init(&bus
->shared_lock
);
742 /* assert bus level PHY GPIO reset */
743 gpiod
= devm_gpiod_get_optional(&bus
->dev
, "reset", GPIOD_OUT_HIGH
);
745 err
= dev_err_probe(&bus
->dev
, PTR_ERR(gpiod
),
746 "mii_bus %s couldn't get reset GPIO\n",
748 device_del(&bus
->dev
);
751 bus
->reset_gpiod
= gpiod
;
752 fsleep(bus
->reset_delay_us
);
753 gpiod_set_value_cansleep(gpiod
, 0);
754 if (bus
->reset_post_delay_us
> 0)
755 fsleep(bus
->reset_post_delay_us
);
759 err
= bus
->reset(bus
);
761 goto error_reset_gpiod
;
765 err
= mdiobus_scan_bus_c22(bus
);
770 prevent_c45_scan
= mdiobus_prevent_c45_scan(bus
);
772 if (!prevent_c45_scan
&& bus
->read_c45
) {
773 err
= mdiobus_scan_bus_c45(bus
);
778 mdiobus_setup_mdiodev_from_board_info(bus
, mdiobus_create_device
);
780 bus
->state
= MDIOBUS_REGISTERED
;
781 dev_dbg(&bus
->dev
, "probed\n");
785 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
786 mdiodev
= bus
->mdio_map
[i
];
790 mdiodev
->device_remove(mdiodev
);
791 mdiodev
->device_free(mdiodev
);
794 /* Put PHYs in RESET to save power */
795 if (bus
->reset_gpiod
)
796 gpiod_set_value_cansleep(bus
->reset_gpiod
, 1);
798 device_del(&bus
->dev
);
801 EXPORT_SYMBOL(__mdiobus_register
);
803 void mdiobus_unregister(struct mii_bus
*bus
)
805 struct mdio_device
*mdiodev
;
808 if (WARN_ON_ONCE(bus
->state
!= MDIOBUS_REGISTERED
))
810 bus
->state
= MDIOBUS_UNREGISTERED
;
812 for (i
= 0; i
< PHY_MAX_ADDR
; i
++) {
813 mdiodev
= bus
->mdio_map
[i
];
817 if (mdiodev
->reset_gpio
)
818 gpiod_put(mdiodev
->reset_gpio
);
820 mdiodev
->device_remove(mdiodev
);
821 mdiodev
->device_free(mdiodev
);
824 /* Put PHYs in RESET to save power */
825 if (bus
->reset_gpiod
)
826 gpiod_set_value_cansleep(bus
->reset_gpiod
, 1);
828 device_del(&bus
->dev
);
830 EXPORT_SYMBOL(mdiobus_unregister
);
833 * mdiobus_free - free a struct mii_bus
834 * @bus: mii_bus to free
836 * This function releases the reference to the underlying device
837 * object in the mii_bus. If this is the last reference, the mii_bus
840 void mdiobus_free(struct mii_bus
*bus
)
842 /* For compatibility with error handling in drivers. */
843 if (bus
->state
== MDIOBUS_ALLOCATED
) {
848 WARN(bus
->state
!= MDIOBUS_UNREGISTERED
,
849 "%s: not in UNREGISTERED state\n", bus
->id
);
850 bus
->state
= MDIOBUS_RELEASED
;
852 put_device(&bus
->dev
);
854 EXPORT_SYMBOL(mdiobus_free
);
856 static void mdiobus_stats_acct(struct mdio_bus_stats
*stats
, bool op
, int ret
)
859 u64_stats_update_begin(&stats
->syncp
);
861 u64_stats_inc(&stats
->transfers
);
863 u64_stats_inc(&stats
->errors
);
868 u64_stats_inc(&stats
->reads
);
870 u64_stats_inc(&stats
->writes
);
872 u64_stats_update_end(&stats
->syncp
);
877 * __mdiobus_read - Unlocked version of the mdiobus_read function
878 * @bus: the mii_bus struct
879 * @addr: the phy address
880 * @regnum: register number to read
882 * Read a MDIO bus register. Caller must hold the mdio bus lock.
884 * NOTE: MUST NOT be called from interrupt context.
886 int __mdiobus_read(struct mii_bus
*bus
, int addr
, u32 regnum
)
890 lockdep_assert_held_once(&bus
->mdio_lock
);
893 retval
= bus
->read(bus
, addr
, regnum
);
895 retval
= -EOPNOTSUPP
;
897 trace_mdio_access(bus
, 1, addr
, regnum
, retval
, retval
);
898 mdiobus_stats_acct(&bus
->stats
[addr
], true, retval
);
902 EXPORT_SYMBOL(__mdiobus_read
);
905 * __mdiobus_write - Unlocked version of the mdiobus_write function
906 * @bus: the mii_bus struct
907 * @addr: the phy address
908 * @regnum: register number to write
909 * @val: value to write to @regnum
911 * Write a MDIO bus register. Caller must hold the mdio bus lock.
913 * NOTE: MUST NOT be called from interrupt context.
915 int __mdiobus_write(struct mii_bus
*bus
, int addr
, u32 regnum
, u16 val
)
919 lockdep_assert_held_once(&bus
->mdio_lock
);
922 err
= bus
->write(bus
, addr
, regnum
, val
);
926 trace_mdio_access(bus
, 0, addr
, regnum
, val
, err
);
927 mdiobus_stats_acct(&bus
->stats
[addr
], false, err
);
931 EXPORT_SYMBOL(__mdiobus_write
);
934 * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function
935 * @bus: the mii_bus struct
936 * @addr: the phy address
937 * @regnum: register number to modify
938 * @mask: bit mask of bits to clear
939 * @set: bit mask of bits to set
941 * Read, modify, and if any change, write the register value back to the
942 * device. Any error returns a negative number.
944 * NOTE: MUST NOT be called from interrupt context.
946 int __mdiobus_modify_changed(struct mii_bus
*bus
, int addr
, u32 regnum
,
951 ret
= __mdiobus_read(bus
, addr
, regnum
);
955 new = (ret
& ~mask
) | set
;
959 ret
= __mdiobus_write(bus
, addr
, regnum
, new);
961 return ret
< 0 ? ret
: 1;
963 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed
);
966 * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function
967 * @bus: the mii_bus struct
968 * @addr: the phy address
969 * @devad: device address to read
970 * @regnum: register number to read
972 * Read a MDIO bus register. Caller must hold the mdio bus lock.
974 * NOTE: MUST NOT be called from interrupt context.
976 int __mdiobus_c45_read(struct mii_bus
*bus
, int addr
, int devad
, u32 regnum
)
980 lockdep_assert_held_once(&bus
->mdio_lock
);
983 retval
= bus
->read_c45(bus
, addr
, devad
, regnum
);
985 retval
= -EOPNOTSUPP
;
987 trace_mdio_access(bus
, 1, addr
, regnum
, retval
, retval
);
988 mdiobus_stats_acct(&bus
->stats
[addr
], true, retval
);
992 EXPORT_SYMBOL(__mdiobus_c45_read
);
995 * __mdiobus_c45_write - Unlocked version of the mdiobus_write function
996 * @bus: the mii_bus struct
997 * @addr: the phy address
998 * @devad: device address to read
999 * @regnum: register number to write
1000 * @val: value to write to @regnum
1002 * Write a MDIO bus register. Caller must hold the mdio bus lock.
1004 * NOTE: MUST NOT be called from interrupt context.
1006 int __mdiobus_c45_write(struct mii_bus
*bus
, int addr
, int devad
, u32 regnum
,
1011 lockdep_assert_held_once(&bus
->mdio_lock
);
1014 err
= bus
->write_c45(bus
, addr
, devad
, regnum
, val
);
1018 trace_mdio_access(bus
, 0, addr
, regnum
, val
, err
);
1019 mdiobus_stats_acct(&bus
->stats
[addr
], false, err
);
1023 EXPORT_SYMBOL(__mdiobus_c45_write
);
1026 * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function
1027 * @bus: the mii_bus struct
1028 * @addr: the phy address
1029 * @devad: device address to read
1030 * @regnum: register number to modify
1031 * @mask: bit mask of bits to clear
1032 * @set: bit mask of bits to set
1034 * Read, modify, and if any change, write the register value back to the
1035 * device. Any error returns a negative number.
1037 * NOTE: MUST NOT be called from interrupt context.
1039 static int __mdiobus_c45_modify_changed(struct mii_bus
*bus
, int addr
,
1040 int devad
, u32 regnum
, u16 mask
,
1045 ret
= __mdiobus_c45_read(bus
, addr
, devad
, regnum
);
1049 new = (ret
& ~mask
) | set
;
1053 ret
= __mdiobus_c45_write(bus
, addr
, devad
, regnum
, new);
1055 return ret
< 0 ? ret
: 1;
1059 * mdiobus_read_nested - Nested version of the mdiobus_read function
1060 * @bus: the mii_bus struct
1061 * @addr: the phy address
1062 * @regnum: register number to read
1064 * In case of nested MDIO bus access avoid lockdep false positives by
1065 * using mutex_lock_nested().
1067 * NOTE: MUST NOT be called from interrupt context,
1068 * because the bus read/write functions may wait for an interrupt
1069 * to conclude the operation.
1071 int mdiobus_read_nested(struct mii_bus
*bus
, int addr
, u32 regnum
)
1075 mutex_lock_nested(&bus
->mdio_lock
, MDIO_MUTEX_NESTED
);
1076 retval
= __mdiobus_read(bus
, addr
, regnum
);
1077 mutex_unlock(&bus
->mdio_lock
);
1081 EXPORT_SYMBOL(mdiobus_read_nested
);
1084 * mdiobus_read - Convenience function for reading a given MII mgmt register
1085 * @bus: the mii_bus struct
1086 * @addr: the phy address
1087 * @regnum: register number to read
1089 * NOTE: MUST NOT be called from interrupt context,
1090 * because the bus read/write functions may wait for an interrupt
1091 * to conclude the operation.
1093 int mdiobus_read(struct mii_bus
*bus
, int addr
, u32 regnum
)
1097 mutex_lock(&bus
->mdio_lock
);
1098 retval
= __mdiobus_read(bus
, addr
, regnum
);
1099 mutex_unlock(&bus
->mdio_lock
);
1103 EXPORT_SYMBOL(mdiobus_read
);
1106 * mdiobus_c45_read - Convenience function for reading a given MII mgmt register
1107 * @bus: the mii_bus struct
1108 * @addr: the phy address
1109 * @devad: device address to read
1110 * @regnum: register number to read
1112 * NOTE: MUST NOT be called from interrupt context,
1113 * because the bus read/write functions may wait for an interrupt
1114 * to conclude the operation.
1116 int mdiobus_c45_read(struct mii_bus
*bus
, int addr
, int devad
, u32 regnum
)
1120 mutex_lock(&bus
->mdio_lock
);
1121 retval
= __mdiobus_c45_read(bus
, addr
, devad
, regnum
);
1122 mutex_unlock(&bus
->mdio_lock
);
1126 EXPORT_SYMBOL(mdiobus_c45_read
);
1129 * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function
1130 * @bus: the mii_bus struct
1131 * @addr: the phy address
1132 * @devad: device address to read
1133 * @regnum: register number to read
1135 * In case of nested MDIO bus access avoid lockdep false positives by
1136 * using mutex_lock_nested().
1138 * NOTE: MUST NOT be called from interrupt context,
1139 * because the bus read/write functions may wait for an interrupt
1140 * to conclude the operation.
1142 int mdiobus_c45_read_nested(struct mii_bus
*bus
, int addr
, int devad
,
1147 mutex_lock_nested(&bus
->mdio_lock
, MDIO_MUTEX_NESTED
);
1148 retval
= __mdiobus_c45_read(bus
, addr
, devad
, regnum
);
1149 mutex_unlock(&bus
->mdio_lock
);
1153 EXPORT_SYMBOL(mdiobus_c45_read_nested
);
1156 * mdiobus_write_nested - Nested version of the mdiobus_write function
1157 * @bus: the mii_bus struct
1158 * @addr: the phy address
1159 * @regnum: register number to write
1160 * @val: value to write to @regnum
1162 * In case of nested MDIO bus access avoid lockdep false positives by
1163 * using mutex_lock_nested().
1165 * NOTE: MUST NOT be called from interrupt context,
1166 * because the bus read/write functions may wait for an interrupt
1167 * to conclude the operation.
1169 int mdiobus_write_nested(struct mii_bus
*bus
, int addr
, u32 regnum
, u16 val
)
1173 mutex_lock_nested(&bus
->mdio_lock
, MDIO_MUTEX_NESTED
);
1174 err
= __mdiobus_write(bus
, addr
, regnum
, val
);
1175 mutex_unlock(&bus
->mdio_lock
);
1179 EXPORT_SYMBOL(mdiobus_write_nested
);
1182 * mdiobus_write - Convenience function for writing a given MII mgmt register
1183 * @bus: the mii_bus struct
1184 * @addr: the phy address
1185 * @regnum: register number to write
1186 * @val: value to write to @regnum
1188 * NOTE: MUST NOT be called from interrupt context,
1189 * because the bus read/write functions may wait for an interrupt
1190 * to conclude the operation.
1192 int mdiobus_write(struct mii_bus
*bus
, int addr
, u32 regnum
, u16 val
)
1196 mutex_lock(&bus
->mdio_lock
);
1197 err
= __mdiobus_write(bus
, addr
, regnum
, val
);
1198 mutex_unlock(&bus
->mdio_lock
);
1202 EXPORT_SYMBOL(mdiobus_write
);
1205 * mdiobus_c45_write - Convenience function for writing a given MII mgmt register
1206 * @bus: the mii_bus struct
1207 * @addr: the phy address
1208 * @devad: device address to read
1209 * @regnum: register number to write
1210 * @val: value to write to @regnum
1212 * NOTE: MUST NOT be called from interrupt context,
1213 * because the bus read/write functions may wait for an interrupt
1214 * to conclude the operation.
1216 int mdiobus_c45_write(struct mii_bus
*bus
, int addr
, int devad
, u32 regnum
,
1221 mutex_lock(&bus
->mdio_lock
);
1222 err
= __mdiobus_c45_write(bus
, addr
, devad
, regnum
, val
);
1223 mutex_unlock(&bus
->mdio_lock
);
1227 EXPORT_SYMBOL(mdiobus_c45_write
);
1230 * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function
1231 * @bus: the mii_bus struct
1232 * @addr: the phy address
1233 * @devad: device address to read
1234 * @regnum: register number to write
1235 * @val: value to write to @regnum
1237 * In case of nested MDIO bus access avoid lockdep false positives by
1238 * using mutex_lock_nested().
1240 * NOTE: MUST NOT be called from interrupt context,
1241 * because the bus read/write functions may wait for an interrupt
1242 * to conclude the operation.
1244 int mdiobus_c45_write_nested(struct mii_bus
*bus
, int addr
, int devad
,
1245 u32 regnum
, u16 val
)
1249 mutex_lock_nested(&bus
->mdio_lock
, MDIO_MUTEX_NESTED
);
1250 err
= __mdiobus_c45_write(bus
, addr
, devad
, regnum
, val
);
1251 mutex_unlock(&bus
->mdio_lock
);
1255 EXPORT_SYMBOL(mdiobus_c45_write_nested
);
1258 * __mdiobus_modify - Convenience function for modifying a given mdio device
1260 * @bus: the mii_bus struct
1261 * @addr: the phy address
1262 * @regnum: register number to write
1263 * @mask: bit mask of bits to clear
1264 * @set: bit mask of bits to set
1266 int __mdiobus_modify(struct mii_bus
*bus
, int addr
, u32 regnum
, u16 mask
,
1271 err
= __mdiobus_modify_changed(bus
, addr
, regnum
, mask
, set
);
1273 return err
< 0 ? err
: 0;
1275 EXPORT_SYMBOL_GPL(__mdiobus_modify
);
1278 * mdiobus_modify - Convenience function for modifying a given mdio device
1280 * @bus: the mii_bus struct
1281 * @addr: the phy address
1282 * @regnum: register number to write
1283 * @mask: bit mask of bits to clear
1284 * @set: bit mask of bits to set
1286 int mdiobus_modify(struct mii_bus
*bus
, int addr
, u32 regnum
, u16 mask
, u16 set
)
1290 mutex_lock(&bus
->mdio_lock
);
1291 err
= __mdiobus_modify(bus
, addr
, regnum
, mask
, set
);
1292 mutex_unlock(&bus
->mdio_lock
);
1296 EXPORT_SYMBOL_GPL(mdiobus_modify
);
1299 * mdiobus_c45_modify - Convenience function for modifying a given mdio device
1301 * @bus: the mii_bus struct
1302 * @addr: the phy address
1303 * @devad: device address to read
1304 * @regnum: register number to write
1305 * @mask: bit mask of bits to clear
1306 * @set: bit mask of bits to set
1308 int mdiobus_c45_modify(struct mii_bus
*bus
, int addr
, int devad
, u32 regnum
,
1313 mutex_lock(&bus
->mdio_lock
);
1314 err
= __mdiobus_c45_modify_changed(bus
, addr
, devad
, regnum
,
1316 mutex_unlock(&bus
->mdio_lock
);
1318 return err
< 0 ? err
: 0;
1320 EXPORT_SYMBOL_GPL(mdiobus_c45_modify
);
1323 * mdiobus_modify_changed - Convenience function for modifying a given mdio
1324 * device register and returning if it changed
1325 * @bus: the mii_bus struct
1326 * @addr: the phy address
1327 * @regnum: register number to write
1328 * @mask: bit mask of bits to clear
1329 * @set: bit mask of bits to set
1331 int mdiobus_modify_changed(struct mii_bus
*bus
, int addr
, u32 regnum
,
1336 mutex_lock(&bus
->mdio_lock
);
1337 err
= __mdiobus_modify_changed(bus
, addr
, regnum
, mask
, set
);
1338 mutex_unlock(&bus
->mdio_lock
);
1342 EXPORT_SYMBOL_GPL(mdiobus_modify_changed
);
1345 * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio
1346 * device register and returning if it changed
1347 * @bus: the mii_bus struct
1348 * @addr: the phy address
1349 * @devad: device address to read
1350 * @regnum: register number to write
1351 * @mask: bit mask of bits to clear
1352 * @set: bit mask of bits to set
1354 int mdiobus_c45_modify_changed(struct mii_bus
*bus
, int addr
, int devad
,
1355 u32 regnum
, u16 mask
, u16 set
)
1359 mutex_lock(&bus
->mdio_lock
);
1360 err
= __mdiobus_c45_modify_changed(bus
, addr
, devad
, regnum
, mask
, set
);
1361 mutex_unlock(&bus
->mdio_lock
);
1365 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed
);
1368 * mdio_bus_match - determine if given MDIO driver supports the given
1370 * @dev: target MDIO device
1371 * @drv: given MDIO driver
1373 * Description: Given a MDIO device, and a MDIO driver, return 1 if
1374 * the driver supports the device. Otherwise, return 0. This may
1375 * require calling the devices own match function, since different classes
1376 * of MDIO devices have different match criteria.
1378 static int mdio_bus_match(struct device
*dev
, const struct device_driver
*drv
)
1380 const struct mdio_driver
*mdiodrv
= to_mdio_driver(drv
);
1381 struct mdio_device
*mdio
= to_mdio_device(dev
);
1383 /* Both the driver and device must type-match */
1384 if (!(mdiodrv
->mdiodrv
.flags
& MDIO_DEVICE_IS_PHY
) !=
1385 !(mdio
->flags
& MDIO_DEVICE_FLAG_PHY
))
1388 if (of_driver_match_device(dev
, drv
))
1391 if (mdio
->bus_match
)
1392 return mdio
->bus_match(dev
, drv
);
1397 static int mdio_uevent(const struct device
*dev
, struct kobj_uevent_env
*env
)
1401 /* Some devices have extra OF data and an OF-style MODALIAS */
1402 rc
= of_device_uevent_modalias(dev
, env
);
1409 static struct attribute
*mdio_bus_device_statistics_attrs
[] = {
1410 &dev_attr_mdio_bus_device_transfers
.attr
.attr
,
1411 &dev_attr_mdio_bus_device_errors
.attr
.attr
,
1412 &dev_attr_mdio_bus_device_writes
.attr
.attr
,
1413 &dev_attr_mdio_bus_device_reads
.attr
.attr
,
1417 static const struct attribute_group mdio_bus_device_statistics_group
= {
1418 .name
= "statistics",
1419 .attrs
= mdio_bus_device_statistics_attrs
,
1422 static const struct attribute_group
*mdio_bus_dev_groups
[] = {
1423 &mdio_bus_device_statistics_group
,
1427 const struct bus_type mdio_bus_type
= {
1429 .dev_groups
= mdio_bus_dev_groups
,
1430 .match
= mdio_bus_match
,
1431 .uevent
= mdio_uevent
,
1433 EXPORT_SYMBOL(mdio_bus_type
);
1435 int __init
mdio_bus_init(void)
1439 ret
= class_register(&mdio_bus_class
);
1441 ret
= bus_register(&mdio_bus_type
);
1443 class_unregister(&mdio_bus_class
);
1449 #if IS_ENABLED(CONFIG_PHYLIB)
1450 void mdio_bus_exit(void)
1452 class_unregister(&mdio_bus_class
);
1453 bus_unregister(&mdio_bus_type
);
1455 EXPORT_SYMBOL_GPL(mdio_bus_exit
);
1457 module_init(mdio_bus_init
);
1458 /* no module_exit, intentional */
1459 MODULE_LICENSE("GPL");
1460 MODULE_DESCRIPTION("MDIO bus/device layer");