xref: /linux/drivers/net/phy/mdio_bus.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
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/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>
19 #include <linux/io.h>
20 #include <linux/kernel.h>
21 #include <linux/micrel_phy.h>
22 #include <linux/mii.h>
23 #include <linux/mm.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>
36 
37 #define CREATE_TRACE_POINTS
38 #include <trace/events/mdio.h>
39 
40 #include "mdio-boardinfo.h"
41 
mdiobus_register_gpiod(struct mdio_device * mdiodev)42 static int mdiobus_register_gpiod(struct mdio_device *mdiodev)
43 {
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);
49 
50 	if (mdiodev->reset_gpio)
51 		gpiod_set_consumer_name(mdiodev->reset_gpio, "PHY reset");
52 
53 	return 0;
54 }
55 
mdiobus_register_reset(struct mdio_device * mdiodev)56 static int mdiobus_register_reset(struct mdio_device *mdiodev)
57 {
58 	struct reset_control *reset;
59 
60 	reset = reset_control_get_optional_exclusive(&mdiodev->dev, "phy");
61 	if (IS_ERR(reset))
62 		return PTR_ERR(reset);
63 
64 	mdiodev->reset_ctrl = reset;
65 
66 	return 0;
67 }
68 
mdiobus_register_device(struct mdio_device * mdiodev)69 int mdiobus_register_device(struct mdio_device *mdiodev)
70 {
71 	int err;
72 
73 	if (mdiodev->bus->mdio_map[mdiodev->addr])
74 		return -EBUSY;
75 
76 	if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
77 		err = mdiobus_register_gpiod(mdiodev);
78 		if (err)
79 			return err;
80 
81 		err = mdiobus_register_reset(mdiodev);
82 		if (err)
83 			return err;
84 
85 		/* Assert the reset signal */
86 		mdio_device_reset(mdiodev, 1);
87 	}
88 
89 	mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
90 
91 	return 0;
92 }
93 EXPORT_SYMBOL(mdiobus_register_device);
94 
mdiobus_unregister_device(struct mdio_device * mdiodev)95 int mdiobus_unregister_device(struct mdio_device *mdiodev)
96 {
97 	if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
98 		return -EINVAL;
99 
100 	reset_control_put(mdiodev->reset_ctrl);
101 
102 	mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
103 
104 	return 0;
105 }
106 EXPORT_SYMBOL(mdiobus_unregister_device);
107 
mdiobus_find_device(struct mii_bus * bus,int addr)108 static struct mdio_device *mdiobus_find_device(struct mii_bus *bus, int addr)
109 {
110 	bool addr_valid = addr >= 0 && addr < ARRAY_SIZE(bus->mdio_map);
111 
112 	if (WARN_ONCE(!addr_valid, "addr %d out of range\n", addr))
113 		return NULL;
114 
115 	return bus->mdio_map[addr];
116 }
117 
mdiobus_get_phy(struct mii_bus * bus,int addr)118 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
119 {
120 	struct mdio_device *mdiodev;
121 
122 	mdiodev = mdiobus_find_device(bus, addr);
123 	if (!mdiodev)
124 		return NULL;
125 
126 	if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
127 		return NULL;
128 
129 	return container_of(mdiodev, struct phy_device, mdio);
130 }
131 EXPORT_SYMBOL(mdiobus_get_phy);
132 
mdiobus_is_registered_device(struct mii_bus * bus,int addr)133 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
134 {
135 	return mdiobus_find_device(bus, addr) != NULL;
136 }
137 EXPORT_SYMBOL(mdiobus_is_registered_device);
138 
139 /**
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.
143  *
144  * Description: called by a bus driver to allocate an mii_bus
145  * structure to fill in.
146  */
mdiobus_alloc_size(size_t size)147 struct mii_bus *mdiobus_alloc_size(size_t size)
148 {
149 	struct mii_bus *bus;
150 	size_t aligned_size = ALIGN(sizeof(*bus), NETDEV_ALIGN);
151 	size_t alloc_size;
152 	int i;
153 
154 	/* If we alloc extra space, it should be aligned */
155 	if (size)
156 		alloc_size = aligned_size + size;
157 	else
158 		alloc_size = sizeof(*bus);
159 
160 	bus = kzalloc(alloc_size, GFP_KERNEL);
161 	if (!bus)
162 		return NULL;
163 
164 	bus->state = MDIOBUS_ALLOCATED;
165 	if (size)
166 		bus->priv = (void *)bus + aligned_size;
167 
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);
172 	}
173 
174 	return bus;
175 }
176 EXPORT_SYMBOL(mdiobus_alloc_size);
177 
178 /**
179  * mdiobus_release - mii_bus device release callback
180  * @d: the target struct device that contains the mii_bus
181  *
182  * Description: called when the last reference to an mii_bus is
183  * dropped, to free the underlying memory.
184  */
mdiobus_release(struct device * d)185 static void mdiobus_release(struct device *d)
186 {
187 	struct mii_bus *bus = to_mii_bus(d);
188 
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",
193 	     bus->id);
194 
195 	if (bus->state == MDIOBUS_RELEASED)
196 		fwnode_handle_put(dev_fwnode(d));
197 
198 	kfree(bus);
199 }
200 
201 struct mdio_bus_stat_attr {
202 	int addr;
203 	unsigned int field_offset;
204 };
205 
mdio_bus_get_stat(struct mdio_bus_stats * s,unsigned int offset)206 static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset)
207 {
208 	const char *p = (const char *)s + offset;
209 	unsigned int start;
210 	u64 val = 0;
211 
212 	do {
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));
216 
217 	return val;
218 }
219 
mdio_bus_get_global_stat(struct mii_bus * bus,unsigned int offset)220 static u64 mdio_bus_get_global_stat(struct mii_bus *bus, unsigned int offset)
221 {
222 	unsigned int i;
223 	u64 val = 0;
224 
225 	for (i = 0; i < PHY_MAX_ADDR; i++)
226 		val += mdio_bus_get_stat(&bus->stats[i], offset);
227 
228 	return val;
229 }
230 
mdio_bus_stat_field_show(struct device * dev,struct device_attribute * attr,char * buf)231 static ssize_t mdio_bus_stat_field_show(struct device *dev,
232 					struct device_attribute *attr,
233 					char *buf)
234 {
235 	struct mii_bus *bus = to_mii_bus(dev);
236 	struct mdio_bus_stat_attr *sattr;
237 	struct dev_ext_attribute *eattr;
238 	u64 val;
239 
240 	eattr = container_of(attr, struct dev_ext_attribute, attr);
241 	sattr = eattr->var;
242 
243 	if (sattr->addr < 0)
244 		val = mdio_bus_get_global_stat(bus, sattr->field_offset);
245 	else
246 		val = mdio_bus_get_stat(&bus->stats[sattr->addr],
247 					sattr->field_offset);
248 
249 	return sysfs_emit(buf, "%llu\n", val);
250 }
251 
mdio_bus_device_stat_field_show(struct device * dev,struct device_attribute * attr,char * buf)252 static ssize_t mdio_bus_device_stat_field_show(struct device *dev,
253 					       struct device_attribute *attr,
254 					       char *buf)
255 {
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;
261 	u64 val;
262 
263 	eattr = container_of(attr, struct dev_ext_attribute, attr);
264 	sattr = eattr->var;
265 
266 	val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset);
267 
268 	return sysfs_emit(buf, "%llu\n", val);
269 }
270 
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,			\
275 	},								\
276 	.var = &((struct mdio_bus_stat_attr) {				\
277 		-1, offsetof(struct mdio_bus_stats, field)		\
278 	}),								\
279 };									\
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,		\
283 	},								\
284 	.var = &((struct mdio_bus_stat_attr) {				\
285 		-1, offsetof(struct mdio_bus_stats, field)		\
286 	}),								\
287 };
288 
289 #define MDIO_BUS_STATS_ATTR(field)					\
290 	MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
291 
292 MDIO_BUS_STATS_ATTR(transfers);
293 MDIO_BUS_STATS_ATTR(errors);
294 MDIO_BUS_STATS_ATTR(writes);
295 MDIO_BUS_STATS_ATTR(reads);
296 
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,			\
301 	},								\
302 	.var = &((struct mdio_bus_stat_attr) {				\
303 		addr, offsetof(struct mdio_bus_stats, field)		\
304 	}),								\
305 }
306 
307 #define MDIO_BUS_STATS_ADDR_ATTR(field, addr)				\
308 	MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr,			\
309 				 __stringify(field) "_" __stringify(addr))
310 
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)				\
316 
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);
349 
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			\
355 
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),
393 	NULL,
394 };
395 
396 static const struct attribute_group mdio_bus_statistics_group = {
397 	.name	= "statistics",
398 	.attrs	= mdio_bus_statistics_attrs,
399 };
400 
401 static const struct attribute_group *mdio_bus_groups[] = {
402 	&mdio_bus_statistics_group,
403 	NULL,
404 };
405 
406 static struct class mdio_bus_class = {
407 	.name		= "mdio_bus",
408 	.dev_release	= mdiobus_release,
409 	.dev_groups	= mdio_bus_groups,
410 };
411 
412 /**
413  * mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
414  * @mdio_name: The name of a mdiobus.
415  *
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.
419  */
mdio_find_bus(const char * mdio_name)420 struct mii_bus *mdio_find_bus(const char *mdio_name)
421 {
422 	struct device *d;
423 
424 	d = class_find_device_by_name(&mdio_bus_class, mdio_name);
425 	return d ? to_mii_bus(d) : NULL;
426 }
427 EXPORT_SYMBOL(mdio_find_bus);
428 
429 #if IS_ENABLED(CONFIG_OF_MDIO)
430 /**
431  * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
432  * @mdio_bus_np: Pointer to the mii_bus.
433  *
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.
437  *
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().
441  *
442  */
of_mdio_find_bus(struct device_node * mdio_bus_np)443 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
444 {
445 	struct device *d;
446 
447 	if (!mdio_bus_np)
448 		return NULL;
449 
450 	d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
451 	return d ? to_mii_bus(d) : NULL;
452 }
453 EXPORT_SYMBOL(of_mdio_find_bus);
454 
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
459  * via DT.
460  * If a PHY package is found, PHY is searched also there.
461  */
of_mdiobus_find_phy(struct device * dev,struct mdio_device * mdiodev,struct device_node * np)462 static int of_mdiobus_find_phy(struct device *dev, struct mdio_device *mdiodev,
463 			       struct device_node *np)
464 {
465 	struct device_node *child;
466 
467 	for_each_available_child_of_node(np, child) {
468 		int addr;
469 
470 		if (of_node_name_eq(child, "ethernet-phy-package")) {
471 			/* Validate PHY package reg presence */
472 			if (!of_property_present(child, "reg")) {
473 				of_node_put(child);
474 				return -EINVAL;
475 			}
476 
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.
480 				 */
481 				of_node_put(child);
482 				return 0;
483 			}
484 
485 			continue;
486 		}
487 
488 		addr = of_mdio_parse_addr(dev, child);
489 		if (addr < 0)
490 			continue;
491 
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.
496 			 */
497 			return 0;
498 		}
499 	}
500 
501 	return -ENODEV;
502 }
503 
of_mdiobus_link_mdiodev(struct mii_bus * bus,struct mdio_device * mdiodev)504 static void of_mdiobus_link_mdiodev(struct mii_bus *bus,
505 				    struct mdio_device *mdiodev)
506 {
507 	struct device *dev = &mdiodev->dev;
508 
509 	if (dev->of_node || !bus->dev.of_node)
510 		return;
511 
512 	of_mdiobus_find_phy(dev, mdiodev, bus->dev.of_node);
513 }
514 #else /* !IS_ENABLED(CONFIG_OF_MDIO) */
of_mdiobus_link_mdiodev(struct mii_bus * mdio,struct mdio_device * mdiodev)515 static inline void of_mdiobus_link_mdiodev(struct mii_bus *mdio,
516 					   struct mdio_device *mdiodev)
517 {
518 }
519 #endif
520 
521 /**
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
526  *
527  * Returns 0 on success or < 0 on error.
528  */
mdiobus_create_device(struct mii_bus * bus,struct mdio_board_info * bi)529 static int mdiobus_create_device(struct mii_bus *bus,
530 				 struct mdio_board_info *bi)
531 {
532 	struct mdio_device *mdiodev;
533 	int ret = 0;
534 
535 	mdiodev = mdio_device_create(bus, bi->mdio_addr);
536 	if (IS_ERR(mdiodev))
537 		return -ENODEV;
538 
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;
543 
544 	ret = mdio_device_register(mdiodev);
545 	if (ret)
546 		mdio_device_free(mdiodev);
547 
548 	return ret;
549 }
550 
mdiobus_scan(struct mii_bus * bus,int addr,bool c45)551 static struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr, bool c45)
552 {
553 	struct phy_device *phydev = ERR_PTR(-ENODEV);
554 	int err;
555 
556 	phydev = get_phy_device(bus, addr, c45);
557 	if (IS_ERR(phydev))
558 		return phydev;
559 
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.
562 	 */
563 	of_mdiobus_link_mdiodev(bus, &phydev->mdio);
564 
565 	err = phy_device_register(phydev);
566 	if (err) {
567 		phy_device_free(phydev);
568 		return ERR_PTR(-ENODEV);
569 	}
570 
571 	return phydev;
572 }
573 
574 /**
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
578  *
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.
585  */
mdiobus_scan_c22(struct mii_bus * bus,int addr)586 struct phy_device *mdiobus_scan_c22(struct mii_bus *bus, int addr)
587 {
588 	return mdiobus_scan(bus, addr, false);
589 }
590 EXPORT_SYMBOL(mdiobus_scan_c22);
591 
592 /**
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
596  *
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.
603  */
mdiobus_scan_c45(struct mii_bus * bus,int addr)604 static struct phy_device *mdiobus_scan_c45(struct mii_bus *bus, int addr)
605 {
606 	return mdiobus_scan(bus, addr, true);
607 }
608 
mdiobus_scan_bus_c22(struct mii_bus * bus)609 static int mdiobus_scan_bus_c22(struct mii_bus *bus)
610 {
611 	int i;
612 
613 	for (i = 0; i < PHY_MAX_ADDR; i++) {
614 		if ((bus->phy_mask & BIT(i)) == 0) {
615 			struct phy_device *phydev;
616 
617 			phydev = mdiobus_scan_c22(bus, i);
618 			if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
619 				return PTR_ERR(phydev);
620 		}
621 	}
622 	return 0;
623 }
624 
mdiobus_scan_bus_c45(struct mii_bus * bus)625 static int mdiobus_scan_bus_c45(struct mii_bus *bus)
626 {
627 	int i;
628 
629 	for (i = 0; i < PHY_MAX_ADDR; i++) {
630 		if ((bus->phy_mask & BIT(i)) == 0) {
631 			struct phy_device *phydev;
632 
633 			/* Don't scan C45 if we already have a C22 device */
634 			if (bus->mdio_map[i])
635 				continue;
636 
637 			phydev = mdiobus_scan_c45(bus, i);
638 			if (IS_ERR(phydev) && (PTR_ERR(phydev) != -ENODEV))
639 				return PTR_ERR(phydev);
640 		}
641 	}
642 	return 0;
643 }
644 
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.
651  */
mdiobus_prevent_c45_scan(struct mii_bus * bus)652 static bool mdiobus_prevent_c45_scan(struct mii_bus *bus)
653 {
654 	int i;
655 
656 	for (i = 0; i < PHY_MAX_ADDR; i++) {
657 		struct phy_device *phydev;
658 		u32 oui;
659 
660 		phydev = mdiobus_get_phy(bus, i);
661 		if (!phydev)
662 			continue;
663 		oui = phydev->phy_id >> 10;
664 
665 		if (oui == MICREL_OUI)
666 			return true;
667 	}
668 	return false;
669 }
670 
671 /**
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
675  *
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().
682  *
683  * Returns 0 on success or < 0 on error.
684  */
__mdiobus_register(struct mii_bus * bus,struct module * owner)685 int __mdiobus_register(struct mii_bus *bus, struct module *owner)
686 {
687 	struct mdio_device *mdiodev;
688 	struct gpio_desc *gpiod;
689 	bool prevent_c45_scan;
690 	int i, err;
691 
692 	if (!bus || !bus->name)
693 		return -EINVAL;
694 
695 	/* An access method always needs both read and write operations */
696 	if (!!bus->read != !!bus->write || !!bus->read_c45 != !!bus->write_c45)
697 		return -EINVAL;
698 
699 	/* At least one method is mandatory */
700 	if (!bus->read && !bus->read_c45)
701 		return -EINVAL;
702 
703 	if (bus->parent && bus->parent->of_node)
704 		bus->parent->of_node->fwnode.flags |=
705 					FWNODE_FLAG_NEEDS_CHILD_BOUND_ON_ADD;
706 
707 	WARN(bus->state != MDIOBUS_ALLOCATED &&
708 	     bus->state != MDIOBUS_UNREGISTERED,
709 	     "%s: not in ALLOCATED or UNREGISTERED state\n", bus->id);
710 
711 	bus->owner = owner;
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);
716 
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.
722 	 */
723 	if (bus->state == MDIOBUS_ALLOCATED)
724 		fwnode_handle_get(dev_fwnode(&bus->dev));
725 
726 	/* We need to set state to MDIOBUS_UNREGISTERED to correctly release
727 	 * the device in mdiobus_free()
728 	 *
729 	 * State will be updated later in this function in case of success
730 	 */
731 	bus->state = MDIOBUS_UNREGISTERED;
732 
733 	err = device_register(&bus->dev);
734 	if (err) {
735 		pr_err("mii_bus %s failed to register\n", bus->id);
736 		return -EINVAL;
737 	}
738 
739 	mutex_init(&bus->mdio_lock);
740 	mutex_init(&bus->shared_lock);
741 
742 	/* assert bus level PHY GPIO reset */
743 	gpiod = devm_gpiod_get_optional(&bus->dev, "reset", GPIOD_OUT_HIGH);
744 	if (IS_ERR(gpiod)) {
745 		err = dev_err_probe(&bus->dev, PTR_ERR(gpiod),
746 				    "mii_bus %s couldn't get reset GPIO\n",
747 				    bus->id);
748 		device_del(&bus->dev);
749 		return err;
750 	} else	if (gpiod) {
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);
756 	}
757 
758 	if (bus->reset) {
759 		err = bus->reset(bus);
760 		if (err)
761 			goto error_reset_gpiod;
762 	}
763 
764 	if (bus->read) {
765 		err = mdiobus_scan_bus_c22(bus);
766 		if (err)
767 			goto error;
768 	}
769 
770 	prevent_c45_scan = mdiobus_prevent_c45_scan(bus);
771 
772 	if (!prevent_c45_scan && bus->read_c45) {
773 		err = mdiobus_scan_bus_c45(bus);
774 		if (err)
775 			goto error;
776 	}
777 
778 	mdiobus_setup_mdiodev_from_board_info(bus, mdiobus_create_device);
779 
780 	bus->state = MDIOBUS_REGISTERED;
781 	dev_dbg(&bus->dev, "probed\n");
782 	return 0;
783 
784 error:
785 	for (i = 0; i < PHY_MAX_ADDR; i++) {
786 		mdiodev = bus->mdio_map[i];
787 		if (!mdiodev)
788 			continue;
789 
790 		mdiodev->device_remove(mdiodev);
791 		mdiodev->device_free(mdiodev);
792 	}
793 error_reset_gpiod:
794 	/* Put PHYs in RESET to save power */
795 	if (bus->reset_gpiod)
796 		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
797 
798 	device_del(&bus->dev);
799 	return err;
800 }
801 EXPORT_SYMBOL(__mdiobus_register);
802 
mdiobus_unregister(struct mii_bus * bus)803 void mdiobus_unregister(struct mii_bus *bus)
804 {
805 	struct mdio_device *mdiodev;
806 	int i;
807 
808 	if (WARN_ON_ONCE(bus->state != MDIOBUS_REGISTERED))
809 		return;
810 	bus->state = MDIOBUS_UNREGISTERED;
811 
812 	for (i = 0; i < PHY_MAX_ADDR; i++) {
813 		mdiodev = bus->mdio_map[i];
814 		if (!mdiodev)
815 			continue;
816 
817 		if (mdiodev->reset_gpio)
818 			gpiod_put(mdiodev->reset_gpio);
819 
820 		mdiodev->device_remove(mdiodev);
821 		mdiodev->device_free(mdiodev);
822 	}
823 
824 	/* Put PHYs in RESET to save power */
825 	if (bus->reset_gpiod)
826 		gpiod_set_value_cansleep(bus->reset_gpiod, 1);
827 
828 	device_del(&bus->dev);
829 }
830 EXPORT_SYMBOL(mdiobus_unregister);
831 
832 /**
833  * mdiobus_free - free a struct mii_bus
834  * @bus: mii_bus to free
835  *
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
838  * will be freed.
839  */
mdiobus_free(struct mii_bus * bus)840 void mdiobus_free(struct mii_bus *bus)
841 {
842 	/* For compatibility with error handling in drivers. */
843 	if (bus->state == MDIOBUS_ALLOCATED) {
844 		kfree(bus);
845 		return;
846 	}
847 
848 	WARN(bus->state != MDIOBUS_UNREGISTERED,
849 	     "%s: not in UNREGISTERED state\n", bus->id);
850 	bus->state = MDIOBUS_RELEASED;
851 
852 	put_device(&bus->dev);
853 }
854 EXPORT_SYMBOL(mdiobus_free);
855 
mdiobus_stats_acct(struct mdio_bus_stats * stats,bool op,int ret)856 static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret)
857 {
858 	preempt_disable();
859 	u64_stats_update_begin(&stats->syncp);
860 
861 	u64_stats_inc(&stats->transfers);
862 	if (ret < 0) {
863 		u64_stats_inc(&stats->errors);
864 		goto out;
865 	}
866 
867 	if (op)
868 		u64_stats_inc(&stats->reads);
869 	else
870 		u64_stats_inc(&stats->writes);
871 out:
872 	u64_stats_update_end(&stats->syncp);
873 	preempt_enable();
874 }
875 
876 /**
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
881  *
882  * Read a MDIO bus register. Caller must hold the mdio bus lock.
883  *
884  * NOTE: MUST NOT be called from interrupt context.
885  */
__mdiobus_read(struct mii_bus * bus,int addr,u32 regnum)886 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
887 {
888 	int retval;
889 
890 	lockdep_assert_held_once(&bus->mdio_lock);
891 
892 	if (bus->read)
893 		retval = bus->read(bus, addr, regnum);
894 	else
895 		retval = -EOPNOTSUPP;
896 
897 	trace_mdio_access(bus, 1, addr, regnum, retval, retval);
898 	mdiobus_stats_acct(&bus->stats[addr], true, retval);
899 
900 	return retval;
901 }
902 EXPORT_SYMBOL(__mdiobus_read);
903 
904 /**
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
910  *
911  * Write a MDIO bus register. Caller must hold the mdio bus lock.
912  *
913  * NOTE: MUST NOT be called from interrupt context.
914  */
__mdiobus_write(struct mii_bus * bus,int addr,u32 regnum,u16 val)915 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
916 {
917 	int err;
918 
919 	lockdep_assert_held_once(&bus->mdio_lock);
920 
921 	if (bus->write)
922 		err = bus->write(bus, addr, regnum, val);
923 	else
924 		err = -EOPNOTSUPP;
925 
926 	trace_mdio_access(bus, 0, addr, regnum, val, err);
927 	mdiobus_stats_acct(&bus->stats[addr], false, err);
928 
929 	return err;
930 }
931 EXPORT_SYMBOL(__mdiobus_write);
932 
933 /**
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
940  *
941  * Read, modify, and if any change, write the register value back to the
942  * device. Any error returns a negative number.
943  *
944  * NOTE: MUST NOT be called from interrupt context.
945  */
__mdiobus_modify_changed(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)946 int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
947 			     u16 mask, u16 set)
948 {
949 	int new, ret;
950 
951 	ret = __mdiobus_read(bus, addr, regnum);
952 	if (ret < 0)
953 		return ret;
954 
955 	new = (ret & ~mask) | set;
956 	if (new == ret)
957 		return 0;
958 
959 	ret = __mdiobus_write(bus, addr, regnum, new);
960 
961 	return ret < 0 ? ret : 1;
962 }
963 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed);
964 
965 /**
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
971  *
972  * Read a MDIO bus register. Caller must hold the mdio bus lock.
973  *
974  * NOTE: MUST NOT be called from interrupt context.
975  */
__mdiobus_c45_read(struct mii_bus * bus,int addr,int devad,u32 regnum)976 int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
977 {
978 	int retval;
979 
980 	lockdep_assert_held_once(&bus->mdio_lock);
981 
982 	if (bus->read_c45)
983 		retval = bus->read_c45(bus, addr, devad, regnum);
984 	else
985 		retval = -EOPNOTSUPP;
986 
987 	trace_mdio_access(bus, 1, addr, regnum, retval, retval);
988 	mdiobus_stats_acct(&bus->stats[addr], true, retval);
989 
990 	return retval;
991 }
992 EXPORT_SYMBOL(__mdiobus_c45_read);
993 
994 /**
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
1001  *
1002  * Write a MDIO bus register. Caller must hold the mdio bus lock.
1003  *
1004  * NOTE: MUST NOT be called from interrupt context.
1005  */
__mdiobus_c45_write(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)1006 int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1007 			u16 val)
1008 {
1009 	int err;
1010 
1011 	lockdep_assert_held_once(&bus->mdio_lock);
1012 
1013 	if (bus->write_c45)
1014 		err = bus->write_c45(bus, addr, devad, regnum, val);
1015 	else
1016 		err = -EOPNOTSUPP;
1017 
1018 	trace_mdio_access(bus, 0, addr, regnum, val, err);
1019 	mdiobus_stats_acct(&bus->stats[addr], false, err);
1020 
1021 	return err;
1022 }
1023 EXPORT_SYMBOL(__mdiobus_c45_write);
1024 
1025 /**
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
1033  *
1034  * Read, modify, and if any change, write the register value back to the
1035  * device. Any error returns a negative number.
1036  *
1037  * NOTE: MUST NOT be called from interrupt context.
1038  */
__mdiobus_c45_modify_changed(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)1039 static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr,
1040 					int devad, u32 regnum, u16 mask,
1041 					u16 set)
1042 {
1043 	int new, ret;
1044 
1045 	ret = __mdiobus_c45_read(bus, addr, devad, regnum);
1046 	if (ret < 0)
1047 		return ret;
1048 
1049 	new = (ret & ~mask) | set;
1050 	if (new == ret)
1051 		return 0;
1052 
1053 	ret = __mdiobus_c45_write(bus, addr, devad, regnum, new);
1054 
1055 	return ret < 0 ? ret : 1;
1056 }
1057 
1058 /**
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
1063  *
1064  * In case of nested MDIO bus access avoid lockdep false positives by
1065  * using mutex_lock_nested().
1066  *
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.
1070  */
mdiobus_read_nested(struct mii_bus * bus,int addr,u32 regnum)1071 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
1072 {
1073 	int retval;
1074 
1075 	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1076 	retval = __mdiobus_read(bus, addr, regnum);
1077 	mutex_unlock(&bus->mdio_lock);
1078 
1079 	return retval;
1080 }
1081 EXPORT_SYMBOL(mdiobus_read_nested);
1082 
1083 /**
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
1088  *
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.
1092  */
mdiobus_read(struct mii_bus * bus,int addr,u32 regnum)1093 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
1094 {
1095 	int retval;
1096 
1097 	mutex_lock(&bus->mdio_lock);
1098 	retval = __mdiobus_read(bus, addr, regnum);
1099 	mutex_unlock(&bus->mdio_lock);
1100 
1101 	return retval;
1102 }
1103 EXPORT_SYMBOL(mdiobus_read);
1104 
1105 /**
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
1111  *
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.
1115  */
mdiobus_c45_read(struct mii_bus * bus,int addr,int devad,u32 regnum)1116 int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
1117 {
1118 	int retval;
1119 
1120 	mutex_lock(&bus->mdio_lock);
1121 	retval = __mdiobus_c45_read(bus, addr, devad, regnum);
1122 	mutex_unlock(&bus->mdio_lock);
1123 
1124 	return retval;
1125 }
1126 EXPORT_SYMBOL(mdiobus_c45_read);
1127 
1128 /**
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
1134  *
1135  * In case of nested MDIO bus access avoid lockdep false positives by
1136  * using mutex_lock_nested().
1137  *
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.
1141  */
mdiobus_c45_read_nested(struct mii_bus * bus,int addr,int devad,u32 regnum)1142 int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad,
1143 			    u32 regnum)
1144 {
1145 	int retval;
1146 
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);
1150 
1151 	return retval;
1152 }
1153 EXPORT_SYMBOL(mdiobus_c45_read_nested);
1154 
1155 /**
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
1161  *
1162  * In case of nested MDIO bus access avoid lockdep false positives by
1163  * using mutex_lock_nested().
1164  *
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.
1168  */
mdiobus_write_nested(struct mii_bus * bus,int addr,u32 regnum,u16 val)1169 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1170 {
1171 	int err;
1172 
1173 	mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
1174 	err = __mdiobus_write(bus, addr, regnum, val);
1175 	mutex_unlock(&bus->mdio_lock);
1176 
1177 	return err;
1178 }
1179 EXPORT_SYMBOL(mdiobus_write_nested);
1180 
1181 /**
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
1187  *
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.
1191  */
mdiobus_write(struct mii_bus * bus,int addr,u32 regnum,u16 val)1192 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
1193 {
1194 	int err;
1195 
1196 	mutex_lock(&bus->mdio_lock);
1197 	err = __mdiobus_write(bus, addr, regnum, val);
1198 	mutex_unlock(&bus->mdio_lock);
1199 
1200 	return err;
1201 }
1202 EXPORT_SYMBOL(mdiobus_write);
1203 
1204 /**
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
1211  *
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.
1215  */
mdiobus_c45_write(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)1216 int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
1217 		      u16 val)
1218 {
1219 	int err;
1220 
1221 	mutex_lock(&bus->mdio_lock);
1222 	err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
1223 	mutex_unlock(&bus->mdio_lock);
1224 
1225 	return err;
1226 }
1227 EXPORT_SYMBOL(mdiobus_c45_write);
1228 
1229 /**
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
1236  *
1237  * In case of nested MDIO bus access avoid lockdep false positives by
1238  * using mutex_lock_nested().
1239  *
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.
1243  */
mdiobus_c45_write_nested(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)1244 int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad,
1245 			     u32 regnum, u16 val)
1246 {
1247 	int err;
1248 
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);
1252 
1253 	return err;
1254 }
1255 EXPORT_SYMBOL(mdiobus_c45_write_nested);
1256 
1257 /*
1258  * __mdiobus_modify - Convenience function for modifying a given mdio device
1259  *	register
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
1265  */
__mdiobus_modify(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)1266 int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
1267 		     u16 set)
1268 {
1269 	int err;
1270 
1271 	err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1272 
1273 	return err < 0 ? err : 0;
1274 }
1275 EXPORT_SYMBOL_GPL(__mdiobus_modify);
1276 
1277 /**
1278  * mdiobus_modify - Convenience function for modifying a given mdio device
1279  *	register
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
1285  */
mdiobus_modify(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)1286 int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)
1287 {
1288 	int err;
1289 
1290 	mutex_lock(&bus->mdio_lock);
1291 	err = __mdiobus_modify(bus, addr, regnum, mask, set);
1292 	mutex_unlock(&bus->mdio_lock);
1293 
1294 	return err;
1295 }
1296 EXPORT_SYMBOL_GPL(mdiobus_modify);
1297 
1298 /**
1299  * mdiobus_c45_modify - Convenience function for modifying a given mdio device
1300  *	register
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
1307  */
mdiobus_c45_modify(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)1308 int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum,
1309 		       u16 mask, u16 set)
1310 {
1311 	int err;
1312 
1313 	mutex_lock(&bus->mdio_lock);
1314 	err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum,
1315 					   mask, set);
1316 	mutex_unlock(&bus->mdio_lock);
1317 
1318 	return err < 0 ? err : 0;
1319 }
1320 EXPORT_SYMBOL_GPL(mdiobus_c45_modify);
1321 
1322 /**
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
1330  */
mdiobus_modify_changed(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)1331 int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
1332 			   u16 mask, u16 set)
1333 {
1334 	int err;
1335 
1336 	mutex_lock(&bus->mdio_lock);
1337 	err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
1338 	mutex_unlock(&bus->mdio_lock);
1339 
1340 	return err;
1341 }
1342 EXPORT_SYMBOL_GPL(mdiobus_modify_changed);
1343 
1344 /**
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
1353  */
mdiobus_c45_modify_changed(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)1354 int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad,
1355 			       u32 regnum, u16 mask, u16 set)
1356 {
1357 	int err;
1358 
1359 	mutex_lock(&bus->mdio_lock);
1360 	err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set);
1361 	mutex_unlock(&bus->mdio_lock);
1362 
1363 	return err;
1364 }
1365 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
1366 
1367 /**
1368  * mdio_bus_match - determine if given MDIO driver supports the given
1369  *		    MDIO device
1370  * @dev: target MDIO device
1371  * @drv: given MDIO driver
1372  *
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.
1377  */
mdio_bus_match(struct device * dev,const struct device_driver * drv)1378 static int mdio_bus_match(struct device *dev, const struct device_driver *drv)
1379 {
1380 	const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
1381 	struct mdio_device *mdio = to_mdio_device(dev);
1382 
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))
1386 		return 0;
1387 
1388 	if (of_driver_match_device(dev, drv))
1389 		return 1;
1390 
1391 	if (mdio->bus_match)
1392 		return mdio->bus_match(dev, drv);
1393 
1394 	return 0;
1395 }
1396 
mdio_uevent(const struct device * dev,struct kobj_uevent_env * env)1397 static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env)
1398 {
1399 	int rc;
1400 
1401 	/* Some devices have extra OF data and an OF-style MODALIAS */
1402 	rc = of_device_uevent_modalias(dev, env);
1403 	if (rc != -ENODEV)
1404 		return rc;
1405 
1406 	return 0;
1407 }
1408 
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,
1414 	NULL,
1415 };
1416 
1417 static const struct attribute_group mdio_bus_device_statistics_group = {
1418 	.name	= "statistics",
1419 	.attrs	= mdio_bus_device_statistics_attrs,
1420 };
1421 
1422 static const struct attribute_group *mdio_bus_dev_groups[] = {
1423 	&mdio_bus_device_statistics_group,
1424 	NULL,
1425 };
1426 
1427 const struct bus_type mdio_bus_type = {
1428 	.name		= "mdio_bus",
1429 	.dev_groups	= mdio_bus_dev_groups,
1430 	.match		= mdio_bus_match,
1431 	.uevent		= mdio_uevent,
1432 };
1433 EXPORT_SYMBOL(mdio_bus_type);
1434 
mdio_bus_init(void)1435 int __init mdio_bus_init(void)
1436 {
1437 	int ret;
1438 
1439 	ret = class_register(&mdio_bus_class);
1440 	if (!ret) {
1441 		ret = bus_register(&mdio_bus_type);
1442 		if (ret)
1443 			class_unregister(&mdio_bus_class);
1444 	}
1445 
1446 	return ret;
1447 }
1448 
1449 #if IS_ENABLED(CONFIG_PHYLIB)
mdio_bus_exit(void)1450 void mdio_bus_exit(void)
1451 {
1452 	class_unregister(&mdio_bus_class);
1453 	bus_unregister(&mdio_bus_type);
1454 }
1455 EXPORT_SYMBOL_GPL(mdio_bus_exit);
1456 #else
1457 module_init(mdio_bus_init);
1458 /* no module_exit, intentional */
1459 MODULE_LICENSE("GPL");
1460 MODULE_DESCRIPTION("MDIO bus/device layer");
1461 #endif
1462