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