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/device.h>
12 #include <linux/errno.h>
13 #include <linux/etherdevice.h>
14 #include <linux/ethtool.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/init.h>
17 #include <linux/io.h>
18 #include <linux/kernel.h>
19 #include <linux/mii.h>
20 #include <linux/mm.h>
21 #include <linux/module.h>
22 #include <linux/netdevice.h>
23 #include <linux/of_device.h>
24 #include <linux/of_mdio.h>
25 #include <linux/phy.h>
26 #include <linux/reset.h>
27 #include <linux/slab.h>
28 #include <linux/spinlock.h>
29 #include <linux/string.h>
30 #include <linux/uaccess.h>
31 #include <linux/unistd.h>
32 #include "mdio-private.h"
33
34 #define CREATE_TRACE_POINTS
35 #include <trace/events/mdio.h>
36
mdiobus_register_device(struct mdio_device * mdiodev)37 int mdiobus_register_device(struct mdio_device *mdiodev)
38 {
39 int err;
40
41 if (mdiodev->bus->mdio_map[mdiodev->addr])
42 return -EBUSY;
43
44 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY) {
45 err = mdio_device_register_reset(mdiodev);
46 if (err)
47 return err;
48
49 /* Assert the reset signal */
50 mdio_device_reset(mdiodev, 1);
51 }
52
53 mdiodev->bus->mdio_map[mdiodev->addr] = mdiodev;
54
55 return 0;
56 }
57 EXPORT_SYMBOL(mdiobus_register_device);
58
mdiobus_unregister_device(struct mdio_device * mdiodev)59 int mdiobus_unregister_device(struct mdio_device *mdiodev)
60 {
61 if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
62 return -EINVAL;
63
64 mdio_device_unregister_reset(mdiodev);
65
66 mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
67
68 return 0;
69 }
70 EXPORT_SYMBOL(mdiobus_unregister_device);
71
mdiobus_find_device(struct mii_bus * bus,int addr)72 static struct mdio_device *mdiobus_find_device(struct mii_bus *bus, int addr)
73 {
74 bool addr_valid = addr >= 0 && addr < ARRAY_SIZE(bus->mdio_map);
75
76 if (WARN_ONCE(!addr_valid, "addr %d out of range\n", addr))
77 return NULL;
78
79 return bus->mdio_map[addr];
80 }
81
mdiobus_get_phy(struct mii_bus * bus,int addr)82 struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr)
83 {
84 struct mdio_device *mdiodev;
85
86 mdiodev = mdiobus_find_device(bus, addr);
87 if (!mdiodev)
88 return NULL;
89
90 if (!(mdiodev->flags & MDIO_DEVICE_FLAG_PHY))
91 return NULL;
92
93 return container_of(mdiodev, struct phy_device, mdio);
94 }
95 EXPORT_SYMBOL(mdiobus_get_phy);
96
mdiobus_is_registered_device(struct mii_bus * bus,int addr)97 bool mdiobus_is_registered_device(struct mii_bus *bus, int addr)
98 {
99 return mdiobus_find_device(bus, addr) != NULL;
100 }
101 EXPORT_SYMBOL(mdiobus_is_registered_device);
102
103 /**
104 * mdiobus_release - mii_bus device release callback
105 * @d: the target struct device that contains the mii_bus
106 *
107 * Description: called when the last reference to an mii_bus is
108 * dropped, to free the underlying memory.
109 */
mdiobus_release(struct device * d)110 static void mdiobus_release(struct device *d)
111 {
112 struct mii_bus *bus = to_mii_bus(d);
113
114 WARN(bus->state != MDIOBUS_RELEASED &&
115 /* for compatibility with error handling in drivers */
116 bus->state != MDIOBUS_ALLOCATED,
117 "%s: not in RELEASED or ALLOCATED state\n",
118 bus->id);
119
120 if (bus->state == MDIOBUS_RELEASED)
121 fwnode_handle_put(dev_fwnode(d));
122
123 kfree(bus);
124 }
125
126 struct mdio_bus_stat_attr {
127 int addr;
128 unsigned int field_offset;
129 };
130
mdio_bus_get_stat(struct mdio_bus_stats * s,unsigned int offset)131 static u64 mdio_bus_get_stat(struct mdio_bus_stats *s, unsigned int offset)
132 {
133 const char *p = (const char *)s + offset;
134 unsigned int start;
135 u64 val = 0;
136
137 do {
138 start = u64_stats_fetch_begin(&s->syncp);
139 val = u64_stats_read((const u64_stats_t *)p);
140 } while (u64_stats_fetch_retry(&s->syncp, start));
141
142 return val;
143 }
144
mdio_bus_get_global_stat(struct mii_bus * bus,unsigned int offset)145 static u64 mdio_bus_get_global_stat(struct mii_bus *bus, unsigned int offset)
146 {
147 unsigned int i;
148 u64 val = 0;
149
150 for (i = 0; i < PHY_MAX_ADDR; i++)
151 val += mdio_bus_get_stat(&bus->stats[i], offset);
152
153 return val;
154 }
155
mdio_bus_stat_field_show(struct device * dev,struct device_attribute * attr,char * buf)156 static ssize_t mdio_bus_stat_field_show(struct device *dev,
157 struct device_attribute *attr,
158 char *buf)
159 {
160 struct mii_bus *bus = to_mii_bus(dev);
161 struct mdio_bus_stat_attr *sattr;
162 struct dev_ext_attribute *eattr;
163 u64 val;
164
165 eattr = container_of(attr, struct dev_ext_attribute, attr);
166 sattr = eattr->var;
167
168 if (sattr->addr < 0)
169 val = mdio_bus_get_global_stat(bus, sattr->field_offset);
170 else
171 val = mdio_bus_get_stat(&bus->stats[sattr->addr],
172 sattr->field_offset);
173
174 return sysfs_emit(buf, "%llu\n", val);
175 }
176
mdio_bus_device_stat_field_show(struct device * dev,struct device_attribute * attr,char * buf)177 static ssize_t mdio_bus_device_stat_field_show(struct device *dev,
178 struct device_attribute *attr,
179 char *buf)
180 {
181 struct mdio_device *mdiodev = to_mdio_device(dev);
182 struct mii_bus *bus = mdiodev->bus;
183 struct mdio_bus_stat_attr *sattr;
184 struct dev_ext_attribute *eattr;
185 int addr = mdiodev->addr;
186 u64 val;
187
188 eattr = container_of(attr, struct dev_ext_attribute, attr);
189 sattr = eattr->var;
190
191 val = mdio_bus_get_stat(&bus->stats[addr], sattr->field_offset);
192
193 return sysfs_emit(buf, "%llu\n", val);
194 }
195
196 #define MDIO_BUS_STATS_ATTR_DECL(field, file) \
197 static struct dev_ext_attribute dev_attr_mdio_bus_##field = { \
198 .attr = { .attr = { .name = file, .mode = 0444 }, \
199 .show = mdio_bus_stat_field_show, \
200 }, \
201 .var = &((struct mdio_bus_stat_attr) { \
202 -1, offsetof(struct mdio_bus_stats, field) \
203 }), \
204 }; \
205 static struct dev_ext_attribute dev_attr_mdio_bus_device_##field = { \
206 .attr = { .attr = { .name = file, .mode = 0444 }, \
207 .show = mdio_bus_device_stat_field_show, \
208 }, \
209 .var = &((struct mdio_bus_stat_attr) { \
210 -1, offsetof(struct mdio_bus_stats, field) \
211 }), \
212 };
213
214 #define MDIO_BUS_STATS_ATTR(field) \
215 MDIO_BUS_STATS_ATTR_DECL(field, __stringify(field))
216
217 MDIO_BUS_STATS_ATTR(transfers);
218 MDIO_BUS_STATS_ATTR(errors);
219 MDIO_BUS_STATS_ATTR(writes);
220 MDIO_BUS_STATS_ATTR(reads);
221
222 #define MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, file) \
223 static struct dev_ext_attribute dev_attr_mdio_bus_addr_##field##_##addr = { \
224 .attr = { .attr = { .name = file, .mode = 0444 }, \
225 .show = mdio_bus_stat_field_show, \
226 }, \
227 .var = &((struct mdio_bus_stat_attr) { \
228 addr, offsetof(struct mdio_bus_stats, field) \
229 }), \
230 }
231
232 #define MDIO_BUS_STATS_ADDR_ATTR(field, addr) \
233 MDIO_BUS_STATS_ADDR_ATTR_DECL(field, addr, \
234 __stringify(field) "_" __stringify(addr))
235
236 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(addr) \
237 MDIO_BUS_STATS_ADDR_ATTR(transfers, addr); \
238 MDIO_BUS_STATS_ADDR_ATTR(errors, addr); \
239 MDIO_BUS_STATS_ADDR_ATTR(writes, addr); \
240 MDIO_BUS_STATS_ADDR_ATTR(reads, addr) \
241
242 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(0);
243 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(1);
244 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(2);
245 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(3);
246 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(4);
247 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(5);
248 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(6);
249 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(7);
250 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(8);
251 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(9);
252 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(10);
253 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(11);
254 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(12);
255 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(13);
256 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(14);
257 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(15);
258 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(16);
259 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(17);
260 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(18);
261 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(19);
262 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(20);
263 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(21);
264 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(22);
265 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(23);
266 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(24);
267 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(25);
268 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(26);
269 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(27);
270 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(28);
271 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(29);
272 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(30);
273 MDIO_BUS_STATS_ADDR_ATTR_GROUP_DECL(31);
274
275 #define MDIO_BUS_STATS_ADDR_ATTR_GROUP(addr) \
276 &dev_attr_mdio_bus_addr_transfers_##addr.attr.attr, \
277 &dev_attr_mdio_bus_addr_errors_##addr.attr.attr, \
278 &dev_attr_mdio_bus_addr_writes_##addr.attr.attr, \
279 &dev_attr_mdio_bus_addr_reads_##addr.attr.attr \
280
281 static struct attribute *mdio_bus_statistics_attrs[] = {
282 &dev_attr_mdio_bus_transfers.attr.attr,
283 &dev_attr_mdio_bus_errors.attr.attr,
284 &dev_attr_mdio_bus_writes.attr.attr,
285 &dev_attr_mdio_bus_reads.attr.attr,
286 MDIO_BUS_STATS_ADDR_ATTR_GROUP(0),
287 MDIO_BUS_STATS_ADDR_ATTR_GROUP(1),
288 MDIO_BUS_STATS_ADDR_ATTR_GROUP(2),
289 MDIO_BUS_STATS_ADDR_ATTR_GROUP(3),
290 MDIO_BUS_STATS_ADDR_ATTR_GROUP(4),
291 MDIO_BUS_STATS_ADDR_ATTR_GROUP(5),
292 MDIO_BUS_STATS_ADDR_ATTR_GROUP(6),
293 MDIO_BUS_STATS_ADDR_ATTR_GROUP(7),
294 MDIO_BUS_STATS_ADDR_ATTR_GROUP(8),
295 MDIO_BUS_STATS_ADDR_ATTR_GROUP(9),
296 MDIO_BUS_STATS_ADDR_ATTR_GROUP(10),
297 MDIO_BUS_STATS_ADDR_ATTR_GROUP(11),
298 MDIO_BUS_STATS_ADDR_ATTR_GROUP(12),
299 MDIO_BUS_STATS_ADDR_ATTR_GROUP(13),
300 MDIO_BUS_STATS_ADDR_ATTR_GROUP(14),
301 MDIO_BUS_STATS_ADDR_ATTR_GROUP(15),
302 MDIO_BUS_STATS_ADDR_ATTR_GROUP(16),
303 MDIO_BUS_STATS_ADDR_ATTR_GROUP(17),
304 MDIO_BUS_STATS_ADDR_ATTR_GROUP(18),
305 MDIO_BUS_STATS_ADDR_ATTR_GROUP(19),
306 MDIO_BUS_STATS_ADDR_ATTR_GROUP(20),
307 MDIO_BUS_STATS_ADDR_ATTR_GROUP(21),
308 MDIO_BUS_STATS_ADDR_ATTR_GROUP(22),
309 MDIO_BUS_STATS_ADDR_ATTR_GROUP(23),
310 MDIO_BUS_STATS_ADDR_ATTR_GROUP(24),
311 MDIO_BUS_STATS_ADDR_ATTR_GROUP(25),
312 MDIO_BUS_STATS_ADDR_ATTR_GROUP(26),
313 MDIO_BUS_STATS_ADDR_ATTR_GROUP(27),
314 MDIO_BUS_STATS_ADDR_ATTR_GROUP(28),
315 MDIO_BUS_STATS_ADDR_ATTR_GROUP(29),
316 MDIO_BUS_STATS_ADDR_ATTR_GROUP(30),
317 MDIO_BUS_STATS_ADDR_ATTR_GROUP(31),
318 NULL,
319 };
320
321 static const struct attribute_group mdio_bus_statistics_group = {
322 .name = "statistics",
323 .attrs = mdio_bus_statistics_attrs,
324 };
325
326 static const struct attribute_group *mdio_bus_groups[] = {
327 &mdio_bus_statistics_group,
328 NULL,
329 };
330
331 const struct class mdio_bus_class = {
332 .name = "mdio_bus",
333 .dev_release = mdiobus_release,
334 .dev_groups = mdio_bus_groups,
335 };
336 EXPORT_SYMBOL_GPL(mdio_bus_class);
337
338 /**
339 * mdio_find_bus - Given the name of a mdiobus, find the mii_bus.
340 * @mdio_name: The name of a mdiobus.
341 *
342 * Return: a reference to the mii_bus, or NULL if none found. The
343 * embedded struct device will have its reference count incremented,
344 * and this must be put_deviced'ed once the bus is finished with.
345 */
mdio_find_bus(const char * mdio_name)346 struct mii_bus *mdio_find_bus(const char *mdio_name)
347 {
348 struct device *d;
349
350 d = class_find_device_by_name(&mdio_bus_class, mdio_name);
351 return d ? to_mii_bus(d) : NULL;
352 }
353 EXPORT_SYMBOL(mdio_find_bus);
354
355 #if IS_ENABLED(CONFIG_OF_MDIO)
356 /**
357 * of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
358 * @mdio_bus_np: Pointer to the mii_bus.
359 *
360 * Return: a reference to the mii_bus, or NULL if none found. The
361 * embedded struct device will have its reference count incremented,
362 * and this must be put once the bus is finished with.
363 *
364 * Because the association of a device_node and mii_bus is made via
365 * of_mdiobus_register(), the mii_bus cannot be found before it is
366 * registered with of_mdiobus_register().
367 *
368 */
of_mdio_find_bus(struct device_node * mdio_bus_np)369 struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
370 {
371 struct device *d;
372
373 if (!mdio_bus_np)
374 return NULL;
375
376 d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
377 return d ? to_mii_bus(d) : NULL;
378 }
379 EXPORT_SYMBOL(of_mdio_find_bus);
380 #endif
381
mdiobus_stats_acct(struct mdio_bus_stats * stats,bool op,int ret)382 static void mdiobus_stats_acct(struct mdio_bus_stats *stats, bool op, int ret)
383 {
384 preempt_disable();
385 u64_stats_update_begin(&stats->syncp);
386
387 u64_stats_inc(&stats->transfers);
388 if (ret < 0) {
389 u64_stats_inc(&stats->errors);
390 goto out;
391 }
392
393 if (op)
394 u64_stats_inc(&stats->reads);
395 else
396 u64_stats_inc(&stats->writes);
397 out:
398 u64_stats_update_end(&stats->syncp);
399 preempt_enable();
400 }
401
402 /**
403 * __mdiobus_read - Unlocked version of the mdiobus_read function
404 * @bus: the mii_bus struct
405 * @addr: the phy address
406 * @regnum: register number to read
407 *
408 * Return: The register value if successful, negative error code on failure
409 *
410 * Read a MDIO bus register. Caller must hold the mdio bus lock.
411 *
412 * NOTE: MUST NOT be called from interrupt context.
413 */
__mdiobus_read(struct mii_bus * bus,int addr,u32 regnum)414 int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
415 {
416 int retval;
417
418 lockdep_assert_held_once(&bus->mdio_lock);
419
420 if (addr >= PHY_MAX_ADDR)
421 return -ENXIO;
422
423 if (bus->read)
424 retval = bus->read(bus, addr, regnum);
425 else
426 retval = -EOPNOTSUPP;
427
428 trace_mdio_access(bus, 1, addr, regnum, retval, retval);
429 mdiobus_stats_acct(&bus->stats[addr], true, retval);
430
431 return retval;
432 }
433 EXPORT_SYMBOL(__mdiobus_read);
434
435 /**
436 * __mdiobus_write - Unlocked version of the mdiobus_write function
437 * @bus: the mii_bus struct
438 * @addr: the phy address
439 * @regnum: register number to write
440 * @val: value to write to @regnum
441 *
442 * Return: Zero if successful, negative error code on failure
443 *
444 * Write a MDIO bus register. Caller must hold the mdio bus lock.
445 *
446 * NOTE: MUST NOT be called from interrupt context.
447 */
__mdiobus_write(struct mii_bus * bus,int addr,u32 regnum,u16 val)448 int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
449 {
450 int err;
451
452 lockdep_assert_held_once(&bus->mdio_lock);
453
454 if (addr >= PHY_MAX_ADDR)
455 return -ENXIO;
456
457 if (bus->write)
458 err = bus->write(bus, addr, regnum, val);
459 else
460 err = -EOPNOTSUPP;
461
462 trace_mdio_access(bus, 0, addr, regnum, val, err);
463 mdiobus_stats_acct(&bus->stats[addr], false, err);
464
465 return err;
466 }
467 EXPORT_SYMBOL(__mdiobus_write);
468
469 /**
470 * __mdiobus_modify_changed - Unlocked version of the mdiobus_modify function
471 * @bus: the mii_bus struct
472 * @addr: the phy address
473 * @regnum: register number to modify
474 * @mask: bit mask of bits to clear
475 * @set: bit mask of bits to set
476 *
477 * Return: 1 if the register was modified, 0 if no change was needed,
478 * negative on any error condition
479 *
480 * Read, modify, and if any change, write the register value back to the
481 * device.
482 *
483 * NOTE: MUST NOT be called from interrupt context.
484 */
__mdiobus_modify_changed(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)485 int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
486 u16 mask, u16 set)
487 {
488 int new, ret;
489
490 ret = __mdiobus_read(bus, addr, regnum);
491 if (ret < 0)
492 return ret;
493
494 new = (ret & ~mask) | set;
495 if (new == ret)
496 return 0;
497
498 ret = __mdiobus_write(bus, addr, regnum, new);
499
500 return ret < 0 ? ret : 1;
501 }
502 EXPORT_SYMBOL_GPL(__mdiobus_modify_changed);
503
504 /**
505 * __mdiobus_c45_read - Unlocked version of the mdiobus_c45_read function
506 * @bus: the mii_bus struct
507 * @addr: the phy address
508 * @devad: device address to read
509 * @regnum: register number to read
510 *
511 * Return: The register value if successful, negative error code on failure
512 *
513 * Read a MDIO bus register. Caller must hold the mdio bus lock.
514 *
515 * NOTE: MUST NOT be called from interrupt context.
516 */
__mdiobus_c45_read(struct mii_bus * bus,int addr,int devad,u32 regnum)517 int __mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
518 {
519 int retval;
520
521 lockdep_assert_held_once(&bus->mdio_lock);
522
523 if (addr >= PHY_MAX_ADDR)
524 return -ENXIO;
525
526 if (bus->read_c45)
527 retval = bus->read_c45(bus, addr, devad, regnum);
528 else
529 retval = -EOPNOTSUPP;
530
531 trace_mdio_access(bus, 1, addr, regnum, retval, retval);
532 mdiobus_stats_acct(&bus->stats[addr], true, retval);
533
534 return retval;
535 }
536 EXPORT_SYMBOL(__mdiobus_c45_read);
537
538 /**
539 * __mdiobus_c45_write - Unlocked version of the mdiobus_write function
540 * @bus: the mii_bus struct
541 * @addr: the phy address
542 * @devad: device address to read
543 * @regnum: register number to write
544 * @val: value to write to @regnum
545 *
546 * Return: Zero if successful, negative error code on failure
547 *
548 * Write a MDIO bus register. Caller must hold the mdio bus lock.
549 *
550 * NOTE: MUST NOT be called from interrupt context.
551 */
__mdiobus_c45_write(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)552 int __mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
553 u16 val)
554 {
555 int err;
556
557 lockdep_assert_held_once(&bus->mdio_lock);
558
559 if (addr >= PHY_MAX_ADDR)
560 return -ENXIO;
561
562 if (bus->write_c45)
563 err = bus->write_c45(bus, addr, devad, regnum, val);
564 else
565 err = -EOPNOTSUPP;
566
567 trace_mdio_access(bus, 0, addr, regnum, val, err);
568 mdiobus_stats_acct(&bus->stats[addr], false, err);
569
570 return err;
571 }
572 EXPORT_SYMBOL(__mdiobus_c45_write);
573
574 /**
575 * __mdiobus_c45_modify_changed - Unlocked version of the mdiobus_modify function
576 * @bus: the mii_bus struct
577 * @addr: the phy address
578 * @devad: device address to read
579 * @regnum: register number to modify
580 * @mask: bit mask of bits to clear
581 * @set: bit mask of bits to set
582 *
583 * Return: 1 if the register was modified, 0 if no change was needed,
584 * negative on any error condition
585 *
586 * Read, modify, and if any change, write the register value back to the
587 * device. Any error returns a negative number.
588 *
589 * NOTE: MUST NOT be called from interrupt context.
590 */
__mdiobus_c45_modify_changed(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)591 static int __mdiobus_c45_modify_changed(struct mii_bus *bus, int addr,
592 int devad, u32 regnum, u16 mask,
593 u16 set)
594 {
595 int new, ret;
596
597 ret = __mdiobus_c45_read(bus, addr, devad, regnum);
598 if (ret < 0)
599 return ret;
600
601 new = (ret & ~mask) | set;
602 if (new == ret)
603 return 0;
604
605 ret = __mdiobus_c45_write(bus, addr, devad, regnum, new);
606
607 return ret < 0 ? ret : 1;
608 }
609
610 /**
611 * mdiobus_read_nested - Nested version of the mdiobus_read function
612 * @bus: the mii_bus struct
613 * @addr: the phy address
614 * @regnum: register number to read
615 *
616 * Return: The register value if successful, negative error code on failure
617 *
618 * In case of nested MDIO bus access avoid lockdep false positives by
619 * using mutex_lock_nested().
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 */
mdiobus_read_nested(struct mii_bus * bus,int addr,u32 regnum)625 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum)
626 {
627 int retval;
628
629 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
630 retval = __mdiobus_read(bus, addr, regnum);
631 mutex_unlock(&bus->mdio_lock);
632
633 return retval;
634 }
635 EXPORT_SYMBOL(mdiobus_read_nested);
636
637 /**
638 * mdiobus_read - Convenience function for reading a given MII mgmt register
639 * @bus: the mii_bus struct
640 * @addr: the phy address
641 * @regnum: register number to read
642 *
643 * Return: The register value if successful, negative error code on failure
644 *
645 * NOTE: MUST NOT be called from interrupt context,
646 * because the bus read/write functions may wait for an interrupt
647 * to conclude the operation.
648 */
mdiobus_read(struct mii_bus * bus,int addr,u32 regnum)649 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
650 {
651 int retval;
652
653 mutex_lock(&bus->mdio_lock);
654 retval = __mdiobus_read(bus, addr, regnum);
655 mutex_unlock(&bus->mdio_lock);
656
657 return retval;
658 }
659 EXPORT_SYMBOL(mdiobus_read);
660
661 /**
662 * mdiobus_c45_read - Convenience function for reading a given MII mgmt register
663 * @bus: the mii_bus struct
664 * @addr: the phy address
665 * @devad: device address to read
666 * @regnum: register number to read
667 *
668 * Return: The register value if successful, negative error code on failure
669 *
670 * NOTE: MUST NOT be called from interrupt context,
671 * because the bus read/write functions may wait for an interrupt
672 * to conclude the operation.
673 */
mdiobus_c45_read(struct mii_bus * bus,int addr,int devad,u32 regnum)674 int mdiobus_c45_read(struct mii_bus *bus, int addr, int devad, u32 regnum)
675 {
676 int retval;
677
678 mutex_lock(&bus->mdio_lock);
679 retval = __mdiobus_c45_read(bus, addr, devad, regnum);
680 mutex_unlock(&bus->mdio_lock);
681
682 return retval;
683 }
684 EXPORT_SYMBOL(mdiobus_c45_read);
685
686 /**
687 * mdiobus_c45_read_nested - Nested version of the mdiobus_c45_read function
688 * @bus: the mii_bus struct
689 * @addr: the phy address
690 * @devad: device address to read
691 * @regnum: register number to read
692 *
693 * Return: The register value if successful, negative error code on failure
694 *
695 * In case of nested MDIO bus access avoid lockdep false positives by
696 * using mutex_lock_nested().
697 *
698 * NOTE: MUST NOT be called from interrupt context,
699 * because the bus read/write functions may wait for an interrupt
700 * to conclude the operation.
701 */
mdiobus_c45_read_nested(struct mii_bus * bus,int addr,int devad,u32 regnum)702 int mdiobus_c45_read_nested(struct mii_bus *bus, int addr, int devad,
703 u32 regnum)
704 {
705 int retval;
706
707 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
708 retval = __mdiobus_c45_read(bus, addr, devad, regnum);
709 mutex_unlock(&bus->mdio_lock);
710
711 return retval;
712 }
713 EXPORT_SYMBOL(mdiobus_c45_read_nested);
714
715 /**
716 * mdiobus_write_nested - Nested version of the mdiobus_write function
717 * @bus: the mii_bus struct
718 * @addr: the phy address
719 * @regnum: register number to write
720 * @val: value to write to @regnum
721 *
722 * Return: Zero if successful, negative error code on failure
723 *
724 * In case of nested MDIO bus access avoid lockdep false positives by
725 * using mutex_lock_nested().
726 *
727 * NOTE: MUST NOT be called from interrupt context,
728 * because the bus read/write functions may wait for an interrupt
729 * to conclude the operation.
730 */
mdiobus_write_nested(struct mii_bus * bus,int addr,u32 regnum,u16 val)731 int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val)
732 {
733 int err;
734
735 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
736 err = __mdiobus_write(bus, addr, regnum, val);
737 mutex_unlock(&bus->mdio_lock);
738
739 return err;
740 }
741 EXPORT_SYMBOL(mdiobus_write_nested);
742
743 /**
744 * mdiobus_write - Convenience function for writing a given MII mgmt register
745 * @bus: the mii_bus struct
746 * @addr: the phy address
747 * @regnum: register number to write
748 * @val: value to write to @regnum
749 *
750 * Return: Zero if successful, negative error code on failure
751 *
752 * NOTE: MUST NOT be called from interrupt context,
753 * because the bus read/write functions may wait for an interrupt
754 * to conclude the operation.
755 */
mdiobus_write(struct mii_bus * bus,int addr,u32 regnum,u16 val)756 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val)
757 {
758 int err;
759
760 mutex_lock(&bus->mdio_lock);
761 err = __mdiobus_write(bus, addr, regnum, val);
762 mutex_unlock(&bus->mdio_lock);
763
764 return err;
765 }
766 EXPORT_SYMBOL(mdiobus_write);
767
768 /**
769 * mdiobus_c45_write - Convenience function for writing a given MII mgmt register
770 * @bus: the mii_bus struct
771 * @addr: the phy address
772 * @devad: device address to read
773 * @regnum: register number to write
774 * @val: value to write to @regnum
775 *
776 * Return: Zero if successful, negative error code on failure
777 *
778 * NOTE: MUST NOT be called from interrupt context,
779 * because the bus read/write functions may wait for an interrupt
780 * to conclude the operation.
781 */
mdiobus_c45_write(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)782 int mdiobus_c45_write(struct mii_bus *bus, int addr, int devad, u32 regnum,
783 u16 val)
784 {
785 int err;
786
787 mutex_lock(&bus->mdio_lock);
788 err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
789 mutex_unlock(&bus->mdio_lock);
790
791 return err;
792 }
793 EXPORT_SYMBOL(mdiobus_c45_write);
794
795 /**
796 * mdiobus_c45_write_nested - Nested version of the mdiobus_c45_write function
797 * @bus: the mii_bus struct
798 * @addr: the phy address
799 * @devad: device address to read
800 * @regnum: register number to write
801 * @val: value to write to @regnum
802 *
803 * Return: Zero if successful, negative error code on failure
804 *
805 * In case of nested MDIO bus access avoid lockdep false positives by
806 * using mutex_lock_nested().
807 *
808 * NOTE: MUST NOT be called from interrupt context,
809 * because the bus read/write functions may wait for an interrupt
810 * to conclude the operation.
811 */
mdiobus_c45_write_nested(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 val)812 int mdiobus_c45_write_nested(struct mii_bus *bus, int addr, int devad,
813 u32 regnum, u16 val)
814 {
815 int err;
816
817 mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED);
818 err = __mdiobus_c45_write(bus, addr, devad, regnum, val);
819 mutex_unlock(&bus->mdio_lock);
820
821 return err;
822 }
823 EXPORT_SYMBOL(mdiobus_c45_write_nested);
824
825 /*
826 * __mdiobus_modify - Convenience function for modifying a given mdio device
827 * register
828 * @bus: the mii_bus struct
829 * @addr: the phy address
830 * @regnum: register number to write
831 * @mask: bit mask of bits to clear
832 * @set: bit mask of bits to set
833 *
834 * Return: 0 on success, negative on any error condition
835 */
__mdiobus_modify(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)836 int __mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
837 u16 set)
838 {
839 int err;
840
841 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
842
843 return err < 0 ? err : 0;
844 }
845 EXPORT_SYMBOL_GPL(__mdiobus_modify);
846
847 /**
848 * mdiobus_modify - Convenience function for modifying a given mdio device
849 * register
850 * @bus: the mii_bus struct
851 * @addr: the phy address
852 * @regnum: register number to write
853 * @mask: bit mask of bits to clear
854 * @set: bit mask of bits to set
855 *
856 * Return: 0 on success, negative on any error condition
857 */
mdiobus_modify(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)858 int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask, u16 set)
859 {
860 int err;
861
862 mutex_lock(&bus->mdio_lock);
863 err = __mdiobus_modify(bus, addr, regnum, mask, set);
864 mutex_unlock(&bus->mdio_lock);
865
866 return err;
867 }
868 EXPORT_SYMBOL_GPL(mdiobus_modify);
869
870 /**
871 * mdiobus_c45_modify - Convenience function for modifying a given mdio device
872 * register
873 * @bus: the mii_bus struct
874 * @addr: the phy address
875 * @devad: device address to read
876 * @regnum: register number to write
877 * @mask: bit mask of bits to clear
878 * @set: bit mask of bits to set
879 *
880 * Return: 0 on success, negative on any error condition
881 */
mdiobus_c45_modify(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)882 int mdiobus_c45_modify(struct mii_bus *bus, int addr, int devad, u32 regnum,
883 u16 mask, u16 set)
884 {
885 int err;
886
887 mutex_lock(&bus->mdio_lock);
888 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum,
889 mask, set);
890 mutex_unlock(&bus->mdio_lock);
891
892 return err < 0 ? err : 0;
893 }
894 EXPORT_SYMBOL_GPL(mdiobus_c45_modify);
895
896 /**
897 * mdiobus_modify_changed - Convenience function for modifying a given mdio
898 * device register and returning if it changed
899 * @bus: the mii_bus struct
900 * @addr: the phy address
901 * @regnum: register number to write
902 * @mask: bit mask of bits to clear
903 * @set: bit mask of bits to set
904 *
905 * Return: 1 if the register was modified, 0 if no change was needed,
906 * negative on any error condition
907 */
mdiobus_modify_changed(struct mii_bus * bus,int addr,u32 regnum,u16 mask,u16 set)908 int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
909 u16 mask, u16 set)
910 {
911 int err;
912
913 mutex_lock(&bus->mdio_lock);
914 err = __mdiobus_modify_changed(bus, addr, regnum, mask, set);
915 mutex_unlock(&bus->mdio_lock);
916
917 return err;
918 }
919 EXPORT_SYMBOL_GPL(mdiobus_modify_changed);
920
921 /**
922 * mdiobus_c45_modify_changed - Convenience function for modifying a given mdio
923 * device register and returning if it changed
924 * @bus: the mii_bus struct
925 * @addr: the phy address
926 * @devad: device address to read
927 * @regnum: register number to write
928 * @mask: bit mask of bits to clear
929 * @set: bit mask of bits to set
930 *
931 * Return: 1 if the register was modified, 0 if no change was needed,
932 * negative on any error condition
933 */
mdiobus_c45_modify_changed(struct mii_bus * bus,int addr,int devad,u32 regnum,u16 mask,u16 set)934 int mdiobus_c45_modify_changed(struct mii_bus *bus, int addr, int devad,
935 u32 regnum, u16 mask, u16 set)
936 {
937 int err;
938
939 mutex_lock(&bus->mdio_lock);
940 err = __mdiobus_c45_modify_changed(bus, addr, devad, regnum, mask, set);
941 mutex_unlock(&bus->mdio_lock);
942
943 return err;
944 }
945 EXPORT_SYMBOL_GPL(mdiobus_c45_modify_changed);
946
947 /**
948 * mdio_bus_match - determine if given MDIO driver supports the given
949 * MDIO device
950 * @dev: target MDIO device
951 * @drv: given MDIO driver
952 *
953 * Return: 1 if the driver supports the device, 0 otherwise
954 *
955 * Description: This may require calling the devices own match function,
956 * since different classes of MDIO devices have different match criteria.
957 */
mdio_bus_match(struct device * dev,const struct device_driver * drv)958 static int mdio_bus_match(struct device *dev, const struct device_driver *drv)
959 {
960 const struct mdio_driver *mdiodrv = to_mdio_driver(drv);
961 struct mdio_device *mdio = to_mdio_device(dev);
962
963 /* Both the driver and device must type-match */
964 if (!(mdiodrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY) !=
965 !(mdio->flags & MDIO_DEVICE_FLAG_PHY))
966 return 0;
967
968 if (of_driver_match_device(dev, drv))
969 return 1;
970
971 if (mdio->bus_match)
972 return mdio->bus_match(dev, drv);
973
974 return 0;
975 }
976
mdio_uevent(const struct device * dev,struct kobj_uevent_env * env)977 static int mdio_uevent(const struct device *dev, struct kobj_uevent_env *env)
978 {
979 int rc;
980
981 /* Some devices have extra OF data and an OF-style MODALIAS */
982 rc = of_device_uevent_modalias(dev, env);
983 if (rc != -ENODEV)
984 return rc;
985
986 return 0;
987 }
988
989 static struct attribute *mdio_bus_device_statistics_attrs[] = {
990 &dev_attr_mdio_bus_device_transfers.attr.attr,
991 &dev_attr_mdio_bus_device_errors.attr.attr,
992 &dev_attr_mdio_bus_device_writes.attr.attr,
993 &dev_attr_mdio_bus_device_reads.attr.attr,
994 NULL,
995 };
996
997 static const struct attribute_group mdio_bus_device_statistics_group = {
998 .name = "statistics",
999 .attrs = mdio_bus_device_statistics_attrs,
1000 };
1001
1002 static const struct attribute_group *mdio_bus_dev_groups[] = {
1003 &mdio_bus_device_statistics_group,
1004 NULL,
1005 };
1006
1007 const struct bus_type mdio_bus_type = {
1008 .name = "mdio_bus",
1009 .dev_groups = mdio_bus_dev_groups,
1010 .match = mdio_bus_match,
1011 .uevent = mdio_uevent,
1012 };
1013 EXPORT_SYMBOL(mdio_bus_type);
1014
mdio_bus_init(void)1015 static int __init mdio_bus_init(void)
1016 {
1017 int ret;
1018
1019 ret = class_register(&mdio_bus_class);
1020 if (!ret) {
1021 ret = bus_register(&mdio_bus_type);
1022 if (ret)
1023 class_unregister(&mdio_bus_class);
1024 }
1025
1026 return ret;
1027 }
1028
mdio_bus_exit(void)1029 static void __exit mdio_bus_exit(void)
1030 {
1031 class_unregister(&mdio_bus_class);
1032 bus_unregister(&mdio_bus_type);
1033 }
1034
1035 subsys_initcall(mdio_bus_init);
1036 module_exit(mdio_bus_exit);
1037
1038 MODULE_LICENSE("GPL");
1039 MODULE_DESCRIPTION("MDIO bus/device layer");
1040