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