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