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