Loading...
1/*
2 * drivers/net/phy/phy_device.c
3 *
4 * Framework for finding and configuring PHYs.
5 * Also contains generic PHY driver
6 *
7 * Author: Andy Fleming
8 *
9 * Copyright (c) 2004 Freescale Semiconductor, Inc.
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 *
16 */
17#include <linux/kernel.h>
18#include <linux/string.h>
19#include <linux/errno.h>
20#include <linux/unistd.h>
21#include <linux/slab.h>
22#include <linux/interrupt.h>
23#include <linux/init.h>
24#include <linux/delay.h>
25#include <linux/netdevice.h>
26#include <linux/etherdevice.h>
27#include <linux/skbuff.h>
28#include <linux/mm.h>
29#include <linux/module.h>
30#include <linux/mii.h>
31#include <linux/ethtool.h>
32#include <linux/phy.h>
33
34#include <asm/io.h>
35#include <asm/irq.h>
36#include <asm/uaccess.h>
37
38MODULE_DESCRIPTION("PHY library");
39MODULE_AUTHOR("Andy Fleming");
40MODULE_LICENSE("GPL");
41
42void phy_device_free(struct phy_device *phydev)
43{
44 kfree(phydev);
45}
46EXPORT_SYMBOL(phy_device_free);
47
48static void phy_device_release(struct device *dev)
49{
50 phy_device_free(to_phy_device(dev));
51}
52
53static struct phy_driver genphy_driver;
54extern int mdio_bus_init(void);
55extern void mdio_bus_exit(void);
56
57static LIST_HEAD(phy_fixup_list);
58static DEFINE_MUTEX(phy_fixup_lock);
59
60static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
61 u32 flags, phy_interface_t interface);
62
63/*
64 * Creates a new phy_fixup and adds it to the list
65 * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
66 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
67 * It can also be PHY_ANY_UID
68 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
69 * comparison
70 * @run: The actual code to be run when a matching PHY is found
71 */
72int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
73 int (*run)(struct phy_device *))
74{
75 struct phy_fixup *fixup;
76
77 fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
78 if (!fixup)
79 return -ENOMEM;
80
81 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
82 fixup->phy_uid = phy_uid;
83 fixup->phy_uid_mask = phy_uid_mask;
84 fixup->run = run;
85
86 mutex_lock(&phy_fixup_lock);
87 list_add_tail(&fixup->list, &phy_fixup_list);
88 mutex_unlock(&phy_fixup_lock);
89
90 return 0;
91}
92EXPORT_SYMBOL(phy_register_fixup);
93
94/* Registers a fixup to be run on any PHY with the UID in phy_uid */
95int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
96 int (*run)(struct phy_device *))
97{
98 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
99}
100EXPORT_SYMBOL(phy_register_fixup_for_uid);
101
102/* Registers a fixup to be run on the PHY with id string bus_id */
103int phy_register_fixup_for_id(const char *bus_id,
104 int (*run)(struct phy_device *))
105{
106 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
107}
108EXPORT_SYMBOL(phy_register_fixup_for_id);
109
110/*
111 * Returns 1 if fixup matches phydev in bus_id and phy_uid.
112 * Fixups can be set to match any in one or more fields.
113 */
114static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
115{
116 if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
117 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
118 return 0;
119
120 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
121 (phydev->phy_id & fixup->phy_uid_mask))
122 if (fixup->phy_uid != PHY_ANY_UID)
123 return 0;
124
125 return 1;
126}
127
128/* Runs any matching fixups for this phydev */
129int phy_scan_fixups(struct phy_device *phydev)
130{
131 struct phy_fixup *fixup;
132
133 mutex_lock(&phy_fixup_lock);
134 list_for_each_entry(fixup, &phy_fixup_list, list) {
135 if (phy_needs_fixup(phydev, fixup)) {
136 int err;
137
138 err = fixup->run(phydev);
139
140 if (err < 0) {
141 mutex_unlock(&phy_fixup_lock);
142 return err;
143 }
144 }
145 }
146 mutex_unlock(&phy_fixup_lock);
147
148 return 0;
149}
150EXPORT_SYMBOL(phy_scan_fixups);
151
152static struct phy_device* phy_device_create(struct mii_bus *bus,
153 int addr, int phy_id)
154{
155 struct phy_device *dev;
156
157 /* We allocate the device, and initialize the
158 * default values */
159 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
160
161 if (NULL == dev)
162 return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
163
164 dev->dev.release = phy_device_release;
165
166 dev->speed = 0;
167 dev->duplex = -1;
168 dev->pause = dev->asym_pause = 0;
169 dev->link = 1;
170 dev->interface = PHY_INTERFACE_MODE_GMII;
171
172 dev->autoneg = AUTONEG_ENABLE;
173
174 dev->addr = addr;
175 dev->phy_id = phy_id;
176 dev->bus = bus;
177 dev->dev.parent = bus->parent;
178 dev->dev.bus = &mdio_bus_type;
179 dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
180 dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
181
182 dev->state = PHY_DOWN;
183
184 mutex_init(&dev->lock);
185 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
186
187 /* Request the appropriate module unconditionally; don't
188 bother trying to do so only if it isn't already loaded,
189 because that gets complicated. A hotplug event would have
190 done an unconditional modprobe anyway.
191 We don't do normal hotplug because it won't work for MDIO
192 -- because it relies on the device staying around for long
193 enough for the driver to get loaded. With MDIO, the NIC
194 driver will get bored and give up as soon as it finds that
195 there's no driver _already_ loaded. */
196 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
197
198 return dev;
199}
200
201/**
202 * get_phy_id - reads the specified addr for its ID.
203 * @bus: the target MII bus
204 * @addr: PHY address on the MII bus
205 * @phy_id: where to store the ID retrieved.
206 *
207 * Description: Reads the ID registers of the PHY at @addr on the
208 * @bus, stores it in @phy_id and returns zero on success.
209 */
210int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id)
211{
212 int phy_reg;
213
214 /* Grab the bits from PHYIR1, and put them
215 * in the upper half */
216 phy_reg = bus->read(bus, addr, MII_PHYSID1);
217
218 if (phy_reg < 0)
219 return -EIO;
220
221 *phy_id = (phy_reg & 0xffff) << 16;
222
223 /* Grab the bits from PHYIR2, and put them in the lower half */
224 phy_reg = bus->read(bus, addr, MII_PHYSID2);
225
226 if (phy_reg < 0)
227 return -EIO;
228
229 *phy_id |= (phy_reg & 0xffff);
230
231 return 0;
232}
233EXPORT_SYMBOL(get_phy_id);
234
235/**
236 * get_phy_device - reads the specified PHY device and returns its @phy_device struct
237 * @bus: the target MII bus
238 * @addr: PHY address on the MII bus
239 *
240 * Description: Reads the ID registers of the PHY at @addr on the
241 * @bus, then allocates and returns the phy_device to represent it.
242 */
243struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
244{
245 struct phy_device *dev = NULL;
246 u32 phy_id;
247 int r;
248
249 r = get_phy_id(bus, addr, &phy_id);
250 if (r)
251 return ERR_PTR(r);
252
253 /* If the phy_id is mostly Fs, there is no device there */
254 if ((phy_id & 0x1fffffff) == 0x1fffffff)
255 return NULL;
256
257 dev = phy_device_create(bus, addr, phy_id);
258
259 return dev;
260}
261EXPORT_SYMBOL(get_phy_device);
262
263/**
264 * phy_device_register - Register the phy device on the MDIO bus
265 * @phydev: phy_device structure to be added to the MDIO bus
266 */
267int phy_device_register(struct phy_device *phydev)
268{
269 int err;
270
271 /* Don't register a phy if one is already registered at this
272 * address */
273 if (phydev->bus->phy_map[phydev->addr])
274 return -EINVAL;
275 phydev->bus->phy_map[phydev->addr] = phydev;
276
277 /* Run all of the fixups for this PHY */
278 phy_scan_fixups(phydev);
279
280 err = device_register(&phydev->dev);
281 if (err) {
282 pr_err("phy %d failed to register\n", phydev->addr);
283 goto out;
284 }
285
286 return 0;
287
288 out:
289 phydev->bus->phy_map[phydev->addr] = NULL;
290 return err;
291}
292EXPORT_SYMBOL(phy_device_register);
293
294/**
295 * phy_find_first - finds the first PHY device on the bus
296 * @bus: the target MII bus
297 */
298struct phy_device *phy_find_first(struct mii_bus *bus)
299{
300 int addr;
301
302 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
303 if (bus->phy_map[addr])
304 return bus->phy_map[addr];
305 }
306 return NULL;
307}
308EXPORT_SYMBOL(phy_find_first);
309
310/**
311 * phy_prepare_link - prepares the PHY layer to monitor link status
312 * @phydev: target phy_device struct
313 * @handler: callback function for link status change notifications
314 *
315 * Description: Tells the PHY infrastructure to handle the
316 * gory details on monitoring link status (whether through
317 * polling or an interrupt), and to call back to the
318 * connected device driver when the link status changes.
319 * If you want to monitor your own link state, don't call
320 * this function.
321 */
322static void phy_prepare_link(struct phy_device *phydev,
323 void (*handler)(struct net_device *))
324{
325 phydev->adjust_link = handler;
326}
327
328/**
329 * phy_connect_direct - connect an ethernet device to a specific phy_device
330 * @dev: the network device to connect
331 * @phydev: the pointer to the phy device
332 * @handler: callback function for state change notifications
333 * @flags: PHY device's dev_flags
334 * @interface: PHY device's interface
335 */
336int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
337 void (*handler)(struct net_device *), u32 flags,
338 phy_interface_t interface)
339{
340 int rc;
341
342 rc = phy_attach_direct(dev, phydev, flags, interface);
343 if (rc)
344 return rc;
345
346 phy_prepare_link(phydev, handler);
347 phy_start_machine(phydev, NULL);
348 if (phydev->irq > 0)
349 phy_start_interrupts(phydev);
350
351 return 0;
352}
353EXPORT_SYMBOL(phy_connect_direct);
354
355/**
356 * phy_connect - connect an ethernet device to a PHY device
357 * @dev: the network device to connect
358 * @bus_id: the id string of the PHY device to connect
359 * @handler: callback function for state change notifications
360 * @flags: PHY device's dev_flags
361 * @interface: PHY device's interface
362 *
363 * Description: Convenience function for connecting ethernet
364 * devices to PHY devices. The default behavior is for
365 * the PHY infrastructure to handle everything, and only notify
366 * the connected driver when the link status changes. If you
367 * don't want, or can't use the provided functionality, you may
368 * choose to call only the subset of functions which provide
369 * the desired functionality.
370 */
371struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
372 void (*handler)(struct net_device *), u32 flags,
373 phy_interface_t interface)
374{
375 struct phy_device *phydev;
376 struct device *d;
377 int rc;
378
379 /* Search the list of PHY devices on the mdio bus for the
380 * PHY with the requested name */
381 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
382 if (!d) {
383 pr_err("PHY %s not found\n", bus_id);
384 return ERR_PTR(-ENODEV);
385 }
386 phydev = to_phy_device(d);
387
388 rc = phy_connect_direct(dev, phydev, handler, flags, interface);
389 if (rc)
390 return ERR_PTR(rc);
391
392 return phydev;
393}
394EXPORT_SYMBOL(phy_connect);
395
396/**
397 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
398 * @phydev: target phy_device struct
399 */
400void phy_disconnect(struct phy_device *phydev)
401{
402 if (phydev->irq > 0)
403 phy_stop_interrupts(phydev);
404
405 phy_stop_machine(phydev);
406
407 phydev->adjust_link = NULL;
408
409 phy_detach(phydev);
410}
411EXPORT_SYMBOL(phy_disconnect);
412
413int phy_init_hw(struct phy_device *phydev)
414{
415 int ret;
416
417 if (!phydev->drv || !phydev->drv->config_init)
418 return 0;
419
420 ret = phy_scan_fixups(phydev);
421 if (ret < 0)
422 return ret;
423
424 return phydev->drv->config_init(phydev);
425}
426
427/**
428 * phy_attach_direct - attach a network device to a given PHY device pointer
429 * @dev: network device to attach
430 * @phydev: Pointer to phy_device to attach
431 * @flags: PHY device's dev_flags
432 * @interface: PHY device's interface
433 *
434 * Description: Called by drivers to attach to a particular PHY
435 * device. The phy_device is found, and properly hooked up
436 * to the phy_driver. If no driver is attached, then the
437 * genphy_driver is used. The phy_device is given a ptr to
438 * the attaching device, and given a callback for link status
439 * change. The phy_device is returned to the attaching driver.
440 */
441static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
442 u32 flags, phy_interface_t interface)
443{
444 struct device *d = &phydev->dev;
445 int err;
446
447 /* Assume that if there is no driver, that it doesn't
448 * exist, and we should use the genphy driver. */
449 if (NULL == d->driver) {
450 d->driver = &genphy_driver.driver;
451
452 err = d->driver->probe(d);
453 if (err >= 0)
454 err = device_bind_driver(d);
455
456 if (err)
457 return err;
458 }
459
460 if (phydev->attached_dev) {
461 dev_err(&dev->dev, "PHY already attached\n");
462 return -EBUSY;
463 }
464
465 phydev->attached_dev = dev;
466 dev->phydev = phydev;
467
468 phydev->dev_flags = flags;
469
470 phydev->interface = interface;
471
472 phydev->state = PHY_READY;
473
474 /* Do initial configuration here, now that
475 * we have certain key parameters
476 * (dev_flags and interface) */
477 err = phy_init_hw(phydev);
478 if (err)
479 phy_detach(phydev);
480
481 return err;
482}
483
484/**
485 * phy_attach - attach a network device to a particular PHY device
486 * @dev: network device to attach
487 * @bus_id: Bus ID of PHY device to attach
488 * @flags: PHY device's dev_flags
489 * @interface: PHY device's interface
490 *
491 * Description: Same as phy_attach_direct() except that a PHY bus_id
492 * string is passed instead of a pointer to a struct phy_device.
493 */
494struct phy_device *phy_attach(struct net_device *dev,
495 const char *bus_id, u32 flags, phy_interface_t interface)
496{
497 struct bus_type *bus = &mdio_bus_type;
498 struct phy_device *phydev;
499 struct device *d;
500 int rc;
501
502 /* Search the list of PHY devices on the mdio bus for the
503 * PHY with the requested name */
504 d = bus_find_device_by_name(bus, NULL, bus_id);
505 if (!d) {
506 pr_err("PHY %s not found\n", bus_id);
507 return ERR_PTR(-ENODEV);
508 }
509 phydev = to_phy_device(d);
510
511 rc = phy_attach_direct(dev, phydev, flags, interface);
512 if (rc)
513 return ERR_PTR(rc);
514
515 return phydev;
516}
517EXPORT_SYMBOL(phy_attach);
518
519/**
520 * phy_detach - detach a PHY device from its network device
521 * @phydev: target phy_device struct
522 */
523void phy_detach(struct phy_device *phydev)
524{
525 phydev->attached_dev->phydev = NULL;
526 phydev->attached_dev = NULL;
527
528 /* If the device had no specific driver before (i.e. - it
529 * was using the generic driver), we unbind the device
530 * from the generic driver so that there's a chance a
531 * real driver could be loaded */
532 if (phydev->dev.driver == &genphy_driver.driver)
533 device_release_driver(&phydev->dev);
534}
535EXPORT_SYMBOL(phy_detach);
536
537
538/* Generic PHY support and helper functions */
539
540/**
541 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
542 * @phydev: target phy_device struct
543 *
544 * Description: Writes MII_ADVERTISE with the appropriate values,
545 * after sanitizing the values to make sure we only advertise
546 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
547 * hasn't changed, and > 0 if it has changed.
548 */
549static int genphy_config_advert(struct phy_device *phydev)
550{
551 u32 advertise;
552 int oldadv, adv;
553 int err, changed = 0;
554
555 /* Only allow advertising what
556 * this PHY supports */
557 phydev->advertising &= phydev->supported;
558 advertise = phydev->advertising;
559
560 /* Setup standard advertisement */
561 oldadv = adv = phy_read(phydev, MII_ADVERTISE);
562
563 if (adv < 0)
564 return adv;
565
566 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
567 ADVERTISE_PAUSE_ASYM);
568 if (advertise & ADVERTISED_10baseT_Half)
569 adv |= ADVERTISE_10HALF;
570 if (advertise & ADVERTISED_10baseT_Full)
571 adv |= ADVERTISE_10FULL;
572 if (advertise & ADVERTISED_100baseT_Half)
573 adv |= ADVERTISE_100HALF;
574 if (advertise & ADVERTISED_100baseT_Full)
575 adv |= ADVERTISE_100FULL;
576 if (advertise & ADVERTISED_Pause)
577 adv |= ADVERTISE_PAUSE_CAP;
578 if (advertise & ADVERTISED_Asym_Pause)
579 adv |= ADVERTISE_PAUSE_ASYM;
580
581 if (adv != oldadv) {
582 err = phy_write(phydev, MII_ADVERTISE, adv);
583
584 if (err < 0)
585 return err;
586 changed = 1;
587 }
588
589 /* Configure gigabit if it's supported */
590 if (phydev->supported & (SUPPORTED_1000baseT_Half |
591 SUPPORTED_1000baseT_Full)) {
592 oldadv = adv = phy_read(phydev, MII_CTRL1000);
593
594 if (adv < 0)
595 return adv;
596
597 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
598 if (advertise & SUPPORTED_1000baseT_Half)
599 adv |= ADVERTISE_1000HALF;
600 if (advertise & SUPPORTED_1000baseT_Full)
601 adv |= ADVERTISE_1000FULL;
602
603 if (adv != oldadv) {
604 err = phy_write(phydev, MII_CTRL1000, adv);
605
606 if (err < 0)
607 return err;
608 changed = 1;
609 }
610 }
611
612 return changed;
613}
614
615/**
616 * genphy_setup_forced - configures/forces speed/duplex from @phydev
617 * @phydev: target phy_device struct
618 *
619 * Description: Configures MII_BMCR to force speed/duplex
620 * to the values in phydev. Assumes that the values are valid.
621 * Please see phy_sanitize_settings().
622 */
623static int genphy_setup_forced(struct phy_device *phydev)
624{
625 int err;
626 int ctl = 0;
627
628 phydev->pause = phydev->asym_pause = 0;
629
630 if (SPEED_1000 == phydev->speed)
631 ctl |= BMCR_SPEED1000;
632 else if (SPEED_100 == phydev->speed)
633 ctl |= BMCR_SPEED100;
634
635 if (DUPLEX_FULL == phydev->duplex)
636 ctl |= BMCR_FULLDPLX;
637
638 err = phy_write(phydev, MII_BMCR, ctl);
639
640 return err;
641}
642
643
644/**
645 * genphy_restart_aneg - Enable and Restart Autonegotiation
646 * @phydev: target phy_device struct
647 */
648int genphy_restart_aneg(struct phy_device *phydev)
649{
650 int ctl;
651
652 ctl = phy_read(phydev, MII_BMCR);
653
654 if (ctl < 0)
655 return ctl;
656
657 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
658
659 /* Don't isolate the PHY if we're negotiating */
660 ctl &= ~(BMCR_ISOLATE);
661
662 ctl = phy_write(phydev, MII_BMCR, ctl);
663
664 return ctl;
665}
666EXPORT_SYMBOL(genphy_restart_aneg);
667
668
669/**
670 * genphy_config_aneg - restart auto-negotiation or write BMCR
671 * @phydev: target phy_device struct
672 *
673 * Description: If auto-negotiation is enabled, we configure the
674 * advertising, and then restart auto-negotiation. If it is not
675 * enabled, then we write the BMCR.
676 */
677int genphy_config_aneg(struct phy_device *phydev)
678{
679 int result;
680
681 if (AUTONEG_ENABLE != phydev->autoneg)
682 return genphy_setup_forced(phydev);
683
684 result = genphy_config_advert(phydev);
685
686 if (result < 0) /* error */
687 return result;
688
689 if (result == 0) {
690 /* Advertisement hasn't changed, but maybe aneg was never on to
691 * begin with? Or maybe phy was isolated? */
692 int ctl = phy_read(phydev, MII_BMCR);
693
694 if (ctl < 0)
695 return ctl;
696
697 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
698 result = 1; /* do restart aneg */
699 }
700
701 /* Only restart aneg if we are advertising something different
702 * than we were before. */
703 if (result > 0)
704 result = genphy_restart_aneg(phydev);
705
706 return result;
707}
708EXPORT_SYMBOL(genphy_config_aneg);
709
710/**
711 * genphy_update_link - update link status in @phydev
712 * @phydev: target phy_device struct
713 *
714 * Description: Update the value in phydev->link to reflect the
715 * current link value. In order to do this, we need to read
716 * the status register twice, keeping the second value.
717 */
718int genphy_update_link(struct phy_device *phydev)
719{
720 int status;
721
722 /* Do a fake read */
723 status = phy_read(phydev, MII_BMSR);
724
725 if (status < 0)
726 return status;
727
728 /* Read link and autonegotiation status */
729 status = phy_read(phydev, MII_BMSR);
730
731 if (status < 0)
732 return status;
733
734 if ((status & BMSR_LSTATUS) == 0)
735 phydev->link = 0;
736 else
737 phydev->link = 1;
738
739 return 0;
740}
741EXPORT_SYMBOL(genphy_update_link);
742
743/**
744 * genphy_read_status - check the link status and update current link state
745 * @phydev: target phy_device struct
746 *
747 * Description: Check the link, then figure out the current state
748 * by comparing what we advertise with what the link partner
749 * advertises. Start by checking the gigabit possibilities,
750 * then move on to 10/100.
751 */
752int genphy_read_status(struct phy_device *phydev)
753{
754 int adv;
755 int err;
756 int lpa;
757 int lpagb = 0;
758
759 /* Update the link, but return if there
760 * was an error */
761 err = genphy_update_link(phydev);
762 if (err)
763 return err;
764
765 if (AUTONEG_ENABLE == phydev->autoneg) {
766 if (phydev->supported & (SUPPORTED_1000baseT_Half
767 | SUPPORTED_1000baseT_Full)) {
768 lpagb = phy_read(phydev, MII_STAT1000);
769
770 if (lpagb < 0)
771 return lpagb;
772
773 adv = phy_read(phydev, MII_CTRL1000);
774
775 if (adv < 0)
776 return adv;
777
778 lpagb &= adv << 2;
779 }
780
781 lpa = phy_read(phydev, MII_LPA);
782
783 if (lpa < 0)
784 return lpa;
785
786 adv = phy_read(phydev, MII_ADVERTISE);
787
788 if (adv < 0)
789 return adv;
790
791 lpa &= adv;
792
793 phydev->speed = SPEED_10;
794 phydev->duplex = DUPLEX_HALF;
795 phydev->pause = phydev->asym_pause = 0;
796
797 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
798 phydev->speed = SPEED_1000;
799
800 if (lpagb & LPA_1000FULL)
801 phydev->duplex = DUPLEX_FULL;
802 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
803 phydev->speed = SPEED_100;
804
805 if (lpa & LPA_100FULL)
806 phydev->duplex = DUPLEX_FULL;
807 } else
808 if (lpa & LPA_10FULL)
809 phydev->duplex = DUPLEX_FULL;
810
811 if (phydev->duplex == DUPLEX_FULL){
812 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
813 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
814 }
815 } else {
816 int bmcr = phy_read(phydev, MII_BMCR);
817 if (bmcr < 0)
818 return bmcr;
819
820 if (bmcr & BMCR_FULLDPLX)
821 phydev->duplex = DUPLEX_FULL;
822 else
823 phydev->duplex = DUPLEX_HALF;
824
825 if (bmcr & BMCR_SPEED1000)
826 phydev->speed = SPEED_1000;
827 else if (bmcr & BMCR_SPEED100)
828 phydev->speed = SPEED_100;
829 else
830 phydev->speed = SPEED_10;
831
832 phydev->pause = phydev->asym_pause = 0;
833 }
834
835 return 0;
836}
837EXPORT_SYMBOL(genphy_read_status);
838
839static int genphy_config_init(struct phy_device *phydev)
840{
841 int val;
842 u32 features;
843
844 /* For now, I'll claim that the generic driver supports
845 * all possible port types */
846 features = (SUPPORTED_TP | SUPPORTED_MII
847 | SUPPORTED_AUI | SUPPORTED_FIBRE |
848 SUPPORTED_BNC);
849
850 /* Do we support autonegotiation? */
851 val = phy_read(phydev, MII_BMSR);
852
853 if (val < 0)
854 return val;
855
856 if (val & BMSR_ANEGCAPABLE)
857 features |= SUPPORTED_Autoneg;
858
859 if (val & BMSR_100FULL)
860 features |= SUPPORTED_100baseT_Full;
861 if (val & BMSR_100HALF)
862 features |= SUPPORTED_100baseT_Half;
863 if (val & BMSR_10FULL)
864 features |= SUPPORTED_10baseT_Full;
865 if (val & BMSR_10HALF)
866 features |= SUPPORTED_10baseT_Half;
867
868 if (val & BMSR_ESTATEN) {
869 val = phy_read(phydev, MII_ESTATUS);
870
871 if (val < 0)
872 return val;
873
874 if (val & ESTATUS_1000_TFULL)
875 features |= SUPPORTED_1000baseT_Full;
876 if (val & ESTATUS_1000_THALF)
877 features |= SUPPORTED_1000baseT_Half;
878 }
879
880 phydev->supported = features;
881 phydev->advertising = features;
882
883 return 0;
884}
885int genphy_suspend(struct phy_device *phydev)
886{
887 int value;
888
889 mutex_lock(&phydev->lock);
890
891 value = phy_read(phydev, MII_BMCR);
892 phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));
893
894 mutex_unlock(&phydev->lock);
895
896 return 0;
897}
898EXPORT_SYMBOL(genphy_suspend);
899
900int genphy_resume(struct phy_device *phydev)
901{
902 int value;
903
904 mutex_lock(&phydev->lock);
905
906 value = phy_read(phydev, MII_BMCR);
907 phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));
908
909 mutex_unlock(&phydev->lock);
910
911 return 0;
912}
913EXPORT_SYMBOL(genphy_resume);
914
915/**
916 * phy_probe - probe and init a PHY device
917 * @dev: device to probe and init
918 *
919 * Description: Take care of setting up the phy_device structure,
920 * set the state to READY (the driver's init function should
921 * set it to STARTING if needed).
922 */
923static int phy_probe(struct device *dev)
924{
925 struct phy_device *phydev;
926 struct phy_driver *phydrv;
927 struct device_driver *drv;
928 int err = 0;
929
930 phydev = to_phy_device(dev);
931
932 /* Make sure the driver is held.
933 * XXX -- Is this correct? */
934 drv = get_driver(phydev->dev.driver);
935 phydrv = to_phy_driver(drv);
936 phydev->drv = phydrv;
937
938 /* Disable the interrupt if the PHY doesn't support it */
939 if (!(phydrv->flags & PHY_HAS_INTERRUPT))
940 phydev->irq = PHY_POLL;
941
942 mutex_lock(&phydev->lock);
943
944 /* Start out supporting everything. Eventually,
945 * a controller will attach, and may modify one
946 * or both of these values */
947 phydev->supported = phydrv->features;
948 phydev->advertising = phydrv->features;
949
950 /* Set the state to READY by default */
951 phydev->state = PHY_READY;
952
953 if (phydev->drv->probe)
954 err = phydev->drv->probe(phydev);
955
956 mutex_unlock(&phydev->lock);
957
958 return err;
959
960}
961
962static int phy_remove(struct device *dev)
963{
964 struct phy_device *phydev;
965
966 phydev = to_phy_device(dev);
967
968 mutex_lock(&phydev->lock);
969 phydev->state = PHY_DOWN;
970 mutex_unlock(&phydev->lock);
971
972 if (phydev->drv->remove)
973 phydev->drv->remove(phydev);
974
975 put_driver(dev->driver);
976 phydev->drv = NULL;
977
978 return 0;
979}
980
981/**
982 * phy_driver_register - register a phy_driver with the PHY layer
983 * @new_driver: new phy_driver to register
984 */
985int phy_driver_register(struct phy_driver *new_driver)
986{
987 int retval;
988
989 new_driver->driver.name = new_driver->name;
990 new_driver->driver.bus = &mdio_bus_type;
991 new_driver->driver.probe = phy_probe;
992 new_driver->driver.remove = phy_remove;
993
994 retval = driver_register(&new_driver->driver);
995
996 if (retval) {
997 printk(KERN_ERR "%s: Error %d in registering driver\n",
998 new_driver->name, retval);
999
1000 return retval;
1001 }
1002
1003 pr_debug("%s: Registered new driver\n", new_driver->name);
1004
1005 return 0;
1006}
1007EXPORT_SYMBOL(phy_driver_register);
1008
1009void phy_driver_unregister(struct phy_driver *drv)
1010{
1011 driver_unregister(&drv->driver);
1012}
1013EXPORT_SYMBOL(phy_driver_unregister);
1014
1015static struct phy_driver genphy_driver = {
1016 .phy_id = 0xffffffff,
1017 .phy_id_mask = 0xffffffff,
1018 .name = "Generic PHY",
1019 .config_init = genphy_config_init,
1020 .features = 0,
1021 .config_aneg = genphy_config_aneg,
1022 .read_status = genphy_read_status,
1023 .suspend = genphy_suspend,
1024 .resume = genphy_resume,
1025 .driver = {.owner= THIS_MODULE, },
1026};
1027
1028static int __init phy_init(void)
1029{
1030 int rc;
1031
1032 rc = mdio_bus_init();
1033 if (rc)
1034 return rc;
1035
1036 rc = phy_driver_register(&genphy_driver);
1037 if (rc)
1038 mdio_bus_exit();
1039
1040 return rc;
1041}
1042
1043static void __exit phy_exit(void)
1044{
1045 phy_driver_unregister(&genphy_driver);
1046 mdio_bus_exit();
1047}
1048
1049subsys_initcall(phy_init);
1050module_exit(phy_exit);
1// SPDX-License-Identifier: GPL-2.0+
2/* Framework for finding and configuring PHYs.
3 * Also contains generic PHY driver
4 *
5 * Author: Andy Fleming
6 *
7 * Copyright (c) 2004 Freescale Semiconductor, Inc.
8 */
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12#include <linux/acpi.h>
13#include <linux/bitmap.h>
14#include <linux/delay.h>
15#include <linux/errno.h>
16#include <linux/etherdevice.h>
17#include <linux/ethtool.h>
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/io.h>
21#include <linux/kernel.h>
22#include <linux/list.h>
23#include <linux/mdio.h>
24#include <linux/mii.h>
25#include <linux/mm.h>
26#include <linux/module.h>
27#include <linux/of.h>
28#include <linux/netdevice.h>
29#include <linux/phy.h>
30#include <linux/phylib_stubs.h>
31#include <linux/phy_led_triggers.h>
32#include <linux/pse-pd/pse.h>
33#include <linux/property.h>
34#include <linux/rtnetlink.h>
35#include <linux/sfp.h>
36#include <linux/skbuff.h>
37#include <linux/slab.h>
38#include <linux/string.h>
39#include <linux/uaccess.h>
40#include <linux/unistd.h>
41
42MODULE_DESCRIPTION("PHY library");
43MODULE_AUTHOR("Andy Fleming");
44MODULE_LICENSE("GPL");
45
46__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
47EXPORT_SYMBOL_GPL(phy_basic_features);
48
49__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
50EXPORT_SYMBOL_GPL(phy_basic_t1_features);
51
52__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1s_p2mp_features) __ro_after_init;
53EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features);
54
55__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
56EXPORT_SYMBOL_GPL(phy_gbit_features);
57
58__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
59EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
60
61__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
62EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
63
64__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
65EXPORT_SYMBOL_GPL(phy_10gbit_features);
66
67__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
68EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
69
70const int phy_basic_ports_array[3] = {
71 ETHTOOL_LINK_MODE_Autoneg_BIT,
72 ETHTOOL_LINK_MODE_TP_BIT,
73 ETHTOOL_LINK_MODE_MII_BIT,
74};
75EXPORT_SYMBOL_GPL(phy_basic_ports_array);
76
77const int phy_fibre_port_array[1] = {
78 ETHTOOL_LINK_MODE_FIBRE_BIT,
79};
80EXPORT_SYMBOL_GPL(phy_fibre_port_array);
81
82const int phy_all_ports_features_array[7] = {
83 ETHTOOL_LINK_MODE_Autoneg_BIT,
84 ETHTOOL_LINK_MODE_TP_BIT,
85 ETHTOOL_LINK_MODE_MII_BIT,
86 ETHTOOL_LINK_MODE_FIBRE_BIT,
87 ETHTOOL_LINK_MODE_AUI_BIT,
88 ETHTOOL_LINK_MODE_BNC_BIT,
89 ETHTOOL_LINK_MODE_Backplane_BIT,
90};
91EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
92
93const int phy_10_100_features_array[4] = {
94 ETHTOOL_LINK_MODE_10baseT_Half_BIT,
95 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
96 ETHTOOL_LINK_MODE_100baseT_Half_BIT,
97 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
98};
99EXPORT_SYMBOL_GPL(phy_10_100_features_array);
100
101const int phy_basic_t1_features_array[3] = {
102 ETHTOOL_LINK_MODE_TP_BIT,
103 ETHTOOL_LINK_MODE_10baseT1L_Full_BIT,
104 ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
105};
106EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
107
108const int phy_basic_t1s_p2mp_features_array[2] = {
109 ETHTOOL_LINK_MODE_TP_BIT,
110 ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT,
111};
112EXPORT_SYMBOL_GPL(phy_basic_t1s_p2mp_features_array);
113
114const int phy_gbit_features_array[2] = {
115 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
116 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
117};
118EXPORT_SYMBOL_GPL(phy_gbit_features_array);
119
120const int phy_10gbit_features_array[1] = {
121 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
122};
123EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
124
125static const int phy_10gbit_fec_features_array[1] = {
126 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
127};
128
129__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
130EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
131
132static const int phy_10gbit_full_features_array[] = {
133 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
134 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
135 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
136 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
137};
138
139static const int phy_eee_cap1_features_array[] = {
140 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
141 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
142 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
143 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
144 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT,
145 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
146};
147
148__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap1_features) __ro_after_init;
149EXPORT_SYMBOL_GPL(phy_eee_cap1_features);
150
151static const int phy_eee_cap2_features_array[] = {
152 ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
153 ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
154};
155
156__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_eee_cap2_features) __ro_after_init;
157EXPORT_SYMBOL_GPL(phy_eee_cap2_features);
158
159static void features_init(void)
160{
161 /* 10/100 half/full*/
162 linkmode_set_bit_array(phy_basic_ports_array,
163 ARRAY_SIZE(phy_basic_ports_array),
164 phy_basic_features);
165 linkmode_set_bit_array(phy_10_100_features_array,
166 ARRAY_SIZE(phy_10_100_features_array),
167 phy_basic_features);
168
169 /* 100 full, TP */
170 linkmode_set_bit_array(phy_basic_t1_features_array,
171 ARRAY_SIZE(phy_basic_t1_features_array),
172 phy_basic_t1_features);
173
174 /* 10 half, P2MP, TP */
175 linkmode_set_bit_array(phy_basic_t1s_p2mp_features_array,
176 ARRAY_SIZE(phy_basic_t1s_p2mp_features_array),
177 phy_basic_t1s_p2mp_features);
178
179 /* 10/100 half/full + 1000 half/full */
180 linkmode_set_bit_array(phy_basic_ports_array,
181 ARRAY_SIZE(phy_basic_ports_array),
182 phy_gbit_features);
183 linkmode_set_bit_array(phy_10_100_features_array,
184 ARRAY_SIZE(phy_10_100_features_array),
185 phy_gbit_features);
186 linkmode_set_bit_array(phy_gbit_features_array,
187 ARRAY_SIZE(phy_gbit_features_array),
188 phy_gbit_features);
189
190 /* 10/100 half/full + 1000 half/full + fibre*/
191 linkmode_set_bit_array(phy_basic_ports_array,
192 ARRAY_SIZE(phy_basic_ports_array),
193 phy_gbit_fibre_features);
194 linkmode_set_bit_array(phy_10_100_features_array,
195 ARRAY_SIZE(phy_10_100_features_array),
196 phy_gbit_fibre_features);
197 linkmode_set_bit_array(phy_gbit_features_array,
198 ARRAY_SIZE(phy_gbit_features_array),
199 phy_gbit_fibre_features);
200 linkmode_set_bit_array(phy_fibre_port_array,
201 ARRAY_SIZE(phy_fibre_port_array),
202 phy_gbit_fibre_features);
203
204 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
205 linkmode_set_bit_array(phy_all_ports_features_array,
206 ARRAY_SIZE(phy_all_ports_features_array),
207 phy_gbit_all_ports_features);
208 linkmode_set_bit_array(phy_10_100_features_array,
209 ARRAY_SIZE(phy_10_100_features_array),
210 phy_gbit_all_ports_features);
211 linkmode_set_bit_array(phy_gbit_features_array,
212 ARRAY_SIZE(phy_gbit_features_array),
213 phy_gbit_all_ports_features);
214
215 /* 10/100 half/full + 1000 half/full + 10G full*/
216 linkmode_set_bit_array(phy_all_ports_features_array,
217 ARRAY_SIZE(phy_all_ports_features_array),
218 phy_10gbit_features);
219 linkmode_set_bit_array(phy_10_100_features_array,
220 ARRAY_SIZE(phy_10_100_features_array),
221 phy_10gbit_features);
222 linkmode_set_bit_array(phy_gbit_features_array,
223 ARRAY_SIZE(phy_gbit_features_array),
224 phy_10gbit_features);
225 linkmode_set_bit_array(phy_10gbit_features_array,
226 ARRAY_SIZE(phy_10gbit_features_array),
227 phy_10gbit_features);
228
229 /* 10/100/1000/10G full */
230 linkmode_set_bit_array(phy_all_ports_features_array,
231 ARRAY_SIZE(phy_all_ports_features_array),
232 phy_10gbit_full_features);
233 linkmode_set_bit_array(phy_10gbit_full_features_array,
234 ARRAY_SIZE(phy_10gbit_full_features_array),
235 phy_10gbit_full_features);
236 /* 10G FEC only */
237 linkmode_set_bit_array(phy_10gbit_fec_features_array,
238 ARRAY_SIZE(phy_10gbit_fec_features_array),
239 phy_10gbit_fec_features);
240 linkmode_set_bit_array(phy_eee_cap1_features_array,
241 ARRAY_SIZE(phy_eee_cap1_features_array),
242 phy_eee_cap1_features);
243 linkmode_set_bit_array(phy_eee_cap2_features_array,
244 ARRAY_SIZE(phy_eee_cap2_features_array),
245 phy_eee_cap2_features);
246
247}
248
249void phy_device_free(struct phy_device *phydev)
250{
251 put_device(&phydev->mdio.dev);
252}
253EXPORT_SYMBOL(phy_device_free);
254
255static void phy_mdio_device_free(struct mdio_device *mdiodev)
256{
257 struct phy_device *phydev;
258
259 phydev = container_of(mdiodev, struct phy_device, mdio);
260 phy_device_free(phydev);
261}
262
263static void phy_device_release(struct device *dev)
264{
265 fwnode_handle_put(dev->fwnode);
266 kfree(to_phy_device(dev));
267}
268
269static void phy_mdio_device_remove(struct mdio_device *mdiodev)
270{
271 struct phy_device *phydev;
272
273 phydev = container_of(mdiodev, struct phy_device, mdio);
274 phy_device_remove(phydev);
275}
276
277static struct phy_driver genphy_driver;
278
279static LIST_HEAD(phy_fixup_list);
280static DEFINE_MUTEX(phy_fixup_lock);
281
282static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
283{
284 struct device_driver *drv = phydev->mdio.dev.driver;
285 struct phy_driver *phydrv = to_phy_driver(drv);
286 struct net_device *netdev = phydev->attached_dev;
287
288 if (!drv || !phydrv->suspend)
289 return false;
290
291 /* PHY not attached? May suspend if the PHY has not already been
292 * suspended as part of a prior call to phy_disconnect() ->
293 * phy_detach() -> phy_suspend() because the parent netdev might be the
294 * MDIO bus driver and clock gated at this point.
295 */
296 if (!netdev)
297 goto out;
298
299 if (netdev->wol_enabled)
300 return false;
301
302 /* As long as not all affected network drivers support the
303 * wol_enabled flag, let's check for hints that WoL is enabled.
304 * Don't suspend PHY if the attached netdev parent may wake up.
305 * The parent may point to a PCI device, as in tg3 driver.
306 */
307 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
308 return false;
309
310 /* Also don't suspend PHY if the netdev itself may wakeup. This
311 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
312 * e.g. SoC devices.
313 */
314 if (device_may_wakeup(&netdev->dev))
315 return false;
316
317out:
318 return !phydev->suspended;
319}
320
321static __maybe_unused int mdio_bus_phy_suspend(struct device *dev)
322{
323 struct phy_device *phydev = to_phy_device(dev);
324
325 if (phydev->mac_managed_pm)
326 return 0;
327
328 /* Wakeup interrupts may occur during the system sleep transition when
329 * the PHY is inaccessible. Set flag to postpone handling until the PHY
330 * has resumed. Wait for concurrent interrupt handler to complete.
331 */
332 if (phy_interrupt_is_valid(phydev)) {
333 phydev->irq_suspended = 1;
334 synchronize_irq(phydev->irq);
335 }
336
337 /* We must stop the state machine manually, otherwise it stops out of
338 * control, possibly with the phydev->lock held. Upon resume, netdev
339 * may call phy routines that try to grab the same lock, and that may
340 * lead to a deadlock.
341 */
342 if (phydev->attached_dev && phydev->adjust_link)
343 phy_stop_machine(phydev);
344
345 if (!mdio_bus_phy_may_suspend(phydev))
346 return 0;
347
348 phydev->suspended_by_mdio_bus = 1;
349
350 return phy_suspend(phydev);
351}
352
353static __maybe_unused int mdio_bus_phy_resume(struct device *dev)
354{
355 struct phy_device *phydev = to_phy_device(dev);
356 int ret;
357
358 if (phydev->mac_managed_pm)
359 return 0;
360
361 if (!phydev->suspended_by_mdio_bus)
362 goto no_resume;
363
364 phydev->suspended_by_mdio_bus = 0;
365
366 /* If we managed to get here with the PHY state machine in a state
367 * neither PHY_HALTED, PHY_READY nor PHY_UP, this is an indication
368 * that something went wrong and we should most likely be using
369 * MAC managed PM, but we are not.
370 */
371 WARN_ON(phydev->state != PHY_HALTED && phydev->state != PHY_READY &&
372 phydev->state != PHY_UP);
373
374 ret = phy_init_hw(phydev);
375 if (ret < 0)
376 return ret;
377
378 ret = phy_resume(phydev);
379 if (ret < 0)
380 return ret;
381no_resume:
382 if (phy_interrupt_is_valid(phydev)) {
383 phydev->irq_suspended = 0;
384 synchronize_irq(phydev->irq);
385
386 /* Rerun interrupts which were postponed by phy_interrupt()
387 * because they occurred during the system sleep transition.
388 */
389 if (phydev->irq_rerun) {
390 phydev->irq_rerun = 0;
391 enable_irq(phydev->irq);
392 irq_wake_thread(phydev->irq, phydev);
393 }
394 }
395
396 if (phydev->attached_dev && phydev->adjust_link)
397 phy_start_machine(phydev);
398
399 return 0;
400}
401
402static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend,
403 mdio_bus_phy_resume);
404
405/**
406 * phy_register_fixup - creates a new phy_fixup and adds it to the list
407 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
408 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
409 * It can also be PHY_ANY_UID
410 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
411 * comparison
412 * @run: The actual code to be run when a matching PHY is found
413 */
414int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
415 int (*run)(struct phy_device *))
416{
417 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
418
419 if (!fixup)
420 return -ENOMEM;
421
422 strscpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
423 fixup->phy_uid = phy_uid;
424 fixup->phy_uid_mask = phy_uid_mask;
425 fixup->run = run;
426
427 mutex_lock(&phy_fixup_lock);
428 list_add_tail(&fixup->list, &phy_fixup_list);
429 mutex_unlock(&phy_fixup_lock);
430
431 return 0;
432}
433EXPORT_SYMBOL(phy_register_fixup);
434
435/* Registers a fixup to be run on any PHY with the UID in phy_uid */
436int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
437 int (*run)(struct phy_device *))
438{
439 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
440}
441EXPORT_SYMBOL(phy_register_fixup_for_uid);
442
443/* Registers a fixup to be run on the PHY with id string bus_id */
444int phy_register_fixup_for_id(const char *bus_id,
445 int (*run)(struct phy_device *))
446{
447 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
448}
449EXPORT_SYMBOL(phy_register_fixup_for_id);
450
451/**
452 * phy_unregister_fixup - remove a phy_fixup from the list
453 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
454 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
455 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
456 */
457int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
458{
459 struct list_head *pos, *n;
460 struct phy_fixup *fixup;
461 int ret;
462
463 ret = -ENODEV;
464
465 mutex_lock(&phy_fixup_lock);
466 list_for_each_safe(pos, n, &phy_fixup_list) {
467 fixup = list_entry(pos, struct phy_fixup, list);
468
469 if ((!strcmp(fixup->bus_id, bus_id)) &&
470 phy_id_compare(fixup->phy_uid, phy_uid, phy_uid_mask)) {
471 list_del(&fixup->list);
472 kfree(fixup);
473 ret = 0;
474 break;
475 }
476 }
477 mutex_unlock(&phy_fixup_lock);
478
479 return ret;
480}
481EXPORT_SYMBOL(phy_unregister_fixup);
482
483/* Unregisters a fixup of any PHY with the UID in phy_uid */
484int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
485{
486 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
487}
488EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
489
490/* Unregisters a fixup of the PHY with id string bus_id */
491int phy_unregister_fixup_for_id(const char *bus_id)
492{
493 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
494}
495EXPORT_SYMBOL(phy_unregister_fixup_for_id);
496
497/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
498 * Fixups can be set to match any in one or more fields.
499 */
500static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
501{
502 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
503 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
504 return 0;
505
506 if (!phy_id_compare(phydev->phy_id, fixup->phy_uid,
507 fixup->phy_uid_mask))
508 if (fixup->phy_uid != PHY_ANY_UID)
509 return 0;
510
511 return 1;
512}
513
514/* Runs any matching fixups for this phydev */
515static int phy_scan_fixups(struct phy_device *phydev)
516{
517 struct phy_fixup *fixup;
518
519 mutex_lock(&phy_fixup_lock);
520 list_for_each_entry(fixup, &phy_fixup_list, list) {
521 if (phy_needs_fixup(phydev, fixup)) {
522 int err = fixup->run(phydev);
523
524 if (err < 0) {
525 mutex_unlock(&phy_fixup_lock);
526 return err;
527 }
528 phydev->has_fixups = true;
529 }
530 }
531 mutex_unlock(&phy_fixup_lock);
532
533 return 0;
534}
535
536static int phy_bus_match(struct device *dev, struct device_driver *drv)
537{
538 struct phy_device *phydev = to_phy_device(dev);
539 struct phy_driver *phydrv = to_phy_driver(drv);
540 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
541 int i;
542
543 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
544 return 0;
545
546 if (phydrv->match_phy_device)
547 return phydrv->match_phy_device(phydev);
548
549 if (phydev->is_c45) {
550 for (i = 1; i < num_ids; i++) {
551 if (phydev->c45_ids.device_ids[i] == 0xffffffff)
552 continue;
553
554 if (phy_id_compare(phydev->c45_ids.device_ids[i],
555 phydrv->phy_id, phydrv->phy_id_mask))
556 return 1;
557 }
558 return 0;
559 } else {
560 return phy_id_compare(phydev->phy_id, phydrv->phy_id,
561 phydrv->phy_id_mask);
562 }
563}
564
565static ssize_t
566phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
567{
568 struct phy_device *phydev = to_phy_device(dev);
569
570 return sysfs_emit(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
571}
572static DEVICE_ATTR_RO(phy_id);
573
574static ssize_t
575phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
576{
577 struct phy_device *phydev = to_phy_device(dev);
578 const char *mode = NULL;
579
580 if (phy_is_internal(phydev))
581 mode = "internal";
582 else
583 mode = phy_modes(phydev->interface);
584
585 return sysfs_emit(buf, "%s\n", mode);
586}
587static DEVICE_ATTR_RO(phy_interface);
588
589static ssize_t
590phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
591 char *buf)
592{
593 struct phy_device *phydev = to_phy_device(dev);
594
595 return sysfs_emit(buf, "%d\n", phydev->has_fixups);
596}
597static DEVICE_ATTR_RO(phy_has_fixups);
598
599static ssize_t phy_dev_flags_show(struct device *dev,
600 struct device_attribute *attr,
601 char *buf)
602{
603 struct phy_device *phydev = to_phy_device(dev);
604
605 return sysfs_emit(buf, "0x%08x\n", phydev->dev_flags);
606}
607static DEVICE_ATTR_RO(phy_dev_flags);
608
609static struct attribute *phy_dev_attrs[] = {
610 &dev_attr_phy_id.attr,
611 &dev_attr_phy_interface.attr,
612 &dev_attr_phy_has_fixups.attr,
613 &dev_attr_phy_dev_flags.attr,
614 NULL,
615};
616ATTRIBUTE_GROUPS(phy_dev);
617
618static const struct device_type mdio_bus_phy_type = {
619 .name = "PHY",
620 .groups = phy_dev_groups,
621 .release = phy_device_release,
622 .pm = pm_ptr(&mdio_bus_phy_pm_ops),
623};
624
625static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
626{
627 int ret;
628
629 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
630 MDIO_ID_ARGS(phy_id));
631 /* We only check for failures in executing the usermode binary,
632 * not whether a PHY driver module exists for the PHY ID.
633 * Accept -ENOENT because this may occur in case no initramfs exists,
634 * then modprobe isn't available.
635 */
636 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
637 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08lx\n",
638 ret, (unsigned long)phy_id);
639 return ret;
640 }
641
642 return 0;
643}
644
645struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
646 bool is_c45,
647 struct phy_c45_device_ids *c45_ids)
648{
649 struct phy_device *dev;
650 struct mdio_device *mdiodev;
651 int ret = 0;
652
653 /* We allocate the device, and initialize the default values */
654 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
655 if (!dev)
656 return ERR_PTR(-ENOMEM);
657
658 mdiodev = &dev->mdio;
659 mdiodev->dev.parent = &bus->dev;
660 mdiodev->dev.bus = &mdio_bus_type;
661 mdiodev->dev.type = &mdio_bus_phy_type;
662 mdiodev->bus = bus;
663 mdiodev->bus_match = phy_bus_match;
664 mdiodev->addr = addr;
665 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
666 mdiodev->device_free = phy_mdio_device_free;
667 mdiodev->device_remove = phy_mdio_device_remove;
668 mdiodev->reset_state = -1;
669
670 dev->speed = SPEED_UNKNOWN;
671 dev->duplex = DUPLEX_UNKNOWN;
672 dev->pause = 0;
673 dev->asym_pause = 0;
674 dev->link = 0;
675 dev->port = PORT_TP;
676 dev->interface = PHY_INTERFACE_MODE_GMII;
677
678 dev->autoneg = AUTONEG_ENABLE;
679
680 dev->pma_extable = -ENODATA;
681 dev->is_c45 = is_c45;
682 dev->phy_id = phy_id;
683 if (c45_ids)
684 dev->c45_ids = *c45_ids;
685 dev->irq = bus->irq[addr];
686
687 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
688 device_initialize(&mdiodev->dev);
689
690 dev->state = PHY_DOWN;
691 INIT_LIST_HEAD(&dev->leds);
692
693 mutex_init(&dev->lock);
694 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
695
696 /* Request the appropriate module unconditionally; don't
697 * bother trying to do so only if it isn't already loaded,
698 * because that gets complicated. A hotplug event would have
699 * done an unconditional modprobe anyway.
700 * We don't do normal hotplug because it won't work for MDIO
701 * -- because it relies on the device staying around for long
702 * enough for the driver to get loaded. With MDIO, the NIC
703 * driver will get bored and give up as soon as it finds that
704 * there's no driver _already_ loaded.
705 */
706 if (is_c45 && c45_ids) {
707 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
708 int i;
709
710 for (i = 1; i < num_ids; i++) {
711 if (c45_ids->device_ids[i] == 0xffffffff)
712 continue;
713
714 ret = phy_request_driver_module(dev,
715 c45_ids->device_ids[i]);
716 if (ret)
717 break;
718 }
719 } else {
720 ret = phy_request_driver_module(dev, phy_id);
721 }
722
723 if (ret) {
724 put_device(&mdiodev->dev);
725 dev = ERR_PTR(ret);
726 }
727
728 return dev;
729}
730EXPORT_SYMBOL(phy_device_create);
731
732/* phy_c45_probe_present - checks to see if a MMD is present in the package
733 * @bus: the target MII bus
734 * @prtad: PHY package address on the MII bus
735 * @devad: PHY device (MMD) address
736 *
737 * Read the MDIO_STAT2 register, and check whether a device is responding
738 * at this address.
739 *
740 * Returns: negative error number on bus access error, zero if no device
741 * is responding, or positive if a device is present.
742 */
743static int phy_c45_probe_present(struct mii_bus *bus, int prtad, int devad)
744{
745 int stat2;
746
747 stat2 = mdiobus_c45_read(bus, prtad, devad, MDIO_STAT2);
748 if (stat2 < 0)
749 return stat2;
750
751 return (stat2 & MDIO_STAT2_DEVPRST) == MDIO_STAT2_DEVPRST_VAL;
752}
753
754/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
755 * @bus: the target MII bus
756 * @addr: PHY address on the MII bus
757 * @dev_addr: MMD address in the PHY.
758 * @devices_in_package: where to store the devices in package information.
759 *
760 * Description: reads devices in package registers of a MMD at @dev_addr
761 * from PHY at @addr on @bus.
762 *
763 * Returns: 0 on success, -EIO on failure.
764 */
765static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
766 u32 *devices_in_package)
767{
768 int phy_reg;
769
770 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS2);
771 if (phy_reg < 0)
772 return -EIO;
773 *devices_in_package = phy_reg << 16;
774
775 phy_reg = mdiobus_c45_read(bus, addr, dev_addr, MDIO_DEVS1);
776 if (phy_reg < 0)
777 return -EIO;
778 *devices_in_package |= phy_reg;
779
780 return 0;
781}
782
783/**
784 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
785 * @bus: the target MII bus
786 * @addr: PHY address on the MII bus
787 * @c45_ids: where to store the c45 ID information.
788 *
789 * Read the PHY "devices in package". If this appears to be valid, read
790 * the PHY identifiers for each device. Return the "devices in package"
791 * and identifiers in @c45_ids.
792 *
793 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if
794 * the "devices in package" is invalid or no device responds.
795 */
796static int get_phy_c45_ids(struct mii_bus *bus, int addr,
797 struct phy_c45_device_ids *c45_ids)
798{
799 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
800 u32 devs_in_pkg = 0;
801 int i, ret, phy_reg;
802
803 /* Find first non-zero Devices In package. Device zero is reserved
804 * for 802.3 c45 complied PHYs, so don't probe it at first.
805 */
806 for (i = 1; i < MDIO_MMD_NUM && (devs_in_pkg == 0 ||
807 (devs_in_pkg & 0x1fffffff) == 0x1fffffff); i++) {
808 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
809 /* Check that there is a device present at this
810 * address before reading the devices-in-package
811 * register to avoid reading garbage from the PHY.
812 * Some PHYs (88x3310) vendor space is not IEEE802.3
813 * compliant.
814 */
815 ret = phy_c45_probe_present(bus, addr, i);
816 if (ret < 0)
817 /* returning -ENODEV doesn't stop bus
818 * scanning
819 */
820 return (phy_reg == -EIO ||
821 phy_reg == -ENODEV) ? -ENODEV : -EIO;
822
823 if (!ret)
824 continue;
825 }
826 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, &devs_in_pkg);
827 if (phy_reg < 0)
828 return -EIO;
829 }
830
831 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff) {
832 /* If mostly Fs, there is no device there, then let's probe
833 * MMD 0, as some 10G PHYs have zero Devices In package,
834 * e.g. Cortina CS4315/CS4340 PHY.
835 */
836 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, &devs_in_pkg);
837 if (phy_reg < 0)
838 return -EIO;
839
840 /* no device there, let's get out of here */
841 if ((devs_in_pkg & 0x1fffffff) == 0x1fffffff)
842 return -ENODEV;
843 }
844
845 /* Now probe Device Identifiers for each device present. */
846 for (i = 1; i < num_ids; i++) {
847 if (!(devs_in_pkg & (1 << i)))
848 continue;
849
850 if (i == MDIO_MMD_VEND1 || i == MDIO_MMD_VEND2) {
851 /* Probe the "Device Present" bits for the vendor MMDs
852 * to ignore these if they do not contain IEEE 802.3
853 * registers.
854 */
855 ret = phy_c45_probe_present(bus, addr, i);
856 if (ret < 0)
857 return ret;
858
859 if (!ret)
860 continue;
861 }
862
863 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID1);
864 if (phy_reg < 0)
865 return -EIO;
866 c45_ids->device_ids[i] = phy_reg << 16;
867
868 phy_reg = mdiobus_c45_read(bus, addr, i, MII_PHYSID2);
869 if (phy_reg < 0)
870 return -EIO;
871 c45_ids->device_ids[i] |= phy_reg;
872 }
873
874 c45_ids->devices_in_package = devs_in_pkg;
875 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */
876 c45_ids->mmds_present = devs_in_pkg & ~BIT(0);
877
878 return 0;
879}
880
881/**
882 * get_phy_c22_id - reads the specified addr for its clause 22 ID.
883 * @bus: the target MII bus
884 * @addr: PHY address on the MII bus
885 * @phy_id: where to store the ID retrieved.
886 *
887 * Read the 802.3 clause 22 PHY ID from the PHY at @addr on the @bus,
888 * placing it in @phy_id. Return zero on successful read and the ID is
889 * valid, %-EIO on bus access error, or %-ENODEV if no device responds
890 * or invalid ID.
891 */
892static int get_phy_c22_id(struct mii_bus *bus, int addr, u32 *phy_id)
893{
894 int phy_reg;
895
896 /* Grab the bits from PHYIR1, and put them in the upper half */
897 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
898 if (phy_reg < 0) {
899 /* returning -ENODEV doesn't stop bus scanning */
900 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
901 }
902
903 *phy_id = phy_reg << 16;
904
905 /* Grab the bits from PHYIR2, and put them in the lower half */
906 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
907 if (phy_reg < 0) {
908 /* returning -ENODEV doesn't stop bus scanning */
909 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
910 }
911
912 *phy_id |= phy_reg;
913
914 /* If the phy_id is mostly Fs, there is no device there */
915 if ((*phy_id & 0x1fffffff) == 0x1fffffff)
916 return -ENODEV;
917
918 return 0;
919}
920
921/* Extract the phy ID from the compatible string of the form
922 * ethernet-phy-idAAAA.BBBB.
923 */
924int fwnode_get_phy_id(struct fwnode_handle *fwnode, u32 *phy_id)
925{
926 unsigned int upper, lower;
927 const char *cp;
928 int ret;
929
930 ret = fwnode_property_read_string(fwnode, "compatible", &cp);
931 if (ret)
932 return ret;
933
934 if (sscanf(cp, "ethernet-phy-id%4x.%4x", &upper, &lower) != 2)
935 return -EINVAL;
936
937 *phy_id = ((upper & GENMASK(15, 0)) << 16) | (lower & GENMASK(15, 0));
938 return 0;
939}
940EXPORT_SYMBOL(fwnode_get_phy_id);
941
942/**
943 * get_phy_device - reads the specified PHY device and returns its @phy_device
944 * struct
945 * @bus: the target MII bus
946 * @addr: PHY address on the MII bus
947 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
948 *
949 * Probe for a PHY at @addr on @bus.
950 *
951 * When probing for a clause 22 PHY, then read the ID registers. If we find
952 * a valid ID, allocate and return a &struct phy_device.
953 *
954 * When probing for a clause 45 PHY, read the "devices in package" registers.
955 * If the "devices in package" appears valid, read the ID registers for each
956 * MMD, allocate and return a &struct phy_device.
957 *
958 * Returns an allocated &struct phy_device on success, %-ENODEV if there is
959 * no PHY present, or %-EIO on bus access error.
960 */
961struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
962{
963 struct phy_c45_device_ids c45_ids;
964 u32 phy_id = 0;
965 int r;
966
967 c45_ids.devices_in_package = 0;
968 c45_ids.mmds_present = 0;
969 memset(c45_ids.device_ids, 0xff, sizeof(c45_ids.device_ids));
970
971 if (is_c45)
972 r = get_phy_c45_ids(bus, addr, &c45_ids);
973 else
974 r = get_phy_c22_id(bus, addr, &phy_id);
975
976 if (r)
977 return ERR_PTR(r);
978
979 /* PHY device such as the Marvell Alaska 88E2110 will return a PHY ID
980 * of 0 when probed using get_phy_c22_id() with no error. Proceed to
981 * probe with C45 to see if we're able to get a valid PHY ID in the C45
982 * space, if successful, create the C45 PHY device.
983 */
984 if (!is_c45 && phy_id == 0 && bus->read_c45) {
985 r = get_phy_c45_ids(bus, addr, &c45_ids);
986 if (!r)
987 return phy_device_create(bus, addr, phy_id,
988 true, &c45_ids);
989 }
990
991 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
992}
993EXPORT_SYMBOL(get_phy_device);
994
995/**
996 * phy_device_register - Register the phy device on the MDIO bus
997 * @phydev: phy_device structure to be added to the MDIO bus
998 */
999int phy_device_register(struct phy_device *phydev)
1000{
1001 int err;
1002
1003 err = mdiobus_register_device(&phydev->mdio);
1004 if (err)
1005 return err;
1006
1007 /* Deassert the reset signal */
1008 phy_device_reset(phydev, 0);
1009
1010 /* Run all of the fixups for this PHY */
1011 err = phy_scan_fixups(phydev);
1012 if (err) {
1013 phydev_err(phydev, "failed to initialize\n");
1014 goto out;
1015 }
1016
1017 err = device_add(&phydev->mdio.dev);
1018 if (err) {
1019 phydev_err(phydev, "failed to add\n");
1020 goto out;
1021 }
1022
1023 return 0;
1024
1025 out:
1026 /* Assert the reset signal */
1027 phy_device_reset(phydev, 1);
1028
1029 mdiobus_unregister_device(&phydev->mdio);
1030 return err;
1031}
1032EXPORT_SYMBOL(phy_device_register);
1033
1034/**
1035 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
1036 * @phydev: phy_device structure to remove
1037 *
1038 * This doesn't free the phy_device itself, it merely reverses the effects
1039 * of phy_device_register(). Use phy_device_free() to free the device
1040 * after calling this function.
1041 */
1042void phy_device_remove(struct phy_device *phydev)
1043{
1044 unregister_mii_timestamper(phydev->mii_ts);
1045 pse_control_put(phydev->psec);
1046
1047 device_del(&phydev->mdio.dev);
1048
1049 /* Assert the reset signal */
1050 phy_device_reset(phydev, 1);
1051
1052 mdiobus_unregister_device(&phydev->mdio);
1053}
1054EXPORT_SYMBOL(phy_device_remove);
1055
1056/**
1057 * phy_get_c45_ids - Read 802.3-c45 IDs for phy device.
1058 * @phydev: phy_device structure to read 802.3-c45 IDs
1059 *
1060 * Returns zero on success, %-EIO on bus access error, or %-ENODEV if
1061 * the "devices in package" is invalid.
1062 */
1063int phy_get_c45_ids(struct phy_device *phydev)
1064{
1065 return get_phy_c45_ids(phydev->mdio.bus, phydev->mdio.addr,
1066 &phydev->c45_ids);
1067}
1068EXPORT_SYMBOL(phy_get_c45_ids);
1069
1070/**
1071 * phy_find_first - finds the first PHY device on the bus
1072 * @bus: the target MII bus
1073 */
1074struct phy_device *phy_find_first(struct mii_bus *bus)
1075{
1076 struct phy_device *phydev;
1077 int addr;
1078
1079 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
1080 phydev = mdiobus_get_phy(bus, addr);
1081 if (phydev)
1082 return phydev;
1083 }
1084 return NULL;
1085}
1086EXPORT_SYMBOL(phy_find_first);
1087
1088static void phy_link_change(struct phy_device *phydev, bool up)
1089{
1090 struct net_device *netdev = phydev->attached_dev;
1091
1092 if (up)
1093 netif_carrier_on(netdev);
1094 else
1095 netif_carrier_off(netdev);
1096 phydev->adjust_link(netdev);
1097 if (phydev->mii_ts && phydev->mii_ts->link_state)
1098 phydev->mii_ts->link_state(phydev->mii_ts, phydev);
1099}
1100
1101/**
1102 * phy_prepare_link - prepares the PHY layer to monitor link status
1103 * @phydev: target phy_device struct
1104 * @handler: callback function for link status change notifications
1105 *
1106 * Description: Tells the PHY infrastructure to handle the
1107 * gory details on monitoring link status (whether through
1108 * polling or an interrupt), and to call back to the
1109 * connected device driver when the link status changes.
1110 * If you want to monitor your own link state, don't call
1111 * this function.
1112 */
1113static void phy_prepare_link(struct phy_device *phydev,
1114 void (*handler)(struct net_device *))
1115{
1116 phydev->adjust_link = handler;
1117}
1118
1119/**
1120 * phy_connect_direct - connect an ethernet device to a specific phy_device
1121 * @dev: the network device to connect
1122 * @phydev: the pointer to the phy device
1123 * @handler: callback function for state change notifications
1124 * @interface: PHY device's interface
1125 */
1126int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
1127 void (*handler)(struct net_device *),
1128 phy_interface_t interface)
1129{
1130 int rc;
1131
1132 if (!dev)
1133 return -EINVAL;
1134
1135 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1136 if (rc)
1137 return rc;
1138
1139 phy_prepare_link(phydev, handler);
1140 if (phy_interrupt_is_valid(phydev))
1141 phy_request_interrupt(phydev);
1142
1143 return 0;
1144}
1145EXPORT_SYMBOL(phy_connect_direct);
1146
1147/**
1148 * phy_connect - connect an ethernet device to a PHY device
1149 * @dev: the network device to connect
1150 * @bus_id: the id string of the PHY device to connect
1151 * @handler: callback function for state change notifications
1152 * @interface: PHY device's interface
1153 *
1154 * Description: Convenience function for connecting ethernet
1155 * devices to PHY devices. The default behavior is for
1156 * the PHY infrastructure to handle everything, and only notify
1157 * the connected driver when the link status changes. If you
1158 * don't want, or can't use the provided functionality, you may
1159 * choose to call only the subset of functions which provide
1160 * the desired functionality.
1161 */
1162struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
1163 void (*handler)(struct net_device *),
1164 phy_interface_t interface)
1165{
1166 struct phy_device *phydev;
1167 struct device *d;
1168 int rc;
1169
1170 /* Search the list of PHY devices on the mdio bus for the
1171 * PHY with the requested name
1172 */
1173 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1174 if (!d) {
1175 pr_err("PHY %s not found\n", bus_id);
1176 return ERR_PTR(-ENODEV);
1177 }
1178 phydev = to_phy_device(d);
1179
1180 rc = phy_connect_direct(dev, phydev, handler, interface);
1181 put_device(d);
1182 if (rc)
1183 return ERR_PTR(rc);
1184
1185 return phydev;
1186}
1187EXPORT_SYMBOL(phy_connect);
1188
1189/**
1190 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1191 * device
1192 * @phydev: target phy_device struct
1193 */
1194void phy_disconnect(struct phy_device *phydev)
1195{
1196 if (phy_is_started(phydev))
1197 phy_stop(phydev);
1198
1199 if (phy_interrupt_is_valid(phydev))
1200 phy_free_interrupt(phydev);
1201
1202 phydev->adjust_link = NULL;
1203
1204 phy_detach(phydev);
1205}
1206EXPORT_SYMBOL(phy_disconnect);
1207
1208/**
1209 * phy_poll_reset - Safely wait until a PHY reset has properly completed
1210 * @phydev: The PHY device to poll
1211 *
1212 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1213 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
1214 * register must be polled until the BMCR_RESET bit clears.
1215 *
1216 * Furthermore, any attempts to write to PHY registers may have no effect
1217 * or even generate MDIO bus errors until this is complete.
1218 *
1219 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1220 * standard and do not fully reset after the BMCR_RESET bit is set, and may
1221 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
1222 * effort to support such broken PHYs, this function is separate from the
1223 * standard phy_init_hw() which will zero all the other bits in the BMCR
1224 * and reapply all driver-specific and board-specific fixups.
1225 */
1226static int phy_poll_reset(struct phy_device *phydev)
1227{
1228 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1229 int ret, val;
1230
1231 ret = phy_read_poll_timeout(phydev, MII_BMCR, val, !(val & BMCR_RESET),
1232 50000, 600000, true);
1233 if (ret)
1234 return ret;
1235 /* Some chips (smsc911x) may still need up to another 1ms after the
1236 * BMCR_RESET bit is cleared before they are usable.
1237 */
1238 msleep(1);
1239 return 0;
1240}
1241
1242int phy_init_hw(struct phy_device *phydev)
1243{
1244 int ret = 0;
1245
1246 /* Deassert the reset signal */
1247 phy_device_reset(phydev, 0);
1248
1249 if (!phydev->drv)
1250 return 0;
1251
1252 if (phydev->drv->soft_reset) {
1253 ret = phydev->drv->soft_reset(phydev);
1254 if (ret < 0)
1255 return ret;
1256
1257 /* see comment in genphy_soft_reset for an explanation */
1258 phydev->suspended = 0;
1259 }
1260
1261 ret = phy_scan_fixups(phydev);
1262 if (ret < 0)
1263 return ret;
1264
1265 phy_interface_zero(phydev->possible_interfaces);
1266
1267 if (phydev->drv->config_init) {
1268 ret = phydev->drv->config_init(phydev);
1269 if (ret < 0)
1270 return ret;
1271 }
1272
1273 if (phydev->drv->config_intr) {
1274 ret = phydev->drv->config_intr(phydev);
1275 if (ret < 0)
1276 return ret;
1277 }
1278
1279 return 0;
1280}
1281EXPORT_SYMBOL(phy_init_hw);
1282
1283void phy_attached_info(struct phy_device *phydev)
1284{
1285 phy_attached_print(phydev, NULL);
1286}
1287EXPORT_SYMBOL(phy_attached_info);
1288
1289#define ATTACHED_FMT "attached PHY driver %s(mii_bus:phy_addr=%s, irq=%s)"
1290char *phy_attached_info_irq(struct phy_device *phydev)
1291{
1292 char *irq_str;
1293 char irq_num[8];
1294
1295 switch(phydev->irq) {
1296 case PHY_POLL:
1297 irq_str = "POLL";
1298 break;
1299 case PHY_MAC_INTERRUPT:
1300 irq_str = "MAC";
1301 break;
1302 default:
1303 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1304 irq_str = irq_num;
1305 break;
1306 }
1307
1308 return kasprintf(GFP_KERNEL, "%s", irq_str);
1309}
1310EXPORT_SYMBOL(phy_attached_info_irq);
1311
1312void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1313{
1314 const char *unbound = phydev->drv ? "" : "[unbound] ";
1315 char *irq_str = phy_attached_info_irq(phydev);
1316
1317 if (!fmt) {
1318 phydev_info(phydev, ATTACHED_FMT "\n", unbound,
1319 phydev_name(phydev), irq_str);
1320 } else {
1321 va_list ap;
1322
1323 phydev_info(phydev, ATTACHED_FMT, unbound,
1324 phydev_name(phydev), irq_str);
1325
1326 va_start(ap, fmt);
1327 vprintk(fmt, ap);
1328 va_end(ap);
1329 }
1330 kfree(irq_str);
1331}
1332EXPORT_SYMBOL(phy_attached_print);
1333
1334static void phy_sysfs_create_links(struct phy_device *phydev)
1335{
1336 struct net_device *dev = phydev->attached_dev;
1337 int err;
1338
1339 if (!dev)
1340 return;
1341
1342 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1343 "attached_dev");
1344 if (err)
1345 return;
1346
1347 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1348 &phydev->mdio.dev.kobj,
1349 "phydev");
1350 if (err) {
1351 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1352 kobject_name(&phydev->mdio.dev.kobj),
1353 err);
1354 /* non-fatal - some net drivers can use one netdevice
1355 * with more then one phy
1356 */
1357 }
1358
1359 phydev->sysfs_links = true;
1360}
1361
1362static ssize_t
1363phy_standalone_show(struct device *dev, struct device_attribute *attr,
1364 char *buf)
1365{
1366 struct phy_device *phydev = to_phy_device(dev);
1367
1368 return sysfs_emit(buf, "%d\n", !phydev->attached_dev);
1369}
1370static DEVICE_ATTR_RO(phy_standalone);
1371
1372/**
1373 * phy_sfp_attach - attach the SFP bus to the PHY upstream network device
1374 * @upstream: pointer to the phy device
1375 * @bus: sfp bus representing cage being attached
1376 *
1377 * This is used to fill in the sfp_upstream_ops .attach member.
1378 */
1379void phy_sfp_attach(void *upstream, struct sfp_bus *bus)
1380{
1381 struct phy_device *phydev = upstream;
1382
1383 if (phydev->attached_dev)
1384 phydev->attached_dev->sfp_bus = bus;
1385 phydev->sfp_bus_attached = true;
1386}
1387EXPORT_SYMBOL(phy_sfp_attach);
1388
1389/**
1390 * phy_sfp_detach - detach the SFP bus from the PHY upstream network device
1391 * @upstream: pointer to the phy device
1392 * @bus: sfp bus representing cage being attached
1393 *
1394 * This is used to fill in the sfp_upstream_ops .detach member.
1395 */
1396void phy_sfp_detach(void *upstream, struct sfp_bus *bus)
1397{
1398 struct phy_device *phydev = upstream;
1399
1400 if (phydev->attached_dev)
1401 phydev->attached_dev->sfp_bus = NULL;
1402 phydev->sfp_bus_attached = false;
1403}
1404EXPORT_SYMBOL(phy_sfp_detach);
1405
1406/**
1407 * phy_sfp_probe - probe for a SFP cage attached to this PHY device
1408 * @phydev: Pointer to phy_device
1409 * @ops: SFP's upstream operations
1410 */
1411int phy_sfp_probe(struct phy_device *phydev,
1412 const struct sfp_upstream_ops *ops)
1413{
1414 struct sfp_bus *bus;
1415 int ret = 0;
1416
1417 if (phydev->mdio.dev.fwnode) {
1418 bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
1419 if (IS_ERR(bus))
1420 return PTR_ERR(bus);
1421
1422 phydev->sfp_bus = bus;
1423
1424 ret = sfp_bus_add_upstream(bus, phydev, ops);
1425 sfp_bus_put(bus);
1426 }
1427 return ret;
1428}
1429EXPORT_SYMBOL(phy_sfp_probe);
1430
1431static bool phy_drv_supports_irq(const struct phy_driver *phydrv)
1432{
1433 return phydrv->config_intr && phydrv->handle_interrupt;
1434}
1435
1436/**
1437 * phy_attach_direct - attach a network device to a given PHY device pointer
1438 * @dev: network device to attach
1439 * @phydev: Pointer to phy_device to attach
1440 * @flags: PHY device's dev_flags
1441 * @interface: PHY device's interface
1442 *
1443 * Description: Called by drivers to attach to a particular PHY
1444 * device. The phy_device is found, and properly hooked up
1445 * to the phy_driver. If no driver is attached, then a
1446 * generic driver is used. The phy_device is given a ptr to
1447 * the attaching device, and given a callback for link status
1448 * change. The phy_device is returned to the attaching driver.
1449 * This function takes a reference on the phy device.
1450 */
1451int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1452 u32 flags, phy_interface_t interface)
1453{
1454 struct mii_bus *bus = phydev->mdio.bus;
1455 struct device *d = &phydev->mdio.dev;
1456 struct module *ndev_owner = NULL;
1457 bool using_genphy = false;
1458 int err;
1459
1460 /* For Ethernet device drivers that register their own MDIO bus, we
1461 * will have bus->owner match ndev_mod, so we do not want to increment
1462 * our own module->refcnt here, otherwise we would not be able to
1463 * unload later on.
1464 */
1465 if (dev)
1466 ndev_owner = dev->dev.parent->driver->owner;
1467 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1468 phydev_err(phydev, "failed to get the bus module\n");
1469 return -EIO;
1470 }
1471
1472 get_device(d);
1473
1474 /* Assume that if there is no driver, that it doesn't
1475 * exist, and we should use the genphy driver.
1476 */
1477 if (!d->driver) {
1478 if (phydev->is_c45)
1479 d->driver = &genphy_c45_driver.mdiodrv.driver;
1480 else
1481 d->driver = &genphy_driver.mdiodrv.driver;
1482
1483 using_genphy = true;
1484 }
1485
1486 if (!try_module_get(d->driver->owner)) {
1487 phydev_err(phydev, "failed to get the device driver module\n");
1488 err = -EIO;
1489 goto error_put_device;
1490 }
1491
1492 if (using_genphy) {
1493 err = d->driver->probe(d);
1494 if (err >= 0)
1495 err = device_bind_driver(d);
1496
1497 if (err)
1498 goto error_module_put;
1499 }
1500
1501 if (phydev->attached_dev) {
1502 dev_err(&dev->dev, "PHY already attached\n");
1503 err = -EBUSY;
1504 goto error;
1505 }
1506
1507 phydev->phy_link_change = phy_link_change;
1508 if (dev) {
1509 phydev->attached_dev = dev;
1510 dev->phydev = phydev;
1511
1512 if (phydev->sfp_bus_attached)
1513 dev->sfp_bus = phydev->sfp_bus;
1514 }
1515
1516 /* Some Ethernet drivers try to connect to a PHY device before
1517 * calling register_netdevice() -> netdev_register_kobject() and
1518 * does the dev->dev.kobj initialization. Here we only check for
1519 * success which indicates that the network device kobject is
1520 * ready. Once we do that we still need to keep track of whether
1521 * links were successfully set up or not for phy_detach() to
1522 * remove them accordingly.
1523 */
1524 phydev->sysfs_links = false;
1525
1526 phy_sysfs_create_links(phydev);
1527
1528 if (!phydev->attached_dev) {
1529 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1530 &dev_attr_phy_standalone.attr);
1531 if (err)
1532 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1533 }
1534
1535 phydev->dev_flags |= flags;
1536
1537 phydev->interface = interface;
1538
1539 phydev->state = PHY_READY;
1540
1541 phydev->interrupts = PHY_INTERRUPT_DISABLED;
1542
1543 /* PHYs can request to use poll mode even though they have an
1544 * associated interrupt line. This could be the case if they
1545 * detect a broken interrupt handling.
1546 */
1547 if (phydev->dev_flags & PHY_F_NO_IRQ)
1548 phydev->irq = PHY_POLL;
1549
1550 if (!phy_drv_supports_irq(phydev->drv) && phy_interrupt_is_valid(phydev))
1551 phydev->irq = PHY_POLL;
1552
1553 /* Port is set to PORT_TP by default and the actual PHY driver will set
1554 * it to different value depending on the PHY configuration. If we have
1555 * the generic PHY driver we can't figure it out, thus set the old
1556 * legacy PORT_MII value.
1557 */
1558 if (using_genphy)
1559 phydev->port = PORT_MII;
1560
1561 /* Initial carrier state is off as the phy is about to be
1562 * (re)initialized.
1563 */
1564 if (dev)
1565 netif_carrier_off(phydev->attached_dev);
1566
1567 /* Do initial configuration here, now that
1568 * we have certain key parameters
1569 * (dev_flags and interface)
1570 */
1571 err = phy_init_hw(phydev);
1572 if (err)
1573 goto error;
1574
1575 phy_resume(phydev);
1576 if (!phydev->is_on_sfp_module)
1577 phy_led_triggers_register(phydev);
1578
1579 /**
1580 * If the external phy used by current mac interface is managed by
1581 * another mac interface, so we should create a device link between
1582 * phy dev and mac dev.
1583 */
1584 if (dev && phydev->mdio.bus->parent && dev->dev.parent != phydev->mdio.bus->parent)
1585 phydev->devlink = device_link_add(dev->dev.parent, &phydev->mdio.dev,
1586 DL_FLAG_PM_RUNTIME | DL_FLAG_STATELESS);
1587
1588 return err;
1589
1590error:
1591 /* phy_detach() does all of the cleanup below */
1592 phy_detach(phydev);
1593 return err;
1594
1595error_module_put:
1596 module_put(d->driver->owner);
1597 d->driver = NULL;
1598error_put_device:
1599 put_device(d);
1600 if (ndev_owner != bus->owner)
1601 module_put(bus->owner);
1602 return err;
1603}
1604EXPORT_SYMBOL(phy_attach_direct);
1605
1606/**
1607 * phy_attach - attach a network device to a particular PHY device
1608 * @dev: network device to attach
1609 * @bus_id: Bus ID of PHY device to attach
1610 * @interface: PHY device's interface
1611 *
1612 * Description: Same as phy_attach_direct() except that a PHY bus_id
1613 * string is passed instead of a pointer to a struct phy_device.
1614 */
1615struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1616 phy_interface_t interface)
1617{
1618 struct phy_device *phydev;
1619 struct device *d;
1620 int rc;
1621
1622 if (!dev)
1623 return ERR_PTR(-EINVAL);
1624
1625 /* Search the list of PHY devices on the mdio bus for the
1626 * PHY with the requested name
1627 */
1628 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
1629 if (!d) {
1630 pr_err("PHY %s not found\n", bus_id);
1631 return ERR_PTR(-ENODEV);
1632 }
1633 phydev = to_phy_device(d);
1634
1635 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1636 put_device(d);
1637 if (rc)
1638 return ERR_PTR(rc);
1639
1640 return phydev;
1641}
1642EXPORT_SYMBOL(phy_attach);
1643
1644static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1645 struct device_driver *driver)
1646{
1647 struct device *d = &phydev->mdio.dev;
1648 bool ret = false;
1649
1650 if (!phydev->drv)
1651 return ret;
1652
1653 get_device(d);
1654 ret = d->driver == driver;
1655 put_device(d);
1656
1657 return ret;
1658}
1659
1660bool phy_driver_is_genphy(struct phy_device *phydev)
1661{
1662 return phy_driver_is_genphy_kind(phydev,
1663 &genphy_driver.mdiodrv.driver);
1664}
1665EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
1666
1667bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1668{
1669 return phy_driver_is_genphy_kind(phydev,
1670 &genphy_c45_driver.mdiodrv.driver);
1671}
1672EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
1673
1674/**
1675 * phy_package_join - join a common PHY group
1676 * @phydev: target phy_device struct
1677 * @base_addr: cookie and base PHY address of PHY package for offset
1678 * calculation of global register access
1679 * @priv_size: if non-zero allocate this amount of bytes for private data
1680 *
1681 * This joins a PHY group and provides a shared storage for all phydevs in
1682 * this group. This is intended to be used for packages which contain
1683 * more than one PHY, for example a quad PHY transceiver.
1684 *
1685 * The base_addr parameter serves as cookie which has to have the same values
1686 * for all members of one group and as the base PHY address of the PHY package
1687 * for offset calculation to access generic registers of a PHY package.
1688 * Usually, one of the PHY addresses of the different PHYs in the package
1689 * provides access to these global registers.
1690 * The address which is given here, will be used in the phy_package_read()
1691 * and phy_package_write() convenience functions as base and added to the
1692 * passed offset in those functions.
1693 *
1694 * This will set the shared pointer of the phydev to the shared storage.
1695 * If this is the first call for a this cookie the shared storage will be
1696 * allocated. If priv_size is non-zero, the given amount of bytes are
1697 * allocated for the priv member.
1698 *
1699 * Returns < 1 on error, 0 on success. Esp. calling phy_package_join()
1700 * with the same cookie but a different priv_size is an error.
1701 */
1702int phy_package_join(struct phy_device *phydev, int base_addr, size_t priv_size)
1703{
1704 struct mii_bus *bus = phydev->mdio.bus;
1705 struct phy_package_shared *shared;
1706 int ret;
1707
1708 if (base_addr < 0 || base_addr >= PHY_MAX_ADDR)
1709 return -EINVAL;
1710
1711 mutex_lock(&bus->shared_lock);
1712 shared = bus->shared[base_addr];
1713 if (!shared) {
1714 ret = -ENOMEM;
1715 shared = kzalloc(sizeof(*shared), GFP_KERNEL);
1716 if (!shared)
1717 goto err_unlock;
1718 if (priv_size) {
1719 shared->priv = kzalloc(priv_size, GFP_KERNEL);
1720 if (!shared->priv)
1721 goto err_free;
1722 shared->priv_size = priv_size;
1723 }
1724 shared->base_addr = base_addr;
1725 shared->np = NULL;
1726 refcount_set(&shared->refcnt, 1);
1727 bus->shared[base_addr] = shared;
1728 } else {
1729 ret = -EINVAL;
1730 if (priv_size && priv_size != shared->priv_size)
1731 goto err_unlock;
1732 refcount_inc(&shared->refcnt);
1733 }
1734 mutex_unlock(&bus->shared_lock);
1735
1736 phydev->shared = shared;
1737
1738 return 0;
1739
1740err_free:
1741 kfree(shared);
1742err_unlock:
1743 mutex_unlock(&bus->shared_lock);
1744 return ret;
1745}
1746EXPORT_SYMBOL_GPL(phy_package_join);
1747
1748/**
1749 * of_phy_package_join - join a common PHY group in PHY package
1750 * @phydev: target phy_device struct
1751 * @priv_size: if non-zero allocate this amount of bytes for private data
1752 *
1753 * This is a variant of phy_package_join for PHY package defined in DT.
1754 *
1755 * The parent node of the @phydev is checked as a valid PHY package node
1756 * structure (by matching the node name "ethernet-phy-package") and the
1757 * base_addr for the PHY package is passed to phy_package_join.
1758 *
1759 * With this configuration the shared struct will also have the np value
1760 * filled to use additional DT defined properties in PHY specific
1761 * probe_once and config_init_once PHY package OPs.
1762 *
1763 * Returns < 0 on error, 0 on success. Esp. calling phy_package_join()
1764 * with the same cookie but a different priv_size is an error. Or a parent
1765 * node is not detected or is not valid or doesn't match the expected node
1766 * name for PHY package.
1767 */
1768int of_phy_package_join(struct phy_device *phydev, size_t priv_size)
1769{
1770 struct device_node *node = phydev->mdio.dev.of_node;
1771 struct device_node *package_node;
1772 u32 base_addr;
1773 int ret;
1774
1775 if (!node)
1776 return -EINVAL;
1777
1778 package_node = of_get_parent(node);
1779 if (!package_node)
1780 return -EINVAL;
1781
1782 if (!of_node_name_eq(package_node, "ethernet-phy-package")) {
1783 ret = -EINVAL;
1784 goto exit;
1785 }
1786
1787 if (of_property_read_u32(package_node, "reg", &base_addr)) {
1788 ret = -EINVAL;
1789 goto exit;
1790 }
1791
1792 ret = phy_package_join(phydev, base_addr, priv_size);
1793 if (ret)
1794 goto exit;
1795
1796 phydev->shared->np = package_node;
1797
1798 return 0;
1799exit:
1800 of_node_put(package_node);
1801 return ret;
1802}
1803EXPORT_SYMBOL_GPL(of_phy_package_join);
1804
1805/**
1806 * phy_package_leave - leave a common PHY group
1807 * @phydev: target phy_device struct
1808 *
1809 * This leaves a PHY group created by phy_package_join(). If this phydev
1810 * was the last user of the shared data between the group, this data is
1811 * freed. Resets the phydev->shared pointer to NULL.
1812 */
1813void phy_package_leave(struct phy_device *phydev)
1814{
1815 struct phy_package_shared *shared = phydev->shared;
1816 struct mii_bus *bus = phydev->mdio.bus;
1817
1818 if (!shared)
1819 return;
1820
1821 /* Decrease the node refcount on leave if present */
1822 if (shared->np)
1823 of_node_put(shared->np);
1824
1825 if (refcount_dec_and_mutex_lock(&shared->refcnt, &bus->shared_lock)) {
1826 bus->shared[shared->base_addr] = NULL;
1827 mutex_unlock(&bus->shared_lock);
1828 kfree(shared->priv);
1829 kfree(shared);
1830 }
1831
1832 phydev->shared = NULL;
1833}
1834EXPORT_SYMBOL_GPL(phy_package_leave);
1835
1836static void devm_phy_package_leave(struct device *dev, void *res)
1837{
1838 phy_package_leave(*(struct phy_device **)res);
1839}
1840
1841/**
1842 * devm_phy_package_join - resource managed phy_package_join()
1843 * @dev: device that is registering this PHY package
1844 * @phydev: target phy_device struct
1845 * @base_addr: cookie and base PHY address of PHY package for offset
1846 * calculation of global register access
1847 * @priv_size: if non-zero allocate this amount of bytes for private data
1848 *
1849 * Managed phy_package_join(). Shared storage fetched by this function,
1850 * phy_package_leave() is automatically called on driver detach. See
1851 * phy_package_join() for more information.
1852 */
1853int devm_phy_package_join(struct device *dev, struct phy_device *phydev,
1854 int base_addr, size_t priv_size)
1855{
1856 struct phy_device **ptr;
1857 int ret;
1858
1859 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),
1860 GFP_KERNEL);
1861 if (!ptr)
1862 return -ENOMEM;
1863
1864 ret = phy_package_join(phydev, base_addr, priv_size);
1865
1866 if (!ret) {
1867 *ptr = phydev;
1868 devres_add(dev, ptr);
1869 } else {
1870 devres_free(ptr);
1871 }
1872
1873 return ret;
1874}
1875EXPORT_SYMBOL_GPL(devm_phy_package_join);
1876
1877/**
1878 * devm_of_phy_package_join - resource managed of_phy_package_join()
1879 * @dev: device that is registering this PHY package
1880 * @phydev: target phy_device struct
1881 * @priv_size: if non-zero allocate this amount of bytes for private data
1882 *
1883 * Managed of_phy_package_join(). Shared storage fetched by this function,
1884 * phy_package_leave() is automatically called on driver detach. See
1885 * of_phy_package_join() for more information.
1886 */
1887int devm_of_phy_package_join(struct device *dev, struct phy_device *phydev,
1888 size_t priv_size)
1889{
1890 struct phy_device **ptr;
1891 int ret;
1892
1893 ptr = devres_alloc(devm_phy_package_leave, sizeof(*ptr),
1894 GFP_KERNEL);
1895 if (!ptr)
1896 return -ENOMEM;
1897
1898 ret = of_phy_package_join(phydev, priv_size);
1899
1900 if (!ret) {
1901 *ptr = phydev;
1902 devres_add(dev, ptr);
1903 } else {
1904 devres_free(ptr);
1905 }
1906
1907 return ret;
1908}
1909EXPORT_SYMBOL_GPL(devm_of_phy_package_join);
1910
1911/**
1912 * phy_detach - detach a PHY device from its network device
1913 * @phydev: target phy_device struct
1914 *
1915 * This detaches the phy device from its network device and the phy
1916 * driver, and drops the reference count taken in phy_attach_direct().
1917 */
1918void phy_detach(struct phy_device *phydev)
1919{
1920 struct net_device *dev = phydev->attached_dev;
1921 struct module *ndev_owner = NULL;
1922 struct mii_bus *bus;
1923
1924 if (phydev->devlink)
1925 device_link_del(phydev->devlink);
1926
1927 if (phydev->sysfs_links) {
1928 if (dev)
1929 sysfs_remove_link(&dev->dev.kobj, "phydev");
1930 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1931 }
1932
1933 if (!phydev->attached_dev)
1934 sysfs_remove_file(&phydev->mdio.dev.kobj,
1935 &dev_attr_phy_standalone.attr);
1936
1937 phy_suspend(phydev);
1938 if (dev) {
1939 phydev->attached_dev->phydev = NULL;
1940 phydev->attached_dev = NULL;
1941 }
1942 phydev->phylink = NULL;
1943
1944 if (!phydev->is_on_sfp_module)
1945 phy_led_triggers_unregister(phydev);
1946
1947 if (phydev->mdio.dev.driver)
1948 module_put(phydev->mdio.dev.driver->owner);
1949
1950 /* If the device had no specific driver before (i.e. - it
1951 * was using the generic driver), we unbind the device
1952 * from the generic driver so that there's a chance a
1953 * real driver could be loaded
1954 */
1955 if (phy_driver_is_genphy(phydev) ||
1956 phy_driver_is_genphy_10g(phydev))
1957 device_release_driver(&phydev->mdio.dev);
1958
1959 /* Assert the reset signal */
1960 phy_device_reset(phydev, 1);
1961
1962 /*
1963 * The phydev might go away on the put_device() below, so avoid
1964 * a use-after-free bug by reading the underlying bus first.
1965 */
1966 bus = phydev->mdio.bus;
1967
1968 put_device(&phydev->mdio.dev);
1969 if (dev)
1970 ndev_owner = dev->dev.parent->driver->owner;
1971 if (ndev_owner != bus->owner)
1972 module_put(bus->owner);
1973}
1974EXPORT_SYMBOL(phy_detach);
1975
1976int phy_suspend(struct phy_device *phydev)
1977{
1978 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1979 struct net_device *netdev = phydev->attached_dev;
1980 const struct phy_driver *phydrv = phydev->drv;
1981 int ret;
1982
1983 if (phydev->suspended)
1984 return 0;
1985
1986 phy_ethtool_get_wol(phydev, &wol);
1987 phydev->wol_enabled = wol.wolopts || (netdev && netdev->wol_enabled);
1988 /* If the device has WOL enabled, we cannot suspend the PHY */
1989 if (phydev->wol_enabled && !(phydrv->flags & PHY_ALWAYS_CALL_SUSPEND))
1990 return -EBUSY;
1991
1992 if (!phydrv || !phydrv->suspend)
1993 return 0;
1994
1995 ret = phydrv->suspend(phydev);
1996 if (!ret)
1997 phydev->suspended = true;
1998
1999 return ret;
2000}
2001EXPORT_SYMBOL(phy_suspend);
2002
2003int __phy_resume(struct phy_device *phydev)
2004{
2005 const struct phy_driver *phydrv = phydev->drv;
2006 int ret;
2007
2008 lockdep_assert_held(&phydev->lock);
2009
2010 if (!phydrv || !phydrv->resume)
2011 return 0;
2012
2013 ret = phydrv->resume(phydev);
2014 if (!ret)
2015 phydev->suspended = false;
2016
2017 return ret;
2018}
2019EXPORT_SYMBOL(__phy_resume);
2020
2021int phy_resume(struct phy_device *phydev)
2022{
2023 int ret;
2024
2025 mutex_lock(&phydev->lock);
2026 ret = __phy_resume(phydev);
2027 mutex_unlock(&phydev->lock);
2028
2029 return ret;
2030}
2031EXPORT_SYMBOL(phy_resume);
2032
2033int phy_loopback(struct phy_device *phydev, bool enable)
2034{
2035 int ret = 0;
2036
2037 if (!phydev->drv)
2038 return -EIO;
2039
2040 mutex_lock(&phydev->lock);
2041
2042 if (enable && phydev->loopback_enabled) {
2043 ret = -EBUSY;
2044 goto out;
2045 }
2046
2047 if (!enable && !phydev->loopback_enabled) {
2048 ret = -EINVAL;
2049 goto out;
2050 }
2051
2052 if (phydev->drv->set_loopback)
2053 ret = phydev->drv->set_loopback(phydev, enable);
2054 else
2055 ret = genphy_loopback(phydev, enable);
2056
2057 if (ret)
2058 goto out;
2059
2060 phydev->loopback_enabled = enable;
2061
2062out:
2063 mutex_unlock(&phydev->lock);
2064 return ret;
2065}
2066EXPORT_SYMBOL(phy_loopback);
2067
2068/**
2069 * phy_reset_after_clk_enable - perform a PHY reset if needed
2070 * @phydev: target phy_device struct
2071 *
2072 * Description: Some PHYs are known to need a reset after their refclk was
2073 * enabled. This function evaluates the flags and perform the reset if it's
2074 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
2075 * was reset.
2076 */
2077int phy_reset_after_clk_enable(struct phy_device *phydev)
2078{
2079 if (!phydev || !phydev->drv)
2080 return -ENODEV;
2081
2082 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
2083 phy_device_reset(phydev, 1);
2084 phy_device_reset(phydev, 0);
2085 return 1;
2086 }
2087
2088 return 0;
2089}
2090EXPORT_SYMBOL(phy_reset_after_clk_enable);
2091
2092/* Generic PHY support and helper functions */
2093
2094/**
2095 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
2096 * @phydev: target phy_device struct
2097 *
2098 * Description: Writes MII_ADVERTISE with the appropriate values,
2099 * after sanitizing the values to make sure we only advertise
2100 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2101 * hasn't changed, and > 0 if it has changed.
2102 */
2103static int genphy_config_advert(struct phy_device *phydev)
2104{
2105 int err, bmsr, changed = 0;
2106 u32 adv;
2107
2108 /* Only allow advertising what this PHY supports */
2109 linkmode_and(phydev->advertising, phydev->advertising,
2110 phydev->supported);
2111
2112 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
2113
2114 /* Setup standard advertisement */
2115 err = phy_modify_changed(phydev, MII_ADVERTISE,
2116 ADVERTISE_ALL | ADVERTISE_100BASE4 |
2117 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
2118 adv);
2119 if (err < 0)
2120 return err;
2121 if (err > 0)
2122 changed = 1;
2123
2124 bmsr = phy_read(phydev, MII_BMSR);
2125 if (bmsr < 0)
2126 return bmsr;
2127
2128 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
2129 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
2130 * logical 1.
2131 */
2132 if (!(bmsr & BMSR_ESTATEN))
2133 return changed;
2134
2135 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
2136
2137 err = phy_modify_changed(phydev, MII_CTRL1000,
2138 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
2139 adv);
2140 if (err < 0)
2141 return err;
2142 if (err > 0)
2143 changed = 1;
2144
2145 return changed;
2146}
2147
2148/**
2149 * genphy_c37_config_advert - sanitize and advertise auto-negotiation parameters
2150 * @phydev: target phy_device struct
2151 *
2152 * Description: Writes MII_ADVERTISE with the appropriate values,
2153 * after sanitizing the values to make sure we only advertise
2154 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
2155 * hasn't changed, and > 0 if it has changed. This function is intended
2156 * for Clause 37 1000Base-X mode.
2157 */
2158static int genphy_c37_config_advert(struct phy_device *phydev)
2159{
2160 u16 adv = 0;
2161
2162 /* Only allow advertising what this PHY supports */
2163 linkmode_and(phydev->advertising, phydev->advertising,
2164 phydev->supported);
2165
2166 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2167 phydev->advertising))
2168 adv |= ADVERTISE_1000XFULL;
2169 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2170 phydev->advertising))
2171 adv |= ADVERTISE_1000XPAUSE;
2172 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2173 phydev->advertising))
2174 adv |= ADVERTISE_1000XPSE_ASYM;
2175
2176 return phy_modify_changed(phydev, MII_ADVERTISE,
2177 ADVERTISE_1000XFULL | ADVERTISE_1000XPAUSE |
2178 ADVERTISE_1000XHALF | ADVERTISE_1000XPSE_ASYM,
2179 adv);
2180}
2181
2182/**
2183 * genphy_config_eee_advert - disable unwanted eee mode advertisement
2184 * @phydev: target phy_device struct
2185 *
2186 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
2187 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
2188 * changed, and 1 if it has changed.
2189 */
2190int genphy_config_eee_advert(struct phy_device *phydev)
2191{
2192 int err;
2193
2194 /* Nothing to disable */
2195 if (!phydev->eee_broken_modes)
2196 return 0;
2197
2198 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
2199 phydev->eee_broken_modes, 0);
2200 /* If the call failed, we assume that EEE is not supported */
2201 return err < 0 ? 0 : err;
2202}
2203EXPORT_SYMBOL(genphy_config_eee_advert);
2204
2205/**
2206 * genphy_setup_forced - configures/forces speed/duplex from @phydev
2207 * @phydev: target phy_device struct
2208 *
2209 * Description: Configures MII_BMCR to force speed/duplex
2210 * to the values in phydev. Assumes that the values are valid.
2211 * Please see phy_sanitize_settings().
2212 */
2213int genphy_setup_forced(struct phy_device *phydev)
2214{
2215 u16 ctl;
2216
2217 phydev->pause = 0;
2218 phydev->asym_pause = 0;
2219
2220 ctl = mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2221
2222 return phy_modify(phydev, MII_BMCR,
2223 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
2224}
2225EXPORT_SYMBOL(genphy_setup_forced);
2226
2227static int genphy_setup_master_slave(struct phy_device *phydev)
2228{
2229 u16 ctl = 0;
2230
2231 if (!phydev->is_gigabit_capable)
2232 return 0;
2233
2234 switch (phydev->master_slave_set) {
2235 case MASTER_SLAVE_CFG_MASTER_PREFERRED:
2236 ctl |= CTL1000_PREFER_MASTER;
2237 break;
2238 case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
2239 break;
2240 case MASTER_SLAVE_CFG_MASTER_FORCE:
2241 ctl |= CTL1000_AS_MASTER;
2242 fallthrough;
2243 case MASTER_SLAVE_CFG_SLAVE_FORCE:
2244 ctl |= CTL1000_ENABLE_MASTER;
2245 break;
2246 case MASTER_SLAVE_CFG_UNKNOWN:
2247 case MASTER_SLAVE_CFG_UNSUPPORTED:
2248 return 0;
2249 default:
2250 phydev_warn(phydev, "Unsupported Master/Slave mode\n");
2251 return -EOPNOTSUPP;
2252 }
2253
2254 return phy_modify_changed(phydev, MII_CTRL1000,
2255 (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER |
2256 CTL1000_PREFER_MASTER), ctl);
2257}
2258
2259int genphy_read_master_slave(struct phy_device *phydev)
2260{
2261 int cfg, state;
2262 int val;
2263
2264 phydev->master_slave_get = MASTER_SLAVE_CFG_UNKNOWN;
2265 phydev->master_slave_state = MASTER_SLAVE_STATE_UNKNOWN;
2266
2267 val = phy_read(phydev, MII_CTRL1000);
2268 if (val < 0)
2269 return val;
2270
2271 if (val & CTL1000_ENABLE_MASTER) {
2272 if (val & CTL1000_AS_MASTER)
2273 cfg = MASTER_SLAVE_CFG_MASTER_FORCE;
2274 else
2275 cfg = MASTER_SLAVE_CFG_SLAVE_FORCE;
2276 } else {
2277 if (val & CTL1000_PREFER_MASTER)
2278 cfg = MASTER_SLAVE_CFG_MASTER_PREFERRED;
2279 else
2280 cfg = MASTER_SLAVE_CFG_SLAVE_PREFERRED;
2281 }
2282
2283 val = phy_read(phydev, MII_STAT1000);
2284 if (val < 0)
2285 return val;
2286
2287 if (val & LPA_1000MSFAIL) {
2288 state = MASTER_SLAVE_STATE_ERR;
2289 } else if (phydev->link) {
2290 /* this bits are valid only for active link */
2291 if (val & LPA_1000MSRES)
2292 state = MASTER_SLAVE_STATE_MASTER;
2293 else
2294 state = MASTER_SLAVE_STATE_SLAVE;
2295 } else {
2296 state = MASTER_SLAVE_STATE_UNKNOWN;
2297 }
2298
2299 phydev->master_slave_get = cfg;
2300 phydev->master_slave_state = state;
2301
2302 return 0;
2303}
2304EXPORT_SYMBOL(genphy_read_master_slave);
2305
2306/**
2307 * genphy_restart_aneg - Enable and Restart Autonegotiation
2308 * @phydev: target phy_device struct
2309 */
2310int genphy_restart_aneg(struct phy_device *phydev)
2311{
2312 /* Don't isolate the PHY if we're negotiating */
2313 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
2314 BMCR_ANENABLE | BMCR_ANRESTART);
2315}
2316EXPORT_SYMBOL(genphy_restart_aneg);
2317
2318/**
2319 * genphy_check_and_restart_aneg - Enable and restart auto-negotiation
2320 * @phydev: target phy_device struct
2321 * @restart: whether aneg restart is requested
2322 *
2323 * Check, and restart auto-negotiation if needed.
2324 */
2325int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart)
2326{
2327 int ret;
2328
2329 if (!restart) {
2330 /* Advertisement hasn't changed, but maybe aneg was never on to
2331 * begin with? Or maybe phy was isolated?
2332 */
2333 ret = phy_read(phydev, MII_BMCR);
2334 if (ret < 0)
2335 return ret;
2336
2337 if (!(ret & BMCR_ANENABLE) || (ret & BMCR_ISOLATE))
2338 restart = true;
2339 }
2340
2341 if (restart)
2342 return genphy_restart_aneg(phydev);
2343
2344 return 0;
2345}
2346EXPORT_SYMBOL(genphy_check_and_restart_aneg);
2347
2348/**
2349 * __genphy_config_aneg - restart auto-negotiation or write BMCR
2350 * @phydev: target phy_device struct
2351 * @changed: whether autoneg is requested
2352 *
2353 * Description: If auto-negotiation is enabled, we configure the
2354 * advertising, and then restart auto-negotiation. If it is not
2355 * enabled, then we write the BMCR.
2356 */
2357int __genphy_config_aneg(struct phy_device *phydev, bool changed)
2358{
2359 int err;
2360
2361 err = genphy_c45_an_config_eee_aneg(phydev);
2362 if (err < 0)
2363 return err;
2364 else if (err)
2365 changed = true;
2366
2367 err = genphy_setup_master_slave(phydev);
2368 if (err < 0)
2369 return err;
2370 else if (err)
2371 changed = true;
2372
2373 if (AUTONEG_ENABLE != phydev->autoneg)
2374 return genphy_setup_forced(phydev);
2375
2376 err = genphy_config_advert(phydev);
2377 if (err < 0) /* error */
2378 return err;
2379 else if (err)
2380 changed = true;
2381
2382 return genphy_check_and_restart_aneg(phydev, changed);
2383}
2384EXPORT_SYMBOL(__genphy_config_aneg);
2385
2386/**
2387 * genphy_c37_config_aneg - restart auto-negotiation or write BMCR
2388 * @phydev: target phy_device struct
2389 *
2390 * Description: If auto-negotiation is enabled, we configure the
2391 * advertising, and then restart auto-negotiation. If it is not
2392 * enabled, then we write the BMCR. This function is intended
2393 * for use with Clause 37 1000Base-X mode.
2394 */
2395int genphy_c37_config_aneg(struct phy_device *phydev)
2396{
2397 int err, changed;
2398
2399 if (phydev->autoneg != AUTONEG_ENABLE)
2400 return genphy_setup_forced(phydev);
2401
2402 err = phy_modify(phydev, MII_BMCR, BMCR_SPEED1000 | BMCR_SPEED100,
2403 BMCR_SPEED1000);
2404 if (err)
2405 return err;
2406
2407 changed = genphy_c37_config_advert(phydev);
2408 if (changed < 0) /* error */
2409 return changed;
2410
2411 if (!changed) {
2412 /* Advertisement hasn't changed, but maybe aneg was never on to
2413 * begin with? Or maybe phy was isolated?
2414 */
2415 int ctl = phy_read(phydev, MII_BMCR);
2416
2417 if (ctl < 0)
2418 return ctl;
2419
2420 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
2421 changed = 1; /* do restart aneg */
2422 }
2423
2424 /* Only restart aneg if we are advertising something different
2425 * than we were before.
2426 */
2427 if (changed > 0)
2428 return genphy_restart_aneg(phydev);
2429
2430 return 0;
2431}
2432EXPORT_SYMBOL(genphy_c37_config_aneg);
2433
2434/**
2435 * genphy_aneg_done - return auto-negotiation status
2436 * @phydev: target phy_device struct
2437 *
2438 * Description: Reads the status register and returns 0 either if
2439 * auto-negotiation is incomplete, or if there was an error.
2440 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
2441 */
2442int genphy_aneg_done(struct phy_device *phydev)
2443{
2444 int retval = phy_read(phydev, MII_BMSR);
2445
2446 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
2447}
2448EXPORT_SYMBOL(genphy_aneg_done);
2449
2450/**
2451 * genphy_update_link - update link status in @phydev
2452 * @phydev: target phy_device struct
2453 *
2454 * Description: Update the value in phydev->link to reflect the
2455 * current link value. In order to do this, we need to read
2456 * the status register twice, keeping the second value.
2457 */
2458int genphy_update_link(struct phy_device *phydev)
2459{
2460 int status = 0, bmcr;
2461
2462 bmcr = phy_read(phydev, MII_BMCR);
2463 if (bmcr < 0)
2464 return bmcr;
2465
2466 /* Autoneg is being started, therefore disregard BMSR value and
2467 * report link as down.
2468 */
2469 if (bmcr & BMCR_ANRESTART)
2470 goto done;
2471
2472 /* The link state is latched low so that momentary link
2473 * drops can be detected. Do not double-read the status
2474 * in polling mode to detect such short link drops except
2475 * the link was already down.
2476 */
2477 if (!phy_polling_mode(phydev) || !phydev->link) {
2478 status = phy_read(phydev, MII_BMSR);
2479 if (status < 0)
2480 return status;
2481 else if (status & BMSR_LSTATUS)
2482 goto done;
2483 }
2484
2485 /* Read link and autonegotiation status */
2486 status = phy_read(phydev, MII_BMSR);
2487 if (status < 0)
2488 return status;
2489done:
2490 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
2491 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
2492
2493 /* Consider the case that autoneg was started and "aneg complete"
2494 * bit has been reset, but "link up" bit not yet.
2495 */
2496 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
2497 phydev->link = 0;
2498
2499 return 0;
2500}
2501EXPORT_SYMBOL(genphy_update_link);
2502
2503int genphy_read_lpa(struct phy_device *phydev)
2504{
2505 int lpa, lpagb;
2506
2507 if (phydev->autoneg == AUTONEG_ENABLE) {
2508 if (!phydev->autoneg_complete) {
2509 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2510 0);
2511 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
2512 return 0;
2513 }
2514
2515 if (phydev->is_gigabit_capable) {
2516 lpagb = phy_read(phydev, MII_STAT1000);
2517 if (lpagb < 0)
2518 return lpagb;
2519
2520 if (lpagb & LPA_1000MSFAIL) {
2521 int adv = phy_read(phydev, MII_CTRL1000);
2522
2523 if (adv < 0)
2524 return adv;
2525
2526 if (adv & CTL1000_ENABLE_MASTER)
2527 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
2528 else
2529 phydev_err(phydev, "Master/Slave resolution failed\n");
2530 return -ENOLINK;
2531 }
2532
2533 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
2534 lpagb);
2535 }
2536
2537 lpa = phy_read(phydev, MII_LPA);
2538 if (lpa < 0)
2539 return lpa;
2540
2541 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
2542 } else {
2543 linkmode_zero(phydev->lp_advertising);
2544 }
2545
2546 return 0;
2547}
2548EXPORT_SYMBOL(genphy_read_lpa);
2549
2550/**
2551 * genphy_read_status_fixed - read the link parameters for !aneg mode
2552 * @phydev: target phy_device struct
2553 *
2554 * Read the current duplex and speed state for a PHY operating with
2555 * autonegotiation disabled.
2556 */
2557int genphy_read_status_fixed(struct phy_device *phydev)
2558{
2559 int bmcr = phy_read(phydev, MII_BMCR);
2560
2561 if (bmcr < 0)
2562 return bmcr;
2563
2564 if (bmcr & BMCR_FULLDPLX)
2565 phydev->duplex = DUPLEX_FULL;
2566 else
2567 phydev->duplex = DUPLEX_HALF;
2568
2569 if (bmcr & BMCR_SPEED1000)
2570 phydev->speed = SPEED_1000;
2571 else if (bmcr & BMCR_SPEED100)
2572 phydev->speed = SPEED_100;
2573 else
2574 phydev->speed = SPEED_10;
2575
2576 return 0;
2577}
2578EXPORT_SYMBOL(genphy_read_status_fixed);
2579
2580/**
2581 * genphy_read_status - check the link status and update current link state
2582 * @phydev: target phy_device struct
2583 *
2584 * Description: Check the link, then figure out the current state
2585 * by comparing what we advertise with what the link partner
2586 * advertises. Start by checking the gigabit possibilities,
2587 * then move on to 10/100.
2588 */
2589int genphy_read_status(struct phy_device *phydev)
2590{
2591 int err, old_link = phydev->link;
2592
2593 /* Update the link, but return if there was an error */
2594 err = genphy_update_link(phydev);
2595 if (err)
2596 return err;
2597
2598 /* why bother the PHY if nothing can have changed */
2599 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
2600 return 0;
2601
2602 phydev->master_slave_get = MASTER_SLAVE_CFG_UNSUPPORTED;
2603 phydev->master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;
2604 phydev->speed = SPEED_UNKNOWN;
2605 phydev->duplex = DUPLEX_UNKNOWN;
2606 phydev->pause = 0;
2607 phydev->asym_pause = 0;
2608
2609 if (phydev->is_gigabit_capable) {
2610 err = genphy_read_master_slave(phydev);
2611 if (err < 0)
2612 return err;
2613 }
2614
2615 err = genphy_read_lpa(phydev);
2616 if (err < 0)
2617 return err;
2618
2619 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2620 phy_resolve_aneg_linkmode(phydev);
2621 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2622 err = genphy_read_status_fixed(phydev);
2623 if (err < 0)
2624 return err;
2625 }
2626
2627 return 0;
2628}
2629EXPORT_SYMBOL(genphy_read_status);
2630
2631/**
2632 * genphy_c37_read_status - check the link status and update current link state
2633 * @phydev: target phy_device struct
2634 * @changed: pointer where to store if link changed
2635 *
2636 * Description: Check the link, then figure out the current state
2637 * by comparing what we advertise with what the link partner
2638 * advertises. This function is for Clause 37 1000Base-X mode.
2639 *
2640 * If link has changed, @changed is set to true, false otherwise.
2641 */
2642int genphy_c37_read_status(struct phy_device *phydev, bool *changed)
2643{
2644 int lpa, err, old_link = phydev->link;
2645
2646 /* Update the link, but return if there was an error */
2647 err = genphy_update_link(phydev);
2648 if (err)
2649 return err;
2650
2651 /* why bother the PHY if nothing can have changed */
2652 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) {
2653 *changed = false;
2654 return 0;
2655 }
2656
2657 /* Signal link has changed */
2658 *changed = true;
2659 phydev->duplex = DUPLEX_UNKNOWN;
2660 phydev->pause = 0;
2661 phydev->asym_pause = 0;
2662
2663 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
2664 lpa = phy_read(phydev, MII_LPA);
2665 if (lpa < 0)
2666 return lpa;
2667
2668 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2669 phydev->lp_advertising, lpa & LPA_LPACK);
2670 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2671 phydev->lp_advertising, lpa & LPA_1000XFULL);
2672 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2673 phydev->lp_advertising, lpa & LPA_1000XPAUSE);
2674 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2675 phydev->lp_advertising,
2676 lpa & LPA_1000XPAUSE_ASYM);
2677
2678 phy_resolve_aneg_linkmode(phydev);
2679 } else if (phydev->autoneg == AUTONEG_DISABLE) {
2680 int bmcr = phy_read(phydev, MII_BMCR);
2681
2682 if (bmcr < 0)
2683 return bmcr;
2684
2685 if (bmcr & BMCR_FULLDPLX)
2686 phydev->duplex = DUPLEX_FULL;
2687 else
2688 phydev->duplex = DUPLEX_HALF;
2689 }
2690
2691 return 0;
2692}
2693EXPORT_SYMBOL(genphy_c37_read_status);
2694
2695/**
2696 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
2697 * @phydev: target phy_device struct
2698 *
2699 * Description: Perform a software PHY reset using the standard
2700 * BMCR_RESET bit and poll for the reset bit to be cleared.
2701 *
2702 * Returns: 0 on success, < 0 on failure
2703 */
2704int genphy_soft_reset(struct phy_device *phydev)
2705{
2706 u16 res = BMCR_RESET;
2707 int ret;
2708
2709 if (phydev->autoneg == AUTONEG_ENABLE)
2710 res |= BMCR_ANRESTART;
2711
2712 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
2713 if (ret < 0)
2714 return ret;
2715
2716 /* Clause 22 states that setting bit BMCR_RESET sets control registers
2717 * to their default value. Therefore the POWER DOWN bit is supposed to
2718 * be cleared after soft reset.
2719 */
2720 phydev->suspended = 0;
2721
2722 ret = phy_poll_reset(phydev);
2723 if (ret)
2724 return ret;
2725
2726 /* BMCR may be reset to defaults */
2727 if (phydev->autoneg == AUTONEG_DISABLE)
2728 ret = genphy_setup_forced(phydev);
2729
2730 return ret;
2731}
2732EXPORT_SYMBOL(genphy_soft_reset);
2733
2734irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
2735{
2736 /* It seems there are cases where the interrupts are handled by another
2737 * entity (ie an IRQ controller embedded inside the PHY) and do not
2738 * need any other interraction from phylib. In this case, just trigger
2739 * the state machine directly.
2740 */
2741 phy_trigger_machine(phydev);
2742
2743 return 0;
2744}
2745EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);
2746
2747/**
2748 * genphy_read_abilities - read PHY abilities from Clause 22 registers
2749 * @phydev: target phy_device struct
2750 *
2751 * Description: Reads the PHY's abilities and populates
2752 * phydev->supported accordingly.
2753 *
2754 * Returns: 0 on success, < 0 on failure
2755 */
2756int genphy_read_abilities(struct phy_device *phydev)
2757{
2758 int val;
2759
2760 linkmode_set_bit_array(phy_basic_ports_array,
2761 ARRAY_SIZE(phy_basic_ports_array),
2762 phydev->supported);
2763
2764 val = phy_read(phydev, MII_BMSR);
2765 if (val < 0)
2766 return val;
2767
2768 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
2769 val & BMSR_ANEGCAPABLE);
2770
2771 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
2772 val & BMSR_100FULL);
2773 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
2774 val & BMSR_100HALF);
2775 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
2776 val & BMSR_10FULL);
2777 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
2778 val & BMSR_10HALF);
2779
2780 if (val & BMSR_ESTATEN) {
2781 val = phy_read(phydev, MII_ESTATUS);
2782 if (val < 0)
2783 return val;
2784
2785 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2786 phydev->supported, val & ESTATUS_1000_TFULL);
2787 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2788 phydev->supported, val & ESTATUS_1000_THALF);
2789 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
2790 phydev->supported, val & ESTATUS_1000_XFULL);
2791 }
2792
2793 /* This is optional functionality. If not supported, we may get an error
2794 * which should be ignored.
2795 */
2796 genphy_c45_read_eee_abilities(phydev);
2797
2798 return 0;
2799}
2800EXPORT_SYMBOL(genphy_read_abilities);
2801
2802/* This is used for the phy device which doesn't support the MMD extended
2803 * register access, but it does have side effect when we are trying to access
2804 * the MMD register via indirect method.
2805 */
2806int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
2807{
2808 return -EOPNOTSUPP;
2809}
2810EXPORT_SYMBOL(genphy_read_mmd_unsupported);
2811
2812int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
2813 u16 regnum, u16 val)
2814{
2815 return -EOPNOTSUPP;
2816}
2817EXPORT_SYMBOL(genphy_write_mmd_unsupported);
2818
2819int genphy_suspend(struct phy_device *phydev)
2820{
2821 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
2822}
2823EXPORT_SYMBOL(genphy_suspend);
2824
2825int genphy_resume(struct phy_device *phydev)
2826{
2827 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
2828}
2829EXPORT_SYMBOL(genphy_resume);
2830
2831int genphy_loopback(struct phy_device *phydev, bool enable)
2832{
2833 if (enable) {
2834 u16 ctl = BMCR_LOOPBACK;
2835 int ret, val;
2836
2837 ctl |= mii_bmcr_encode_fixed(phydev->speed, phydev->duplex);
2838
2839 phy_modify(phydev, MII_BMCR, ~0, ctl);
2840
2841 ret = phy_read_poll_timeout(phydev, MII_BMSR, val,
2842 val & BMSR_LSTATUS,
2843 5000, 500000, true);
2844 if (ret)
2845 return ret;
2846 } else {
2847 phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK, 0);
2848
2849 phy_config_aneg(phydev);
2850 }
2851
2852 return 0;
2853}
2854EXPORT_SYMBOL(genphy_loopback);
2855
2856/**
2857 * phy_remove_link_mode - Remove a supported link mode
2858 * @phydev: phy_device structure to remove link mode from
2859 * @link_mode: Link mode to be removed
2860 *
2861 * Description: Some MACs don't support all link modes which the PHY
2862 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2863 * to remove a link mode.
2864 */
2865void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2866{
2867 linkmode_clear_bit(link_mode, phydev->supported);
2868 phy_advertise_supported(phydev);
2869}
2870EXPORT_SYMBOL(phy_remove_link_mode);
2871
2872static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2873{
2874 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2875 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2876 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2877 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2878}
2879
2880/**
2881 * phy_advertise_supported - Advertise all supported modes
2882 * @phydev: target phy_device struct
2883 *
2884 * Description: Called to advertise all supported modes, doesn't touch
2885 * pause mode advertising.
2886 */
2887void phy_advertise_supported(struct phy_device *phydev)
2888{
2889 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2890
2891 linkmode_copy(new, phydev->supported);
2892 phy_copy_pause_bits(new, phydev->advertising);
2893 linkmode_copy(phydev->advertising, new);
2894}
2895EXPORT_SYMBOL(phy_advertise_supported);
2896
2897/**
2898 * phy_advertise_eee_all - Advertise all supported EEE modes
2899 * @phydev: target phy_device struct
2900 *
2901 * Description: Per default phylib preserves the EEE advertising at the time of
2902 * phy probing, which might be a subset of the supported EEE modes. Use this
2903 * function when all supported EEE modes should be advertised. This does not
2904 * trigger auto-negotiation, so must be called before phy_start()/
2905 * phylink_start() which will start auto-negotiation.
2906 */
2907void phy_advertise_eee_all(struct phy_device *phydev)
2908{
2909 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);
2910}
2911EXPORT_SYMBOL_GPL(phy_advertise_eee_all);
2912
2913/**
2914 * phy_support_eee - Set initial EEE policy configuration
2915 * @phydev: Target phy_device struct
2916 *
2917 * This function configures the initial policy for Energy Efficient Ethernet
2918 * (EEE) on the specified PHY device, influencing that EEE capabilities are
2919 * advertised before the link is established. It should be called during PHY
2920 * registration by the MAC driver and/or the PHY driver (for SmartEEE PHYs)
2921 * if MAC supports LPI or PHY is capable to compensate missing LPI functionality
2922 * of the MAC.
2923 *
2924 * The function sets default EEE policy parameters, including preparing the PHY
2925 * to advertise EEE capabilities based on hardware support.
2926 *
2927 * It also sets the expected configuration for Low Power Idle (LPI) in the MAC
2928 * driver. If the PHY framework determines that both local and remote
2929 * advertisements support EEE, and the negotiated link mode is compatible with
2930 * EEE, it will set enable_tx_lpi = true. The MAC driver is expected to act on
2931 * this setting by enabling the LPI timer if enable_tx_lpi is set.
2932 */
2933void phy_support_eee(struct phy_device *phydev)
2934{
2935 linkmode_copy(phydev->advertising_eee, phydev->supported_eee);
2936 phydev->eee_cfg.tx_lpi_enabled = true;
2937 phydev->eee_cfg.eee_enabled = true;
2938}
2939EXPORT_SYMBOL(phy_support_eee);
2940
2941/**
2942 * phy_support_sym_pause - Enable support of symmetrical pause
2943 * @phydev: target phy_device struct
2944 *
2945 * Description: Called by the MAC to indicate is supports symmetrical
2946 * Pause, but not asym pause.
2947 */
2948void phy_support_sym_pause(struct phy_device *phydev)
2949{
2950 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2951 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2952}
2953EXPORT_SYMBOL(phy_support_sym_pause);
2954
2955/**
2956 * phy_support_asym_pause - Enable support of asym pause
2957 * @phydev: target phy_device struct
2958 *
2959 * Description: Called by the MAC to indicate is supports Asym Pause.
2960 */
2961void phy_support_asym_pause(struct phy_device *phydev)
2962{
2963 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2964}
2965EXPORT_SYMBOL(phy_support_asym_pause);
2966
2967/**
2968 * phy_set_sym_pause - Configure symmetric Pause
2969 * @phydev: target phy_device struct
2970 * @rx: Receiver Pause is supported
2971 * @tx: Transmit Pause is supported
2972 * @autoneg: Auto neg should be used
2973 *
2974 * Description: Configure advertised Pause support depending on if
2975 * receiver pause and pause auto neg is supported. Generally called
2976 * from the set_pauseparam .ndo.
2977 */
2978void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2979 bool autoneg)
2980{
2981 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2982
2983 if (rx && tx && autoneg)
2984 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2985 phydev->supported);
2986
2987 linkmode_copy(phydev->advertising, phydev->supported);
2988}
2989EXPORT_SYMBOL(phy_set_sym_pause);
2990
2991/**
2992 * phy_set_asym_pause - Configure Pause and Asym Pause
2993 * @phydev: target phy_device struct
2994 * @rx: Receiver Pause is supported
2995 * @tx: Transmit Pause is supported
2996 *
2997 * Description: Configure advertised Pause support depending on if
2998 * transmit and receiver pause is supported. If there has been a
2999 * change in adverting, trigger a new autoneg. Generally called from
3000 * the set_pauseparam .ndo.
3001 */
3002void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
3003{
3004 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
3005
3006 linkmode_copy(oldadv, phydev->advertising);
3007 linkmode_set_pause(phydev->advertising, tx, rx);
3008
3009 if (!linkmode_equal(oldadv, phydev->advertising) &&
3010 phydev->autoneg)
3011 phy_start_aneg(phydev);
3012}
3013EXPORT_SYMBOL(phy_set_asym_pause);
3014
3015/**
3016 * phy_validate_pause - Test if the PHY/MAC support the pause configuration
3017 * @phydev: phy_device struct
3018 * @pp: requested pause configuration
3019 *
3020 * Description: Test if the PHY/MAC combination supports the Pause
3021 * configuration the user is requesting. Returns True if it is
3022 * supported, false otherwise.
3023 */
3024bool phy_validate_pause(struct phy_device *phydev,
3025 struct ethtool_pauseparam *pp)
3026{
3027 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3028 phydev->supported) && pp->rx_pause)
3029 return false;
3030
3031 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3032 phydev->supported) &&
3033 pp->rx_pause != pp->tx_pause)
3034 return false;
3035
3036 return true;
3037}
3038EXPORT_SYMBOL(phy_validate_pause);
3039
3040/**
3041 * phy_get_pause - resolve negotiated pause modes
3042 * @phydev: phy_device struct
3043 * @tx_pause: pointer to bool to indicate whether transmit pause should be
3044 * enabled.
3045 * @rx_pause: pointer to bool to indicate whether receive pause should be
3046 * enabled.
3047 *
3048 * Resolve and return the flow control modes according to the negotiation
3049 * result. This includes checking that we are operating in full duplex mode.
3050 * See linkmode_resolve_pause() for further details.
3051 */
3052void phy_get_pause(struct phy_device *phydev, bool *tx_pause, bool *rx_pause)
3053{
3054 if (phydev->duplex != DUPLEX_FULL) {
3055 *tx_pause = false;
3056 *rx_pause = false;
3057 return;
3058 }
3059
3060 return linkmode_resolve_pause(phydev->advertising,
3061 phydev->lp_advertising,
3062 tx_pause, rx_pause);
3063}
3064EXPORT_SYMBOL(phy_get_pause);
3065
3066#if IS_ENABLED(CONFIG_OF_MDIO)
3067static int phy_get_int_delay_property(struct device *dev, const char *name)
3068{
3069 s32 int_delay;
3070 int ret;
3071
3072 ret = device_property_read_u32(dev, name, &int_delay);
3073 if (ret)
3074 return ret;
3075
3076 return int_delay;
3077}
3078#else
3079static int phy_get_int_delay_property(struct device *dev, const char *name)
3080{
3081 return -EINVAL;
3082}
3083#endif
3084
3085/**
3086 * phy_get_internal_delay - returns the index of the internal delay
3087 * @phydev: phy_device struct
3088 * @dev: pointer to the devices device struct
3089 * @delay_values: array of delays the PHY supports
3090 * @size: the size of the delay array
3091 * @is_rx: boolean to indicate to get the rx internal delay
3092 *
3093 * Returns the index within the array of internal delay passed in.
3094 * If the device property is not present then the interface type is checked
3095 * if the interface defines use of internal delay then a 1 is returned otherwise
3096 * a 0 is returned.
3097 * The array must be in ascending order. If PHY does not have an ascending order
3098 * array then size = 0 and the value of the delay property is returned.
3099 * Return -EINVAL if the delay is invalid or cannot be found.
3100 */
3101s32 phy_get_internal_delay(struct phy_device *phydev, struct device *dev,
3102 const int *delay_values, int size, bool is_rx)
3103{
3104 s32 delay;
3105 int i;
3106
3107 if (is_rx) {
3108 delay = phy_get_int_delay_property(dev, "rx-internal-delay-ps");
3109 if (delay < 0 && size == 0) {
3110 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3111 phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
3112 return 1;
3113 else
3114 return 0;
3115 }
3116
3117 } else {
3118 delay = phy_get_int_delay_property(dev, "tx-internal-delay-ps");
3119 if (delay < 0 && size == 0) {
3120 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID ||
3121 phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
3122 return 1;
3123 else
3124 return 0;
3125 }
3126 }
3127
3128 if (delay < 0)
3129 return delay;
3130
3131 if (size == 0)
3132 return delay;
3133
3134 if (delay < delay_values[0] || delay > delay_values[size - 1]) {
3135 phydev_err(phydev, "Delay %d is out of range\n", delay);
3136 return -EINVAL;
3137 }
3138
3139 if (delay == delay_values[0])
3140 return 0;
3141
3142 for (i = 1; i < size; i++) {
3143 if (delay == delay_values[i])
3144 return i;
3145
3146 /* Find an approximate index by looking up the table */
3147 if (delay > delay_values[i - 1] &&
3148 delay < delay_values[i]) {
3149 if (delay - delay_values[i - 1] <
3150 delay_values[i] - delay)
3151 return i - 1;
3152 else
3153 return i;
3154 }
3155 }
3156
3157 phydev_err(phydev, "error finding internal delay index for %d\n",
3158 delay);
3159
3160 return -EINVAL;
3161}
3162EXPORT_SYMBOL(phy_get_internal_delay);
3163
3164static int phy_led_set_brightness(struct led_classdev *led_cdev,
3165 enum led_brightness value)
3166{
3167 struct phy_led *phyled = to_phy_led(led_cdev);
3168 struct phy_device *phydev = phyled->phydev;
3169 int err;
3170
3171 mutex_lock(&phydev->lock);
3172 err = phydev->drv->led_brightness_set(phydev, phyled->index, value);
3173 mutex_unlock(&phydev->lock);
3174
3175 return err;
3176}
3177
3178static int phy_led_blink_set(struct led_classdev *led_cdev,
3179 unsigned long *delay_on,
3180 unsigned long *delay_off)
3181{
3182 struct phy_led *phyled = to_phy_led(led_cdev);
3183 struct phy_device *phydev = phyled->phydev;
3184 int err;
3185
3186 mutex_lock(&phydev->lock);
3187 err = phydev->drv->led_blink_set(phydev, phyled->index,
3188 delay_on, delay_off);
3189 mutex_unlock(&phydev->lock);
3190
3191 return err;
3192}
3193
3194static __maybe_unused struct device *
3195phy_led_hw_control_get_device(struct led_classdev *led_cdev)
3196{
3197 struct phy_led *phyled = to_phy_led(led_cdev);
3198 struct phy_device *phydev = phyled->phydev;
3199
3200 if (phydev->attached_dev)
3201 return &phydev->attached_dev->dev;
3202 return NULL;
3203}
3204
3205static int __maybe_unused
3206phy_led_hw_control_get(struct led_classdev *led_cdev,
3207 unsigned long *rules)
3208{
3209 struct phy_led *phyled = to_phy_led(led_cdev);
3210 struct phy_device *phydev = phyled->phydev;
3211 int err;
3212
3213 mutex_lock(&phydev->lock);
3214 err = phydev->drv->led_hw_control_get(phydev, phyled->index, rules);
3215 mutex_unlock(&phydev->lock);
3216
3217 return err;
3218}
3219
3220static int __maybe_unused
3221phy_led_hw_control_set(struct led_classdev *led_cdev,
3222 unsigned long rules)
3223{
3224 struct phy_led *phyled = to_phy_led(led_cdev);
3225 struct phy_device *phydev = phyled->phydev;
3226 int err;
3227
3228 mutex_lock(&phydev->lock);
3229 err = phydev->drv->led_hw_control_set(phydev, phyled->index, rules);
3230 mutex_unlock(&phydev->lock);
3231
3232 return err;
3233}
3234
3235static __maybe_unused int phy_led_hw_is_supported(struct led_classdev *led_cdev,
3236 unsigned long rules)
3237{
3238 struct phy_led *phyled = to_phy_led(led_cdev);
3239 struct phy_device *phydev = phyled->phydev;
3240 int err;
3241
3242 mutex_lock(&phydev->lock);
3243 err = phydev->drv->led_hw_is_supported(phydev, phyled->index, rules);
3244 mutex_unlock(&phydev->lock);
3245
3246 return err;
3247}
3248
3249static void phy_leds_unregister(struct phy_device *phydev)
3250{
3251 struct phy_led *phyled;
3252
3253 list_for_each_entry(phyled, &phydev->leds, list) {
3254 led_classdev_unregister(&phyled->led_cdev);
3255 }
3256}
3257
3258static int of_phy_led(struct phy_device *phydev,
3259 struct device_node *led)
3260{
3261 struct device *dev = &phydev->mdio.dev;
3262 struct led_init_data init_data = {};
3263 struct led_classdev *cdev;
3264 unsigned long modes = 0;
3265 struct phy_led *phyled;
3266 u32 index;
3267 int err;
3268
3269 phyled = devm_kzalloc(dev, sizeof(*phyled), GFP_KERNEL);
3270 if (!phyled)
3271 return -ENOMEM;
3272
3273 cdev = &phyled->led_cdev;
3274 phyled->phydev = phydev;
3275
3276 err = of_property_read_u32(led, "reg", &index);
3277 if (err)
3278 return err;
3279 if (index > U8_MAX)
3280 return -EINVAL;
3281
3282 if (of_property_read_bool(led, "active-low"))
3283 set_bit(PHY_LED_ACTIVE_LOW, &modes);
3284 if (of_property_read_bool(led, "inactive-high-impedance"))
3285 set_bit(PHY_LED_INACTIVE_HIGH_IMPEDANCE, &modes);
3286
3287 if (modes) {
3288 /* Return error if asked to set polarity modes but not supported */
3289 if (!phydev->drv->led_polarity_set)
3290 return -EINVAL;
3291
3292 err = phydev->drv->led_polarity_set(phydev, index, modes);
3293 if (err)
3294 return err;
3295 }
3296
3297 phyled->index = index;
3298 if (phydev->drv->led_brightness_set)
3299 cdev->brightness_set_blocking = phy_led_set_brightness;
3300 if (phydev->drv->led_blink_set)
3301 cdev->blink_set = phy_led_blink_set;
3302
3303#ifdef CONFIG_LEDS_TRIGGERS
3304 if (phydev->drv->led_hw_is_supported &&
3305 phydev->drv->led_hw_control_set &&
3306 phydev->drv->led_hw_control_get) {
3307 cdev->hw_control_is_supported = phy_led_hw_is_supported;
3308 cdev->hw_control_set = phy_led_hw_control_set;
3309 cdev->hw_control_get = phy_led_hw_control_get;
3310 cdev->hw_control_trigger = "netdev";
3311 }
3312
3313 cdev->hw_control_get_device = phy_led_hw_control_get_device;
3314#endif
3315 cdev->max_brightness = 1;
3316 init_data.devicename = dev_name(&phydev->mdio.dev);
3317 init_data.fwnode = of_fwnode_handle(led);
3318 init_data.devname_mandatory = true;
3319
3320 err = led_classdev_register_ext(dev, cdev, &init_data);
3321 if (err)
3322 return err;
3323
3324 list_add(&phyled->list, &phydev->leds);
3325
3326 return 0;
3327}
3328
3329static int of_phy_leds(struct phy_device *phydev)
3330{
3331 struct device_node *node = phydev->mdio.dev.of_node;
3332 struct device_node *leds, *led;
3333 int err;
3334
3335 if (!IS_ENABLED(CONFIG_OF_MDIO))
3336 return 0;
3337
3338 if (!node)
3339 return 0;
3340
3341 leds = of_get_child_by_name(node, "leds");
3342 if (!leds)
3343 return 0;
3344
3345 for_each_available_child_of_node(leds, led) {
3346 err = of_phy_led(phydev, led);
3347 if (err) {
3348 of_node_put(led);
3349 phy_leds_unregister(phydev);
3350 return err;
3351 }
3352 }
3353
3354 return 0;
3355}
3356
3357/**
3358 * fwnode_mdio_find_device - Given a fwnode, find the mdio_device
3359 * @fwnode: pointer to the mdio_device's fwnode
3360 *
3361 * If successful, returns a pointer to the mdio_device with the embedded
3362 * struct device refcount incremented by one, or NULL on failure.
3363 * The caller should call put_device() on the mdio_device after its use.
3364 */
3365struct mdio_device *fwnode_mdio_find_device(struct fwnode_handle *fwnode)
3366{
3367 struct device *d;
3368
3369 if (!fwnode)
3370 return NULL;
3371
3372 d = bus_find_device_by_fwnode(&mdio_bus_type, fwnode);
3373 if (!d)
3374 return NULL;
3375
3376 return to_mdio_device(d);
3377}
3378EXPORT_SYMBOL(fwnode_mdio_find_device);
3379
3380/**
3381 * fwnode_phy_find_device - For provided phy_fwnode, find phy_device.
3382 *
3383 * @phy_fwnode: Pointer to the phy's fwnode.
3384 *
3385 * If successful, returns a pointer to the phy_device with the embedded
3386 * struct device refcount incremented by one, or NULL on failure.
3387 */
3388struct phy_device *fwnode_phy_find_device(struct fwnode_handle *phy_fwnode)
3389{
3390 struct mdio_device *mdiodev;
3391
3392 mdiodev = fwnode_mdio_find_device(phy_fwnode);
3393 if (!mdiodev)
3394 return NULL;
3395
3396 if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
3397 return to_phy_device(&mdiodev->dev);
3398
3399 put_device(&mdiodev->dev);
3400
3401 return NULL;
3402}
3403EXPORT_SYMBOL(fwnode_phy_find_device);
3404
3405/**
3406 * device_phy_find_device - For the given device, get the phy_device
3407 * @dev: Pointer to the given device
3408 *
3409 * Refer return conditions of fwnode_phy_find_device().
3410 */
3411struct phy_device *device_phy_find_device(struct device *dev)
3412{
3413 return fwnode_phy_find_device(dev_fwnode(dev));
3414}
3415EXPORT_SYMBOL_GPL(device_phy_find_device);
3416
3417/**
3418 * fwnode_get_phy_node - Get the phy_node using the named reference.
3419 * @fwnode: Pointer to fwnode from which phy_node has to be obtained.
3420 *
3421 * Refer return conditions of fwnode_find_reference().
3422 * For ACPI, only "phy-handle" is supported. Legacy DT properties "phy"
3423 * and "phy-device" are not supported in ACPI. DT supports all the three
3424 * named references to the phy node.
3425 */
3426struct fwnode_handle *fwnode_get_phy_node(const struct fwnode_handle *fwnode)
3427{
3428 struct fwnode_handle *phy_node;
3429
3430 /* Only phy-handle is used for ACPI */
3431 phy_node = fwnode_find_reference(fwnode, "phy-handle", 0);
3432 if (is_acpi_node(fwnode) || !IS_ERR(phy_node))
3433 return phy_node;
3434 phy_node = fwnode_find_reference(fwnode, "phy", 0);
3435 if (IS_ERR(phy_node))
3436 phy_node = fwnode_find_reference(fwnode, "phy-device", 0);
3437 return phy_node;
3438}
3439EXPORT_SYMBOL_GPL(fwnode_get_phy_node);
3440
3441/**
3442 * phy_probe - probe and init a PHY device
3443 * @dev: device to probe and init
3444 *
3445 * Take care of setting up the phy_device structure, set the state to READY.
3446 */
3447static int phy_probe(struct device *dev)
3448{
3449 struct phy_device *phydev = to_phy_device(dev);
3450 struct device_driver *drv = phydev->mdio.dev.driver;
3451 struct phy_driver *phydrv = to_phy_driver(drv);
3452 int err = 0;
3453
3454 phydev->drv = phydrv;
3455
3456 /* Disable the interrupt if the PHY doesn't support it
3457 * but the interrupt is still a valid one
3458 */
3459 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
3460 phydev->irq = PHY_POLL;
3461
3462 if (phydrv->flags & PHY_IS_INTERNAL)
3463 phydev->is_internal = true;
3464
3465 /* Deassert the reset signal */
3466 phy_device_reset(phydev, 0);
3467
3468 if (phydev->drv->probe) {
3469 err = phydev->drv->probe(phydev);
3470 if (err)
3471 goto out;
3472 }
3473
3474 phy_disable_interrupts(phydev);
3475
3476 /* Start out supporting everything. Eventually,
3477 * a controller will attach, and may modify one
3478 * or both of these values
3479 */
3480 if (phydrv->features) {
3481 linkmode_copy(phydev->supported, phydrv->features);
3482 genphy_c45_read_eee_abilities(phydev);
3483 }
3484 else if (phydrv->get_features)
3485 err = phydrv->get_features(phydev);
3486 else if (phydev->is_c45)
3487 err = genphy_c45_pma_read_abilities(phydev);
3488 else
3489 err = genphy_read_abilities(phydev);
3490
3491 if (err)
3492 goto out;
3493
3494 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
3495 phydev->supported))
3496 phydev->autoneg = 0;
3497
3498 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
3499 phydev->supported))
3500 phydev->is_gigabit_capable = 1;
3501 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
3502 phydev->supported))
3503 phydev->is_gigabit_capable = 1;
3504
3505 of_set_phy_supported(phydev);
3506 phy_advertise_supported(phydev);
3507
3508 /* Get PHY default EEE advertising modes and handle them as potentially
3509 * safe initial configuration.
3510 */
3511 err = genphy_c45_read_eee_adv(phydev, phydev->advertising_eee);
3512 if (err)
3513 goto out;
3514
3515 /* There is no "enabled" flag. If PHY is advertising, assume it is
3516 * kind of enabled.
3517 */
3518 phydev->eee_enabled = !linkmode_empty(phydev->advertising_eee);
3519
3520 /* Some PHYs may advertise, by default, not support EEE modes. So,
3521 * we need to clean them.
3522 */
3523 if (phydev->eee_enabled)
3524 linkmode_and(phydev->advertising_eee, phydev->supported_eee,
3525 phydev->advertising_eee);
3526
3527 /* Get the EEE modes we want to prohibit. We will ask
3528 * the PHY stop advertising these mode later on
3529 */
3530 of_set_phy_eee_broken(phydev);
3531
3532 /* The Pause Frame bits indicate that the PHY can support passing
3533 * pause frames. During autonegotiation, the PHYs will determine if
3534 * they should allow pause frames to pass. The MAC driver should then
3535 * use that result to determine whether to enable flow control via
3536 * pause frames.
3537 *
3538 * Normally, PHY drivers should not set the Pause bits, and instead
3539 * allow phylib to do that. However, there may be some situations
3540 * (e.g. hardware erratum) where the driver wants to set only one
3541 * of these bits.
3542 */
3543 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
3544 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
3545 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3546 phydev->supported);
3547 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3548 phydev->supported);
3549 }
3550
3551 /* Set the state to READY by default */
3552 phydev->state = PHY_READY;
3553
3554 /* Get the LEDs from the device tree, and instantiate standard
3555 * LEDs for them.
3556 */
3557 if (IS_ENABLED(CONFIG_PHYLIB_LEDS))
3558 err = of_phy_leds(phydev);
3559
3560out:
3561 /* Re-assert the reset signal on error */
3562 if (err)
3563 phy_device_reset(phydev, 1);
3564
3565 return err;
3566}
3567
3568static int phy_remove(struct device *dev)
3569{
3570 struct phy_device *phydev = to_phy_device(dev);
3571
3572 cancel_delayed_work_sync(&phydev->state_queue);
3573
3574 if (IS_ENABLED(CONFIG_PHYLIB_LEDS))
3575 phy_leds_unregister(phydev);
3576
3577 phydev->state = PHY_DOWN;
3578
3579 sfp_bus_del_upstream(phydev->sfp_bus);
3580 phydev->sfp_bus = NULL;
3581
3582 if (phydev->drv && phydev->drv->remove)
3583 phydev->drv->remove(phydev);
3584
3585 /* Assert the reset signal */
3586 phy_device_reset(phydev, 1);
3587
3588 phydev->drv = NULL;
3589
3590 return 0;
3591}
3592
3593/**
3594 * phy_driver_register - register a phy_driver with the PHY layer
3595 * @new_driver: new phy_driver to register
3596 * @owner: module owning this PHY
3597 */
3598int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
3599{
3600 int retval;
3601
3602 /* Either the features are hard coded, or dynamically
3603 * determined. It cannot be both.
3604 */
3605 if (WARN_ON(new_driver->features && new_driver->get_features)) {
3606 pr_err("%s: features and get_features must not both be set\n",
3607 new_driver->name);
3608 return -EINVAL;
3609 }
3610
3611 /* PHYLIB device drivers must not match using a DT compatible table
3612 * as this bypasses our checks that the mdiodev that is being matched
3613 * is backed by a struct phy_device. If such a case happens, we will
3614 * make out-of-bounds accesses and lockup in phydev->lock.
3615 */
3616 if (WARN(new_driver->mdiodrv.driver.of_match_table,
3617 "%s: driver must not provide a DT match table\n",
3618 new_driver->name))
3619 return -EINVAL;
3620
3621 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
3622 new_driver->mdiodrv.driver.name = new_driver->name;
3623 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
3624 new_driver->mdiodrv.driver.probe = phy_probe;
3625 new_driver->mdiodrv.driver.remove = phy_remove;
3626 new_driver->mdiodrv.driver.owner = owner;
3627 new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
3628
3629 retval = driver_register(&new_driver->mdiodrv.driver);
3630 if (retval) {
3631 pr_err("%s: Error %d in registering driver\n",
3632 new_driver->name, retval);
3633
3634 return retval;
3635 }
3636
3637 pr_debug("%s: Registered new driver\n", new_driver->name);
3638
3639 return 0;
3640}
3641EXPORT_SYMBOL(phy_driver_register);
3642
3643int phy_drivers_register(struct phy_driver *new_driver, int n,
3644 struct module *owner)
3645{
3646 int i, ret = 0;
3647
3648 for (i = 0; i < n; i++) {
3649 ret = phy_driver_register(new_driver + i, owner);
3650 if (ret) {
3651 while (i-- > 0)
3652 phy_driver_unregister(new_driver + i);
3653 break;
3654 }
3655 }
3656 return ret;
3657}
3658EXPORT_SYMBOL(phy_drivers_register);
3659
3660void phy_driver_unregister(struct phy_driver *drv)
3661{
3662 driver_unregister(&drv->mdiodrv.driver);
3663}
3664EXPORT_SYMBOL(phy_driver_unregister);
3665
3666void phy_drivers_unregister(struct phy_driver *drv, int n)
3667{
3668 int i;
3669
3670 for (i = 0; i < n; i++)
3671 phy_driver_unregister(drv + i);
3672}
3673EXPORT_SYMBOL(phy_drivers_unregister);
3674
3675static struct phy_driver genphy_driver = {
3676 .phy_id = 0xffffffff,
3677 .phy_id_mask = 0xffffffff,
3678 .name = "Generic PHY",
3679 .get_features = genphy_read_abilities,
3680 .suspend = genphy_suspend,
3681 .resume = genphy_resume,
3682 .set_loopback = genphy_loopback,
3683};
3684
3685static const struct ethtool_phy_ops phy_ethtool_phy_ops = {
3686 .get_sset_count = phy_ethtool_get_sset_count,
3687 .get_strings = phy_ethtool_get_strings,
3688 .get_stats = phy_ethtool_get_stats,
3689 .get_plca_cfg = phy_ethtool_get_plca_cfg,
3690 .set_plca_cfg = phy_ethtool_set_plca_cfg,
3691 .get_plca_status = phy_ethtool_get_plca_status,
3692 .start_cable_test = phy_start_cable_test,
3693 .start_cable_test_tdr = phy_start_cable_test_tdr,
3694};
3695
3696static const struct phylib_stubs __phylib_stubs = {
3697 .hwtstamp_get = __phy_hwtstamp_get,
3698 .hwtstamp_set = __phy_hwtstamp_set,
3699};
3700
3701static void phylib_register_stubs(void)
3702{
3703 phylib_stubs = &__phylib_stubs;
3704}
3705
3706static void phylib_unregister_stubs(void)
3707{
3708 phylib_stubs = NULL;
3709}
3710
3711static int __init phy_init(void)
3712{
3713 int rc;
3714
3715 rtnl_lock();
3716 ethtool_set_ethtool_phy_ops(&phy_ethtool_phy_ops);
3717 phylib_register_stubs();
3718 rtnl_unlock();
3719
3720 rc = mdio_bus_init();
3721 if (rc)
3722 goto err_ethtool_phy_ops;
3723
3724 features_init();
3725
3726 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
3727 if (rc)
3728 goto err_mdio_bus;
3729
3730 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
3731 if (rc)
3732 goto err_c45;
3733
3734 return 0;
3735
3736err_c45:
3737 phy_driver_unregister(&genphy_c45_driver);
3738err_mdio_bus:
3739 mdio_bus_exit();
3740err_ethtool_phy_ops:
3741 rtnl_lock();
3742 phylib_unregister_stubs();
3743 ethtool_set_ethtool_phy_ops(NULL);
3744 rtnl_unlock();
3745
3746 return rc;
3747}
3748
3749static void __exit phy_exit(void)
3750{
3751 phy_driver_unregister(&genphy_c45_driver);
3752 phy_driver_unregister(&genphy_driver);
3753 mdio_bus_exit();
3754 rtnl_lock();
3755 phylib_unregister_stubs();
3756 ethtool_set_ethtool_phy_ops(NULL);
3757 rtnl_unlock();
3758}
3759
3760subsys_initcall(phy_init);
3761module_exit(phy_exit);