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/kernel.h>
13#include <linux/string.h>
14#include <linux/errno.h>
15#include <linux/unistd.h>
16#include <linux/slab.h>
17#include <linux/interrupt.h>
18#include <linux/init.h>
19#include <linux/delay.h>
20#include <linux/netdevice.h>
21#include <linux/etherdevice.h>
22#include <linux/skbuff.h>
23#include <linux/mm.h>
24#include <linux/module.h>
25#include <linux/mii.h>
26#include <linux/ethtool.h>
27#include <linux/bitmap.h>
28#include <linux/phy.h>
29#include <linux/phy_led_triggers.h>
30#include <linux/mdio.h>
31#include <linux/io.h>
32#include <linux/uaccess.h>
33
34MODULE_DESCRIPTION("PHY library");
35MODULE_AUTHOR("Andy Fleming");
36MODULE_LICENSE("GPL");
37
38__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
39EXPORT_SYMBOL_GPL(phy_basic_features);
40
41__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
42EXPORT_SYMBOL_GPL(phy_basic_t1_features);
43
44__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
45EXPORT_SYMBOL_GPL(phy_gbit_features);
46
47__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
48EXPORT_SYMBOL_GPL(phy_gbit_fibre_features);
49
50__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
51EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
52
53__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
54EXPORT_SYMBOL_GPL(phy_10gbit_features);
55
56__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
57EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
58
59const int phy_basic_ports_array[3] = {
60 ETHTOOL_LINK_MODE_Autoneg_BIT,
61 ETHTOOL_LINK_MODE_TP_BIT,
62 ETHTOOL_LINK_MODE_MII_BIT,
63};
64EXPORT_SYMBOL_GPL(phy_basic_ports_array);
65
66const int phy_fibre_port_array[1] = {
67 ETHTOOL_LINK_MODE_FIBRE_BIT,
68};
69EXPORT_SYMBOL_GPL(phy_fibre_port_array);
70
71const int phy_all_ports_features_array[7] = {
72 ETHTOOL_LINK_MODE_Autoneg_BIT,
73 ETHTOOL_LINK_MODE_TP_BIT,
74 ETHTOOL_LINK_MODE_MII_BIT,
75 ETHTOOL_LINK_MODE_FIBRE_BIT,
76 ETHTOOL_LINK_MODE_AUI_BIT,
77 ETHTOOL_LINK_MODE_BNC_BIT,
78 ETHTOOL_LINK_MODE_Backplane_BIT,
79};
80EXPORT_SYMBOL_GPL(phy_all_ports_features_array);
81
82const int phy_10_100_features_array[4] = {
83 ETHTOOL_LINK_MODE_10baseT_Half_BIT,
84 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
85 ETHTOOL_LINK_MODE_100baseT_Half_BIT,
86 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
87};
88EXPORT_SYMBOL_GPL(phy_10_100_features_array);
89
90const int phy_basic_t1_features_array[2] = {
91 ETHTOOL_LINK_MODE_TP_BIT,
92 ETHTOOL_LINK_MODE_100baseT1_Full_BIT,
93};
94EXPORT_SYMBOL_GPL(phy_basic_t1_features_array);
95
96const int phy_gbit_features_array[2] = {
97 ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
98 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
99};
100EXPORT_SYMBOL_GPL(phy_gbit_features_array);
101
102const int phy_10gbit_features_array[1] = {
103 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
104};
105EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
106
107const int phy_10gbit_fec_features_array[1] = {
108 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
109};
110EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
111
112__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
113EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
114
115static const int phy_10gbit_full_features_array[] = {
116 ETHTOOL_LINK_MODE_10baseT_Full_BIT,
117 ETHTOOL_LINK_MODE_100baseT_Full_BIT,
118 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
119 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
120};
121
122static void features_init(void)
123{
124 /* 10/100 half/full*/
125 linkmode_set_bit_array(phy_basic_ports_array,
126 ARRAY_SIZE(phy_basic_ports_array),
127 phy_basic_features);
128 linkmode_set_bit_array(phy_10_100_features_array,
129 ARRAY_SIZE(phy_10_100_features_array),
130 phy_basic_features);
131
132 /* 100 full, TP */
133 linkmode_set_bit_array(phy_basic_t1_features_array,
134 ARRAY_SIZE(phy_basic_t1_features_array),
135 phy_basic_t1_features);
136
137 /* 10/100 half/full + 1000 half/full */
138 linkmode_set_bit_array(phy_basic_ports_array,
139 ARRAY_SIZE(phy_basic_ports_array),
140 phy_gbit_features);
141 linkmode_set_bit_array(phy_10_100_features_array,
142 ARRAY_SIZE(phy_10_100_features_array),
143 phy_gbit_features);
144 linkmode_set_bit_array(phy_gbit_features_array,
145 ARRAY_SIZE(phy_gbit_features_array),
146 phy_gbit_features);
147
148 /* 10/100 half/full + 1000 half/full + fibre*/
149 linkmode_set_bit_array(phy_basic_ports_array,
150 ARRAY_SIZE(phy_basic_ports_array),
151 phy_gbit_fibre_features);
152 linkmode_set_bit_array(phy_10_100_features_array,
153 ARRAY_SIZE(phy_10_100_features_array),
154 phy_gbit_fibre_features);
155 linkmode_set_bit_array(phy_gbit_features_array,
156 ARRAY_SIZE(phy_gbit_features_array),
157 phy_gbit_fibre_features);
158 linkmode_set_bit_array(phy_fibre_port_array,
159 ARRAY_SIZE(phy_fibre_port_array),
160 phy_gbit_fibre_features);
161
162 /* 10/100 half/full + 1000 half/full + TP/MII/FIBRE/AUI/BNC/Backplane*/
163 linkmode_set_bit_array(phy_all_ports_features_array,
164 ARRAY_SIZE(phy_all_ports_features_array),
165 phy_gbit_all_ports_features);
166 linkmode_set_bit_array(phy_10_100_features_array,
167 ARRAY_SIZE(phy_10_100_features_array),
168 phy_gbit_all_ports_features);
169 linkmode_set_bit_array(phy_gbit_features_array,
170 ARRAY_SIZE(phy_gbit_features_array),
171 phy_gbit_all_ports_features);
172
173 /* 10/100 half/full + 1000 half/full + 10G full*/
174 linkmode_set_bit_array(phy_all_ports_features_array,
175 ARRAY_SIZE(phy_all_ports_features_array),
176 phy_10gbit_features);
177 linkmode_set_bit_array(phy_10_100_features_array,
178 ARRAY_SIZE(phy_10_100_features_array),
179 phy_10gbit_features);
180 linkmode_set_bit_array(phy_gbit_features_array,
181 ARRAY_SIZE(phy_gbit_features_array),
182 phy_10gbit_features);
183 linkmode_set_bit_array(phy_10gbit_features_array,
184 ARRAY_SIZE(phy_10gbit_features_array),
185 phy_10gbit_features);
186
187 /* 10/100/1000/10G full */
188 linkmode_set_bit_array(phy_all_ports_features_array,
189 ARRAY_SIZE(phy_all_ports_features_array),
190 phy_10gbit_full_features);
191 linkmode_set_bit_array(phy_10gbit_full_features_array,
192 ARRAY_SIZE(phy_10gbit_full_features_array),
193 phy_10gbit_full_features);
194 /* 10G FEC only */
195 linkmode_set_bit_array(phy_10gbit_fec_features_array,
196 ARRAY_SIZE(phy_10gbit_fec_features_array),
197 phy_10gbit_fec_features);
198}
199
200void phy_device_free(struct phy_device *phydev)
201{
202 put_device(&phydev->mdio.dev);
203}
204EXPORT_SYMBOL(phy_device_free);
205
206static void phy_mdio_device_free(struct mdio_device *mdiodev)
207{
208 struct phy_device *phydev;
209
210 phydev = container_of(mdiodev, struct phy_device, mdio);
211 phy_device_free(phydev);
212}
213
214static void phy_device_release(struct device *dev)
215{
216 kfree(to_phy_device(dev));
217}
218
219static void phy_mdio_device_remove(struct mdio_device *mdiodev)
220{
221 struct phy_device *phydev;
222
223 phydev = container_of(mdiodev, struct phy_device, mdio);
224 phy_device_remove(phydev);
225}
226
227static struct phy_driver genphy_driver;
228extern struct phy_driver genphy_c45_driver;
229
230static LIST_HEAD(phy_fixup_list);
231static DEFINE_MUTEX(phy_fixup_lock);
232
233#ifdef CONFIG_PM
234static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
235{
236 struct device_driver *drv = phydev->mdio.dev.driver;
237 struct phy_driver *phydrv = to_phy_driver(drv);
238 struct net_device *netdev = phydev->attached_dev;
239
240 if (!drv || !phydrv->suspend)
241 return false;
242
243 /* PHY not attached? May suspend if the PHY has not already been
244 * suspended as part of a prior call to phy_disconnect() ->
245 * phy_detach() -> phy_suspend() because the parent netdev might be the
246 * MDIO bus driver and clock gated at this point.
247 */
248 if (!netdev)
249 return !phydev->suspended;
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
269 return true;
270}
271
272static int mdio_bus_phy_suspend(struct device *dev)
273{
274 struct phy_device *phydev = to_phy_device(dev);
275
276 /* We must stop the state machine manually, otherwise it stops out of
277 * control, possibly with the phydev->lock held. Upon resume, netdev
278 * may call phy routines that try to grab the same lock, and that may
279 * lead to a deadlock.
280 */
281 if (phydev->attached_dev && phydev->adjust_link)
282 phy_stop_machine(phydev);
283
284 if (!mdio_bus_phy_may_suspend(phydev))
285 return 0;
286
287 return phy_suspend(phydev);
288}
289
290static int mdio_bus_phy_resume(struct device *dev)
291{
292 struct phy_device *phydev = to_phy_device(dev);
293 int ret;
294
295 if (!mdio_bus_phy_may_suspend(phydev))
296 goto no_resume;
297
298 ret = phy_resume(phydev);
299 if (ret < 0)
300 return ret;
301
302no_resume:
303 if (phydev->attached_dev && phydev->adjust_link)
304 phy_start_machine(phydev);
305
306 return 0;
307}
308
309static int mdio_bus_phy_restore(struct device *dev)
310{
311 struct phy_device *phydev = to_phy_device(dev);
312 struct net_device *netdev = phydev->attached_dev;
313 int ret;
314
315 if (!netdev)
316 return 0;
317
318 ret = phy_init_hw(phydev);
319 if (ret < 0)
320 return ret;
321
322 if (phydev->attached_dev && phydev->adjust_link)
323 phy_start_machine(phydev);
324
325 return 0;
326}
327
328static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
329 .suspend = mdio_bus_phy_suspend,
330 .resume = mdio_bus_phy_resume,
331 .freeze = mdio_bus_phy_suspend,
332 .thaw = mdio_bus_phy_resume,
333 .restore = mdio_bus_phy_restore,
334};
335
336#define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
337
338#else
339
340#define MDIO_BUS_PHY_PM_OPS NULL
341
342#endif /* CONFIG_PM */
343
344/**
345 * phy_register_fixup - creates a new phy_fixup and adds it to the list
346 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
347 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
348 * It can also be PHY_ANY_UID
349 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
350 * comparison
351 * @run: The actual code to be run when a matching PHY is found
352 */
353int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
354 int (*run)(struct phy_device *))
355{
356 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
357
358 if (!fixup)
359 return -ENOMEM;
360
361 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
362 fixup->phy_uid = phy_uid;
363 fixup->phy_uid_mask = phy_uid_mask;
364 fixup->run = run;
365
366 mutex_lock(&phy_fixup_lock);
367 list_add_tail(&fixup->list, &phy_fixup_list);
368 mutex_unlock(&phy_fixup_lock);
369
370 return 0;
371}
372EXPORT_SYMBOL(phy_register_fixup);
373
374/* Registers a fixup to be run on any PHY with the UID in phy_uid */
375int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
376 int (*run)(struct phy_device *))
377{
378 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
379}
380EXPORT_SYMBOL(phy_register_fixup_for_uid);
381
382/* Registers a fixup to be run on the PHY with id string bus_id */
383int phy_register_fixup_for_id(const char *bus_id,
384 int (*run)(struct phy_device *))
385{
386 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
387}
388EXPORT_SYMBOL(phy_register_fixup_for_id);
389
390/**
391 * phy_unregister_fixup - remove a phy_fixup from the list
392 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
393 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
394 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
395 */
396int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
397{
398 struct list_head *pos, *n;
399 struct phy_fixup *fixup;
400 int ret;
401
402 ret = -ENODEV;
403
404 mutex_lock(&phy_fixup_lock);
405 list_for_each_safe(pos, n, &phy_fixup_list) {
406 fixup = list_entry(pos, struct phy_fixup, list);
407
408 if ((!strcmp(fixup->bus_id, bus_id)) &&
409 ((fixup->phy_uid & phy_uid_mask) ==
410 (phy_uid & phy_uid_mask))) {
411 list_del(&fixup->list);
412 kfree(fixup);
413 ret = 0;
414 break;
415 }
416 }
417 mutex_unlock(&phy_fixup_lock);
418
419 return ret;
420}
421EXPORT_SYMBOL(phy_unregister_fixup);
422
423/* Unregisters a fixup of any PHY with the UID in phy_uid */
424int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
425{
426 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
427}
428EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
429
430/* Unregisters a fixup of the PHY with id string bus_id */
431int phy_unregister_fixup_for_id(const char *bus_id)
432{
433 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
434}
435EXPORT_SYMBOL(phy_unregister_fixup_for_id);
436
437/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
438 * Fixups can be set to match any in one or more fields.
439 */
440static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
441{
442 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
443 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
444 return 0;
445
446 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
447 (phydev->phy_id & fixup->phy_uid_mask))
448 if (fixup->phy_uid != PHY_ANY_UID)
449 return 0;
450
451 return 1;
452}
453
454/* Runs any matching fixups for this phydev */
455static int phy_scan_fixups(struct phy_device *phydev)
456{
457 struct phy_fixup *fixup;
458
459 mutex_lock(&phy_fixup_lock);
460 list_for_each_entry(fixup, &phy_fixup_list, list) {
461 if (phy_needs_fixup(phydev, fixup)) {
462 int err = fixup->run(phydev);
463
464 if (err < 0) {
465 mutex_unlock(&phy_fixup_lock);
466 return err;
467 }
468 phydev->has_fixups = true;
469 }
470 }
471 mutex_unlock(&phy_fixup_lock);
472
473 return 0;
474}
475
476static int phy_bus_match(struct device *dev, struct device_driver *drv)
477{
478 struct phy_device *phydev = to_phy_device(dev);
479 struct phy_driver *phydrv = to_phy_driver(drv);
480 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
481 int i;
482
483 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
484 return 0;
485
486 if (phydrv->match_phy_device)
487 return phydrv->match_phy_device(phydev);
488
489 if (phydev->is_c45) {
490 for (i = 1; i < num_ids; i++) {
491 if (!(phydev->c45_ids.devices_in_package & (1 << i)))
492 continue;
493
494 if ((phydrv->phy_id & phydrv->phy_id_mask) ==
495 (phydev->c45_ids.device_ids[i] &
496 phydrv->phy_id_mask))
497 return 1;
498 }
499 return 0;
500 } else {
501 return (phydrv->phy_id & phydrv->phy_id_mask) ==
502 (phydev->phy_id & phydrv->phy_id_mask);
503 }
504}
505
506static ssize_t
507phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
508{
509 struct phy_device *phydev = to_phy_device(dev);
510
511 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
512}
513static DEVICE_ATTR_RO(phy_id);
514
515static ssize_t
516phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
517{
518 struct phy_device *phydev = to_phy_device(dev);
519 const char *mode = NULL;
520
521 if (phy_is_internal(phydev))
522 mode = "internal";
523 else
524 mode = phy_modes(phydev->interface);
525
526 return sprintf(buf, "%s\n", mode);
527}
528static DEVICE_ATTR_RO(phy_interface);
529
530static ssize_t
531phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
532 char *buf)
533{
534 struct phy_device *phydev = to_phy_device(dev);
535
536 return sprintf(buf, "%d\n", phydev->has_fixups);
537}
538static DEVICE_ATTR_RO(phy_has_fixups);
539
540static struct attribute *phy_dev_attrs[] = {
541 &dev_attr_phy_id.attr,
542 &dev_attr_phy_interface.attr,
543 &dev_attr_phy_has_fixups.attr,
544 NULL,
545};
546ATTRIBUTE_GROUPS(phy_dev);
547
548static const struct device_type mdio_bus_phy_type = {
549 .name = "PHY",
550 .groups = phy_dev_groups,
551 .release = phy_device_release,
552 .pm = MDIO_BUS_PHY_PM_OPS,
553};
554
555static int phy_request_driver_module(struct phy_device *dev, int phy_id)
556{
557 int ret;
558
559 ret = request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT,
560 MDIO_ID_ARGS(phy_id));
561 /* We only check for failures in executing the usermode binary,
562 * not whether a PHY driver module exists for the PHY ID.
563 * Accept -ENOENT because this may occur in case no initramfs exists,
564 * then modprobe isn't available.
565 */
566 if (IS_ENABLED(CONFIG_MODULES) && ret < 0 && ret != -ENOENT) {
567 phydev_err(dev, "error %d loading PHY driver module for ID 0x%08x\n",
568 ret, phy_id);
569 return ret;
570 }
571
572 return 0;
573}
574
575struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
576 bool is_c45,
577 struct phy_c45_device_ids *c45_ids)
578{
579 struct phy_device *dev;
580 struct mdio_device *mdiodev;
581 int ret = 0;
582
583 /* We allocate the device, and initialize the default values */
584 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
585 if (!dev)
586 return ERR_PTR(-ENOMEM);
587
588 mdiodev = &dev->mdio;
589 mdiodev->dev.parent = &bus->dev;
590 mdiodev->dev.bus = &mdio_bus_type;
591 mdiodev->dev.type = &mdio_bus_phy_type;
592 mdiodev->bus = bus;
593 mdiodev->bus_match = phy_bus_match;
594 mdiodev->addr = addr;
595 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
596 mdiodev->device_free = phy_mdio_device_free;
597 mdiodev->device_remove = phy_mdio_device_remove;
598
599 dev->speed = 0;
600 dev->duplex = -1;
601 dev->pause = 0;
602 dev->asym_pause = 0;
603 dev->link = 0;
604 dev->interface = PHY_INTERFACE_MODE_GMII;
605
606 dev->autoneg = AUTONEG_ENABLE;
607
608 dev->is_c45 = is_c45;
609 dev->phy_id = phy_id;
610 if (c45_ids)
611 dev->c45_ids = *c45_ids;
612 dev->irq = bus->irq[addr];
613 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
614
615 dev->state = PHY_DOWN;
616
617 mutex_init(&dev->lock);
618 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
619
620 /* Request the appropriate module unconditionally; don't
621 * bother trying to do so only if it isn't already loaded,
622 * because that gets complicated. A hotplug event would have
623 * done an unconditional modprobe anyway.
624 * We don't do normal hotplug because it won't work for MDIO
625 * -- because it relies on the device staying around for long
626 * enough for the driver to get loaded. With MDIO, the NIC
627 * driver will get bored and give up as soon as it finds that
628 * there's no driver _already_ loaded.
629 */
630 if (is_c45 && c45_ids) {
631 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
632 int i;
633
634 for (i = 1; i < num_ids; i++) {
635 if (!(c45_ids->devices_in_package & (1 << i)))
636 continue;
637
638 ret = phy_request_driver_module(dev,
639 c45_ids->device_ids[i]);
640 if (ret)
641 break;
642 }
643 } else {
644 ret = phy_request_driver_module(dev, phy_id);
645 }
646
647 if (!ret) {
648 device_initialize(&mdiodev->dev);
649 } else {
650 kfree(dev);
651 dev = ERR_PTR(ret);
652 }
653
654 return dev;
655}
656EXPORT_SYMBOL(phy_device_create);
657
658/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
659 * @bus: the target MII bus
660 * @addr: PHY address on the MII bus
661 * @dev_addr: MMD address in the PHY.
662 * @devices_in_package: where to store the devices in package information.
663 *
664 * Description: reads devices in package registers of a MMD at @dev_addr
665 * from PHY at @addr on @bus.
666 *
667 * Returns: 0 on success, -EIO on failure.
668 */
669static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
670 u32 *devices_in_package)
671{
672 int phy_reg, reg_addr;
673
674 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
675 phy_reg = mdiobus_read(bus, addr, reg_addr);
676 if (phy_reg < 0)
677 return -EIO;
678 *devices_in_package = phy_reg << 16;
679
680 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
681 phy_reg = mdiobus_read(bus, addr, reg_addr);
682 if (phy_reg < 0)
683 return -EIO;
684 *devices_in_package |= phy_reg;
685
686 /* Bit 0 doesn't represent a device, it indicates c22 regs presence */
687 *devices_in_package &= ~BIT(0);
688
689 return 0;
690}
691
692/**
693 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
694 * @bus: the target MII bus
695 * @addr: PHY address on the MII bus
696 * @phy_id: where to store the ID retrieved.
697 * @c45_ids: where to store the c45 ID information.
698 *
699 * If the PHY devices-in-package appears to be valid, it and the
700 * corresponding identifiers are stored in @c45_ids, zero is stored
701 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
702 * zero on success.
703 *
704 */
705static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
706 struct phy_c45_device_ids *c45_ids) {
707 int phy_reg;
708 int i, reg_addr;
709 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
710 u32 *devs = &c45_ids->devices_in_package;
711
712 /* Find first non-zero Devices In package. Device zero is reserved
713 * for 802.3 c45 complied PHYs, so don't probe it at first.
714 */
715 for (i = 1; i < num_ids && *devs == 0; i++) {
716 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
717 if (phy_reg < 0)
718 return -EIO;
719
720 if ((*devs & 0x1fffffff) == 0x1fffffff) {
721 /* If mostly Fs, there is no device there,
722 * then let's continue to probe more, as some
723 * 10G PHYs have zero Devices In package,
724 * e.g. Cortina CS4315/CS4340 PHY.
725 */
726 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
727 if (phy_reg < 0)
728 return -EIO;
729 /* no device there, let's get out of here */
730 if ((*devs & 0x1fffffff) == 0x1fffffff) {
731 *phy_id = 0xffffffff;
732 return 0;
733 } else {
734 break;
735 }
736 }
737 }
738
739 /* Now probe Device Identifiers for each device present. */
740 for (i = 1; i < num_ids; i++) {
741 if (!(c45_ids->devices_in_package & (1 << i)))
742 continue;
743
744 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
745 phy_reg = mdiobus_read(bus, addr, reg_addr);
746 if (phy_reg < 0)
747 return -EIO;
748 c45_ids->device_ids[i] = phy_reg << 16;
749
750 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
751 phy_reg = mdiobus_read(bus, addr, reg_addr);
752 if (phy_reg < 0)
753 return -EIO;
754 c45_ids->device_ids[i] |= phy_reg;
755 }
756 *phy_id = 0;
757 return 0;
758}
759
760/**
761 * get_phy_id - reads the specified addr for its ID.
762 * @bus: the target MII bus
763 * @addr: PHY address on the MII bus
764 * @phy_id: where to store the ID retrieved.
765 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
766 * @c45_ids: where to store the c45 ID information.
767 *
768 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
769 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
770 * zero on success.
771 *
772 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
773 * its return value is in turn returned.
774 *
775 */
776static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
777 bool is_c45, struct phy_c45_device_ids *c45_ids)
778{
779 int phy_reg;
780
781 if (is_c45)
782 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
783
784 /* Grab the bits from PHYIR1, and put them in the upper half */
785 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
786 if (phy_reg < 0) {
787 /* returning -ENODEV doesn't stop bus scanning */
788 return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
789 }
790
791 *phy_id = phy_reg << 16;
792
793 /* Grab the bits from PHYIR2, and put them in the lower half */
794 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
795 if (phy_reg < 0)
796 return -EIO;
797
798 *phy_id |= phy_reg;
799
800 return 0;
801}
802
803/**
804 * get_phy_device - reads the specified PHY device and returns its @phy_device
805 * struct
806 * @bus: the target MII bus
807 * @addr: PHY address on the MII bus
808 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
809 *
810 * Description: Reads the ID registers of the PHY at @addr on the
811 * @bus, then allocates and returns the phy_device to represent it.
812 */
813struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
814{
815 struct phy_c45_device_ids c45_ids = {0};
816 u32 phy_id = 0;
817 int r;
818
819 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
820 if (r)
821 return ERR_PTR(r);
822
823 /* If the phy_id is mostly Fs, there is no device there */
824 if ((phy_id & 0x1fffffff) == 0x1fffffff)
825 return ERR_PTR(-ENODEV);
826
827 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
828}
829EXPORT_SYMBOL(get_phy_device);
830
831/**
832 * phy_device_register - Register the phy device on the MDIO bus
833 * @phydev: phy_device structure to be added to the MDIO bus
834 */
835int phy_device_register(struct phy_device *phydev)
836{
837 int err;
838
839 err = mdiobus_register_device(&phydev->mdio);
840 if (err)
841 return err;
842
843 /* Deassert the reset signal */
844 phy_device_reset(phydev, 0);
845
846 /* Run all of the fixups for this PHY */
847 err = phy_scan_fixups(phydev);
848 if (err) {
849 phydev_err(phydev, "failed to initialize\n");
850 goto out;
851 }
852
853 err = device_add(&phydev->mdio.dev);
854 if (err) {
855 phydev_err(phydev, "failed to add\n");
856 goto out;
857 }
858
859 return 0;
860
861 out:
862 /* Assert the reset signal */
863 phy_device_reset(phydev, 1);
864
865 mdiobus_unregister_device(&phydev->mdio);
866 return err;
867}
868EXPORT_SYMBOL(phy_device_register);
869
870/**
871 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
872 * @phydev: phy_device structure to remove
873 *
874 * This doesn't free the phy_device itself, it merely reverses the effects
875 * of phy_device_register(). Use phy_device_free() to free the device
876 * after calling this function.
877 */
878void phy_device_remove(struct phy_device *phydev)
879{
880 device_del(&phydev->mdio.dev);
881
882 /* Assert the reset signal */
883 phy_device_reset(phydev, 1);
884
885 mdiobus_unregister_device(&phydev->mdio);
886}
887EXPORT_SYMBOL(phy_device_remove);
888
889/**
890 * phy_find_first - finds the first PHY device on the bus
891 * @bus: the target MII bus
892 */
893struct phy_device *phy_find_first(struct mii_bus *bus)
894{
895 struct phy_device *phydev;
896 int addr;
897
898 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
899 phydev = mdiobus_get_phy(bus, addr);
900 if (phydev)
901 return phydev;
902 }
903 return NULL;
904}
905EXPORT_SYMBOL(phy_find_first);
906
907static void phy_link_change(struct phy_device *phydev, bool up, bool do_carrier)
908{
909 struct net_device *netdev = phydev->attached_dev;
910
911 if (do_carrier) {
912 if (up)
913 netif_carrier_on(netdev);
914 else
915 netif_carrier_off(netdev);
916 }
917 phydev->adjust_link(netdev);
918}
919
920/**
921 * phy_prepare_link - prepares the PHY layer to monitor link status
922 * @phydev: target phy_device struct
923 * @handler: callback function for link status change notifications
924 *
925 * Description: Tells the PHY infrastructure to handle the
926 * gory details on monitoring link status (whether through
927 * polling or an interrupt), and to call back to the
928 * connected device driver when the link status changes.
929 * If you want to monitor your own link state, don't call
930 * this function.
931 */
932static void phy_prepare_link(struct phy_device *phydev,
933 void (*handler)(struct net_device *))
934{
935 phydev->adjust_link = handler;
936}
937
938/**
939 * phy_connect_direct - connect an ethernet device to a specific phy_device
940 * @dev: the network device to connect
941 * @phydev: the pointer to the phy device
942 * @handler: callback function for state change notifications
943 * @interface: PHY device's interface
944 */
945int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
946 void (*handler)(struct net_device *),
947 phy_interface_t interface)
948{
949 int rc;
950
951 if (!dev)
952 return -EINVAL;
953
954 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
955 if (rc)
956 return rc;
957
958 phy_prepare_link(phydev, handler);
959 if (phy_interrupt_is_valid(phydev))
960 phy_request_interrupt(phydev);
961
962 return 0;
963}
964EXPORT_SYMBOL(phy_connect_direct);
965
966/**
967 * phy_connect - connect an ethernet device to a PHY device
968 * @dev: the network device to connect
969 * @bus_id: the id string of the PHY device to connect
970 * @handler: callback function for state change notifications
971 * @interface: PHY device's interface
972 *
973 * Description: Convenience function for connecting ethernet
974 * devices to PHY devices. The default behavior is for
975 * the PHY infrastructure to handle everything, and only notify
976 * the connected driver when the link status changes. If you
977 * don't want, or can't use the provided functionality, you may
978 * choose to call only the subset of functions which provide
979 * the desired functionality.
980 */
981struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
982 void (*handler)(struct net_device *),
983 phy_interface_t interface)
984{
985 struct phy_device *phydev;
986 struct device *d;
987 int rc;
988
989 /* Search the list of PHY devices on the mdio bus for the
990 * PHY with the requested name
991 */
992 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
993 if (!d) {
994 pr_err("PHY %s not found\n", bus_id);
995 return ERR_PTR(-ENODEV);
996 }
997 phydev = to_phy_device(d);
998
999 rc = phy_connect_direct(dev, phydev, handler, interface);
1000 put_device(d);
1001 if (rc)
1002 return ERR_PTR(rc);
1003
1004 return phydev;
1005}
1006EXPORT_SYMBOL(phy_connect);
1007
1008/**
1009 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
1010 * device
1011 * @phydev: target phy_device struct
1012 */
1013void phy_disconnect(struct phy_device *phydev)
1014{
1015 if (phy_is_started(phydev))
1016 phy_stop(phydev);
1017
1018 if (phy_interrupt_is_valid(phydev))
1019 phy_free_interrupt(phydev);
1020
1021 phydev->adjust_link = NULL;
1022
1023 phy_detach(phydev);
1024}
1025EXPORT_SYMBOL(phy_disconnect);
1026
1027/**
1028 * phy_poll_reset - Safely wait until a PHY reset has properly completed
1029 * @phydev: The PHY device to poll
1030 *
1031 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
1032 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
1033 * register must be polled until the BMCR_RESET bit clears.
1034 *
1035 * Furthermore, any attempts to write to PHY registers may have no effect
1036 * or even generate MDIO bus errors until this is complete.
1037 *
1038 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
1039 * standard and do not fully reset after the BMCR_RESET bit is set, and may
1040 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
1041 * effort to support such broken PHYs, this function is separate from the
1042 * standard phy_init_hw() which will zero all the other bits in the BMCR
1043 * and reapply all driver-specific and board-specific fixups.
1044 */
1045static int phy_poll_reset(struct phy_device *phydev)
1046{
1047 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
1048 unsigned int retries = 12;
1049 int ret;
1050
1051 do {
1052 msleep(50);
1053 ret = phy_read(phydev, MII_BMCR);
1054 if (ret < 0)
1055 return ret;
1056 } while (ret & BMCR_RESET && --retries);
1057 if (ret & BMCR_RESET)
1058 return -ETIMEDOUT;
1059
1060 /* Some chips (smsc911x) may still need up to another 1ms after the
1061 * BMCR_RESET bit is cleared before they are usable.
1062 */
1063 msleep(1);
1064 return 0;
1065}
1066
1067int phy_init_hw(struct phy_device *phydev)
1068{
1069 int ret = 0;
1070
1071 /* Deassert the reset signal */
1072 phy_device_reset(phydev, 0);
1073
1074 if (!phydev->drv)
1075 return 0;
1076
1077 if (phydev->drv->soft_reset)
1078 ret = phydev->drv->soft_reset(phydev);
1079
1080 if (ret < 0)
1081 return ret;
1082
1083 ret = phy_scan_fixups(phydev);
1084 if (ret < 0)
1085 return ret;
1086
1087 if (phydev->drv->config_init)
1088 ret = phydev->drv->config_init(phydev);
1089
1090 return ret;
1091}
1092EXPORT_SYMBOL(phy_init_hw);
1093
1094void phy_attached_info(struct phy_device *phydev)
1095{
1096 phy_attached_print(phydev, NULL);
1097}
1098EXPORT_SYMBOL(phy_attached_info);
1099
1100#define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%s)"
1101void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
1102{
1103 const char *drv_name = phydev->drv ? phydev->drv->name : "unbound";
1104 char *irq_str;
1105 char irq_num[8];
1106
1107 switch(phydev->irq) {
1108 case PHY_POLL:
1109 irq_str = "POLL";
1110 break;
1111 case PHY_IGNORE_INTERRUPT:
1112 irq_str = "IGNORE";
1113 break;
1114 default:
1115 snprintf(irq_num, sizeof(irq_num), "%d", phydev->irq);
1116 irq_str = irq_num;
1117 break;
1118 }
1119
1120
1121 if (!fmt) {
1122 phydev_info(phydev, ATTACHED_FMT "\n",
1123 drv_name, phydev_name(phydev),
1124 irq_str);
1125 } else {
1126 va_list ap;
1127
1128 phydev_info(phydev, ATTACHED_FMT,
1129 drv_name, phydev_name(phydev),
1130 irq_str);
1131
1132 va_start(ap, fmt);
1133 vprintk(fmt, ap);
1134 va_end(ap);
1135 }
1136}
1137EXPORT_SYMBOL(phy_attached_print);
1138
1139static void phy_sysfs_create_links(struct phy_device *phydev)
1140{
1141 struct net_device *dev = phydev->attached_dev;
1142 int err;
1143
1144 if (!dev)
1145 return;
1146
1147 err = sysfs_create_link(&phydev->mdio.dev.kobj, &dev->dev.kobj,
1148 "attached_dev");
1149 if (err)
1150 return;
1151
1152 err = sysfs_create_link_nowarn(&dev->dev.kobj,
1153 &phydev->mdio.dev.kobj,
1154 "phydev");
1155 if (err) {
1156 dev_err(&dev->dev, "could not add device link to %s err %d\n",
1157 kobject_name(&phydev->mdio.dev.kobj),
1158 err);
1159 /* non-fatal - some net drivers can use one netdevice
1160 * with more then one phy
1161 */
1162 }
1163
1164 phydev->sysfs_links = true;
1165}
1166
1167static ssize_t
1168phy_standalone_show(struct device *dev, struct device_attribute *attr,
1169 char *buf)
1170{
1171 struct phy_device *phydev = to_phy_device(dev);
1172
1173 return sprintf(buf, "%d\n", !phydev->attached_dev);
1174}
1175static DEVICE_ATTR_RO(phy_standalone);
1176
1177/**
1178 * phy_attach_direct - attach a network device to a given PHY device pointer
1179 * @dev: network device to attach
1180 * @phydev: Pointer to phy_device to attach
1181 * @flags: PHY device's dev_flags
1182 * @interface: PHY device's interface
1183 *
1184 * Description: Called by drivers to attach to a particular PHY
1185 * device. The phy_device is found, and properly hooked up
1186 * to the phy_driver. If no driver is attached, then a
1187 * generic driver is used. The phy_device is given a ptr to
1188 * the attaching device, and given a callback for link status
1189 * change. The phy_device is returned to the attaching driver.
1190 * This function takes a reference on the phy device.
1191 */
1192int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
1193 u32 flags, phy_interface_t interface)
1194{
1195 struct mii_bus *bus = phydev->mdio.bus;
1196 struct device *d = &phydev->mdio.dev;
1197 struct module *ndev_owner = NULL;
1198 bool using_genphy = false;
1199 int err;
1200
1201 /* For Ethernet device drivers that register their own MDIO bus, we
1202 * will have bus->owner match ndev_mod, so we do not want to increment
1203 * our own module->refcnt here, otherwise we would not be able to
1204 * unload later on.
1205 */
1206 if (dev)
1207 ndev_owner = dev->dev.parent->driver->owner;
1208 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
1209 phydev_err(phydev, "failed to get the bus module\n");
1210 return -EIO;
1211 }
1212
1213 get_device(d);
1214
1215 /* Assume that if there is no driver, that it doesn't
1216 * exist, and we should use the genphy driver.
1217 */
1218 if (!d->driver) {
1219 if (phydev->is_c45)
1220 d->driver = &genphy_c45_driver.mdiodrv.driver;
1221 else
1222 d->driver = &genphy_driver.mdiodrv.driver;
1223
1224 using_genphy = true;
1225 }
1226
1227 if (!try_module_get(d->driver->owner)) {
1228 phydev_err(phydev, "failed to get the device driver module\n");
1229 err = -EIO;
1230 goto error_put_device;
1231 }
1232
1233 if (using_genphy) {
1234 err = d->driver->probe(d);
1235 if (err >= 0)
1236 err = device_bind_driver(d);
1237
1238 if (err)
1239 goto error_module_put;
1240 }
1241
1242 if (phydev->attached_dev) {
1243 dev_err(&dev->dev, "PHY already attached\n");
1244 err = -EBUSY;
1245 goto error;
1246 }
1247
1248 phydev->phy_link_change = phy_link_change;
1249 if (dev) {
1250 phydev->attached_dev = dev;
1251 dev->phydev = phydev;
1252 }
1253
1254 /* Some Ethernet drivers try to connect to a PHY device before
1255 * calling register_netdevice() -> netdev_register_kobject() and
1256 * does the dev->dev.kobj initialization. Here we only check for
1257 * success which indicates that the network device kobject is
1258 * ready. Once we do that we still need to keep track of whether
1259 * links were successfully set up or not for phy_detach() to
1260 * remove them accordingly.
1261 */
1262 phydev->sysfs_links = false;
1263
1264 phy_sysfs_create_links(phydev);
1265
1266 if (!phydev->attached_dev) {
1267 err = sysfs_create_file(&phydev->mdio.dev.kobj,
1268 &dev_attr_phy_standalone.attr);
1269 if (err)
1270 phydev_err(phydev, "error creating 'phy_standalone' sysfs entry\n");
1271 }
1272
1273 phydev->dev_flags = flags;
1274
1275 phydev->interface = interface;
1276
1277 phydev->state = PHY_READY;
1278
1279 /* Initial carrier state is off as the phy is about to be
1280 * (re)initialized.
1281 */
1282 if (dev)
1283 netif_carrier_off(phydev->attached_dev);
1284
1285 /* Do initial configuration here, now that
1286 * we have certain key parameters
1287 * (dev_flags and interface)
1288 */
1289 err = phy_init_hw(phydev);
1290 if (err)
1291 goto error;
1292
1293 phy_resume(phydev);
1294 phy_led_triggers_register(phydev);
1295
1296 return err;
1297
1298error:
1299 /* phy_detach() does all of the cleanup below */
1300 phy_detach(phydev);
1301 return err;
1302
1303error_module_put:
1304 module_put(d->driver->owner);
1305error_put_device:
1306 put_device(d);
1307 if (ndev_owner != bus->owner)
1308 module_put(bus->owner);
1309 return err;
1310}
1311EXPORT_SYMBOL(phy_attach_direct);
1312
1313/**
1314 * phy_attach - attach a network device to a particular PHY device
1315 * @dev: network device to attach
1316 * @bus_id: Bus ID of PHY device to attach
1317 * @interface: PHY device's interface
1318 *
1319 * Description: Same as phy_attach_direct() except that a PHY bus_id
1320 * string is passed instead of a pointer to a struct phy_device.
1321 */
1322struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1323 phy_interface_t interface)
1324{
1325 struct bus_type *bus = &mdio_bus_type;
1326 struct phy_device *phydev;
1327 struct device *d;
1328 int rc;
1329
1330 if (!dev)
1331 return ERR_PTR(-EINVAL);
1332
1333 /* Search the list of PHY devices on the mdio bus for the
1334 * PHY with the requested name
1335 */
1336 d = bus_find_device_by_name(bus, NULL, bus_id);
1337 if (!d) {
1338 pr_err("PHY %s not found\n", bus_id);
1339 return ERR_PTR(-ENODEV);
1340 }
1341 phydev = to_phy_device(d);
1342
1343 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1344 put_device(d);
1345 if (rc)
1346 return ERR_PTR(rc);
1347
1348 return phydev;
1349}
1350EXPORT_SYMBOL(phy_attach);
1351
1352static bool phy_driver_is_genphy_kind(struct phy_device *phydev,
1353 struct device_driver *driver)
1354{
1355 struct device *d = &phydev->mdio.dev;
1356 bool ret = false;
1357
1358 if (!phydev->drv)
1359 return ret;
1360
1361 get_device(d);
1362 ret = d->driver == driver;
1363 put_device(d);
1364
1365 return ret;
1366}
1367
1368bool phy_driver_is_genphy(struct phy_device *phydev)
1369{
1370 return phy_driver_is_genphy_kind(phydev,
1371 &genphy_driver.mdiodrv.driver);
1372}
1373EXPORT_SYMBOL_GPL(phy_driver_is_genphy);
1374
1375bool phy_driver_is_genphy_10g(struct phy_device *phydev)
1376{
1377 return phy_driver_is_genphy_kind(phydev,
1378 &genphy_c45_driver.mdiodrv.driver);
1379}
1380EXPORT_SYMBOL_GPL(phy_driver_is_genphy_10g);
1381
1382/**
1383 * phy_detach - detach a PHY device from its network device
1384 * @phydev: target phy_device struct
1385 *
1386 * This detaches the phy device from its network device and the phy
1387 * driver, and drops the reference count taken in phy_attach_direct().
1388 */
1389void phy_detach(struct phy_device *phydev)
1390{
1391 struct net_device *dev = phydev->attached_dev;
1392 struct module *ndev_owner = NULL;
1393 struct mii_bus *bus;
1394
1395 if (phydev->sysfs_links) {
1396 if (dev)
1397 sysfs_remove_link(&dev->dev.kobj, "phydev");
1398 sysfs_remove_link(&phydev->mdio.dev.kobj, "attached_dev");
1399 }
1400
1401 if (!phydev->attached_dev)
1402 sysfs_remove_file(&phydev->mdio.dev.kobj,
1403 &dev_attr_phy_standalone.attr);
1404
1405 phy_suspend(phydev);
1406 if (dev) {
1407 phydev->attached_dev->phydev = NULL;
1408 phydev->attached_dev = NULL;
1409 }
1410 phydev->phylink = NULL;
1411
1412 phy_led_triggers_unregister(phydev);
1413
1414 module_put(phydev->mdio.dev.driver->owner);
1415
1416 /* If the device had no specific driver before (i.e. - it
1417 * was using the generic driver), we unbind the device
1418 * from the generic driver so that there's a chance a
1419 * real driver could be loaded
1420 */
1421 if (phy_driver_is_genphy(phydev) ||
1422 phy_driver_is_genphy_10g(phydev))
1423 device_release_driver(&phydev->mdio.dev);
1424
1425 /*
1426 * The phydev might go away on the put_device() below, so avoid
1427 * a use-after-free bug by reading the underlying bus first.
1428 */
1429 bus = phydev->mdio.bus;
1430
1431 put_device(&phydev->mdio.dev);
1432 if (dev)
1433 ndev_owner = dev->dev.parent->driver->owner;
1434 if (ndev_owner != bus->owner)
1435 module_put(bus->owner);
1436
1437 /* Assert the reset signal */
1438 phy_device_reset(phydev, 1);
1439}
1440EXPORT_SYMBOL(phy_detach);
1441
1442int phy_suspend(struct phy_device *phydev)
1443{
1444 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1445 struct net_device *netdev = phydev->attached_dev;
1446 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1447 int ret = 0;
1448
1449 /* If the device has WOL enabled, we cannot suspend the PHY */
1450 phy_ethtool_get_wol(phydev, &wol);
1451 if (wol.wolopts || (netdev && netdev->wol_enabled))
1452 return -EBUSY;
1453
1454 if (phydev->drv && phydrv->suspend)
1455 ret = phydrv->suspend(phydev);
1456
1457 if (ret)
1458 return ret;
1459
1460 phydev->suspended = true;
1461
1462 return ret;
1463}
1464EXPORT_SYMBOL(phy_suspend);
1465
1466int __phy_resume(struct phy_device *phydev)
1467{
1468 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1469 int ret = 0;
1470
1471 WARN_ON(!mutex_is_locked(&phydev->lock));
1472
1473 if (phydev->drv && phydrv->resume)
1474 ret = phydrv->resume(phydev);
1475
1476 if (ret)
1477 return ret;
1478
1479 phydev->suspended = false;
1480
1481 return ret;
1482}
1483EXPORT_SYMBOL(__phy_resume);
1484
1485int phy_resume(struct phy_device *phydev)
1486{
1487 int ret;
1488
1489 mutex_lock(&phydev->lock);
1490 ret = __phy_resume(phydev);
1491 mutex_unlock(&phydev->lock);
1492
1493 return ret;
1494}
1495EXPORT_SYMBOL(phy_resume);
1496
1497int phy_loopback(struct phy_device *phydev, bool enable)
1498{
1499 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1500 int ret = 0;
1501
1502 mutex_lock(&phydev->lock);
1503
1504 if (enable && phydev->loopback_enabled) {
1505 ret = -EBUSY;
1506 goto out;
1507 }
1508
1509 if (!enable && !phydev->loopback_enabled) {
1510 ret = -EINVAL;
1511 goto out;
1512 }
1513
1514 if (phydev->drv && phydrv->set_loopback)
1515 ret = phydrv->set_loopback(phydev, enable);
1516 else
1517 ret = -EOPNOTSUPP;
1518
1519 if (ret)
1520 goto out;
1521
1522 phydev->loopback_enabled = enable;
1523
1524out:
1525 mutex_unlock(&phydev->lock);
1526 return ret;
1527}
1528EXPORT_SYMBOL(phy_loopback);
1529
1530/**
1531 * phy_reset_after_clk_enable - perform a PHY reset if needed
1532 * @phydev: target phy_device struct
1533 *
1534 * Description: Some PHYs are known to need a reset after their refclk was
1535 * enabled. This function evaluates the flags and perform the reset if it's
1536 * needed. Returns < 0 on error, 0 if the phy wasn't reset and 1 if the phy
1537 * was reset.
1538 */
1539int phy_reset_after_clk_enable(struct phy_device *phydev)
1540{
1541 if (!phydev || !phydev->drv)
1542 return -ENODEV;
1543
1544 if (phydev->drv->flags & PHY_RST_AFTER_CLK_EN) {
1545 phy_device_reset(phydev, 1);
1546 phy_device_reset(phydev, 0);
1547 return 1;
1548 }
1549
1550 return 0;
1551}
1552EXPORT_SYMBOL(phy_reset_after_clk_enable);
1553
1554/* Generic PHY support and helper functions */
1555
1556/**
1557 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1558 * @phydev: target phy_device struct
1559 *
1560 * Description: Writes MII_ADVERTISE with the appropriate values,
1561 * after sanitizing the values to make sure we only advertise
1562 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1563 * hasn't changed, and > 0 if it has changed.
1564 */
1565static int genphy_config_advert(struct phy_device *phydev)
1566{
1567 int err, bmsr, changed = 0;
1568 u32 adv;
1569
1570 /* Only allow advertising what this PHY supports */
1571 linkmode_and(phydev->advertising, phydev->advertising,
1572 phydev->supported);
1573
1574 adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
1575
1576 /* Setup standard advertisement */
1577 err = phy_modify_changed(phydev, MII_ADVERTISE,
1578 ADVERTISE_ALL | ADVERTISE_100BASE4 |
1579 ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM,
1580 adv);
1581 if (err < 0)
1582 return err;
1583 if (err > 0)
1584 changed = 1;
1585
1586 bmsr = phy_read(phydev, MII_BMSR);
1587 if (bmsr < 0)
1588 return bmsr;
1589
1590 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1591 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1592 * logical 1.
1593 */
1594 if (!(bmsr & BMSR_ESTATEN))
1595 return changed;
1596
1597 adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
1598
1599 err = phy_modify_changed(phydev, MII_CTRL1000,
1600 ADVERTISE_1000FULL | ADVERTISE_1000HALF,
1601 adv);
1602 if (err < 0)
1603 return err;
1604 if (err > 0)
1605 changed = 1;
1606
1607 return changed;
1608}
1609
1610/**
1611 * genphy_config_eee_advert - disable unwanted eee mode advertisement
1612 * @phydev: target phy_device struct
1613 *
1614 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1615 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1616 * changed, and 1 if it has changed.
1617 */
1618int genphy_config_eee_advert(struct phy_device *phydev)
1619{
1620 int err;
1621
1622 /* Nothing to disable */
1623 if (!phydev->eee_broken_modes)
1624 return 0;
1625
1626 err = phy_modify_mmd_changed(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV,
1627 phydev->eee_broken_modes, 0);
1628 /* If the call failed, we assume that EEE is not supported */
1629 return err < 0 ? 0 : err;
1630}
1631EXPORT_SYMBOL(genphy_config_eee_advert);
1632
1633/**
1634 * genphy_setup_forced - configures/forces speed/duplex from @phydev
1635 * @phydev: target phy_device struct
1636 *
1637 * Description: Configures MII_BMCR to force speed/duplex
1638 * to the values in phydev. Assumes that the values are valid.
1639 * Please see phy_sanitize_settings().
1640 */
1641int genphy_setup_forced(struct phy_device *phydev)
1642{
1643 u16 ctl = 0;
1644
1645 phydev->pause = 0;
1646 phydev->asym_pause = 0;
1647
1648 if (SPEED_1000 == phydev->speed)
1649 ctl |= BMCR_SPEED1000;
1650 else if (SPEED_100 == phydev->speed)
1651 ctl |= BMCR_SPEED100;
1652
1653 if (DUPLEX_FULL == phydev->duplex)
1654 ctl |= BMCR_FULLDPLX;
1655
1656 return phy_modify(phydev, MII_BMCR,
1657 ~(BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN), ctl);
1658}
1659EXPORT_SYMBOL(genphy_setup_forced);
1660
1661/**
1662 * genphy_restart_aneg - Enable and Restart Autonegotiation
1663 * @phydev: target phy_device struct
1664 */
1665int genphy_restart_aneg(struct phy_device *phydev)
1666{
1667 /* Don't isolate the PHY if we're negotiating */
1668 return phy_modify(phydev, MII_BMCR, BMCR_ISOLATE,
1669 BMCR_ANENABLE | BMCR_ANRESTART);
1670}
1671EXPORT_SYMBOL(genphy_restart_aneg);
1672
1673/**
1674 * __genphy_config_aneg - restart auto-negotiation or write BMCR
1675 * @phydev: target phy_device struct
1676 * @changed: whether autoneg is requested
1677 *
1678 * Description: If auto-negotiation is enabled, we configure the
1679 * advertising, and then restart auto-negotiation. If it is not
1680 * enabled, then we write the BMCR.
1681 */
1682int __genphy_config_aneg(struct phy_device *phydev, bool changed)
1683{
1684 int err;
1685
1686 if (genphy_config_eee_advert(phydev))
1687 changed = true;
1688
1689 if (AUTONEG_ENABLE != phydev->autoneg)
1690 return genphy_setup_forced(phydev);
1691
1692 err = genphy_config_advert(phydev);
1693 if (err < 0) /* error */
1694 return err;
1695 else if (err)
1696 changed = true;
1697
1698 if (!changed) {
1699 /* Advertisement hasn't changed, but maybe aneg was never on to
1700 * begin with? Or maybe phy was isolated?
1701 */
1702 int ctl = phy_read(phydev, MII_BMCR);
1703
1704 if (ctl < 0)
1705 return ctl;
1706
1707 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1708 changed = true; /* do restart aneg */
1709 }
1710
1711 /* Only restart aneg if we are advertising something different
1712 * than we were before.
1713 */
1714 return changed ? genphy_restart_aneg(phydev) : 0;
1715}
1716EXPORT_SYMBOL(__genphy_config_aneg);
1717
1718/**
1719 * genphy_aneg_done - return auto-negotiation status
1720 * @phydev: target phy_device struct
1721 *
1722 * Description: Reads the status register and returns 0 either if
1723 * auto-negotiation is incomplete, or if there was an error.
1724 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1725 */
1726int genphy_aneg_done(struct phy_device *phydev)
1727{
1728 int retval = phy_read(phydev, MII_BMSR);
1729
1730 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1731}
1732EXPORT_SYMBOL(genphy_aneg_done);
1733
1734/**
1735 * genphy_update_link - update link status in @phydev
1736 * @phydev: target phy_device struct
1737 *
1738 * Description: Update the value in phydev->link to reflect the
1739 * current link value. In order to do this, we need to read
1740 * the status register twice, keeping the second value.
1741 */
1742int genphy_update_link(struct phy_device *phydev)
1743{
1744 int status = 0, bmcr;
1745
1746 bmcr = phy_read(phydev, MII_BMCR);
1747 if (bmcr < 0)
1748 return bmcr;
1749
1750 /* Autoneg is being started, therefore disregard BMSR value and
1751 * report link as down.
1752 */
1753 if (bmcr & BMCR_ANRESTART)
1754 goto done;
1755
1756 /* The link state is latched low so that momentary link
1757 * drops can be detected. Do not double-read the status
1758 * in polling mode to detect such short link drops.
1759 */
1760 if (!phy_polling_mode(phydev)) {
1761 status = phy_read(phydev, MII_BMSR);
1762 if (status < 0)
1763 return status;
1764 else if (status & BMSR_LSTATUS)
1765 goto done;
1766 }
1767
1768 /* Read link and autonegotiation status */
1769 status = phy_read(phydev, MII_BMSR);
1770 if (status < 0)
1771 return status;
1772done:
1773 phydev->link = status & BMSR_LSTATUS ? 1 : 0;
1774 phydev->autoneg_complete = status & BMSR_ANEGCOMPLETE ? 1 : 0;
1775
1776 /* Consider the case that autoneg was started and "aneg complete"
1777 * bit has been reset, but "link up" bit not yet.
1778 */
1779 if (phydev->autoneg == AUTONEG_ENABLE && !phydev->autoneg_complete)
1780 phydev->link = 0;
1781
1782 return 0;
1783}
1784EXPORT_SYMBOL(genphy_update_link);
1785
1786int genphy_read_lpa(struct phy_device *phydev)
1787{
1788 int lpa, lpagb;
1789
1790 if (phydev->autoneg == AUTONEG_ENABLE) {
1791 if (!phydev->autoneg_complete) {
1792 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1793 0);
1794 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, 0);
1795 return 0;
1796 }
1797
1798 if (phydev->is_gigabit_capable) {
1799 lpagb = phy_read(phydev, MII_STAT1000);
1800 if (lpagb < 0)
1801 return lpagb;
1802
1803 if (lpagb & LPA_1000MSFAIL) {
1804 int adv = phy_read(phydev, MII_CTRL1000);
1805
1806 if (adv < 0)
1807 return adv;
1808
1809 if (adv & CTL1000_ENABLE_MASTER)
1810 phydev_err(phydev, "Master/Slave resolution failed, maybe conflicting manual settings?\n");
1811 else
1812 phydev_err(phydev, "Master/Slave resolution failed\n");
1813 return -ENOLINK;
1814 }
1815
1816 mii_stat1000_mod_linkmode_lpa_t(phydev->lp_advertising,
1817 lpagb);
1818 }
1819
1820 lpa = phy_read(phydev, MII_LPA);
1821 if (lpa < 0)
1822 return lpa;
1823
1824 mii_lpa_mod_linkmode_lpa_t(phydev->lp_advertising, lpa);
1825 } else {
1826 linkmode_zero(phydev->lp_advertising);
1827 }
1828
1829 return 0;
1830}
1831EXPORT_SYMBOL(genphy_read_lpa);
1832
1833/**
1834 * genphy_read_status - check the link status and update current link state
1835 * @phydev: target phy_device struct
1836 *
1837 * Description: Check the link, then figure out the current state
1838 * by comparing what we advertise with what the link partner
1839 * advertises. Start by checking the gigabit possibilities,
1840 * then move on to 10/100.
1841 */
1842int genphy_read_status(struct phy_device *phydev)
1843{
1844 int err, old_link = phydev->link;
1845
1846 /* Update the link, but return if there was an error */
1847 err = genphy_update_link(phydev);
1848 if (err)
1849 return err;
1850
1851 /* why bother the PHY if nothing can have changed */
1852 if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link)
1853 return 0;
1854
1855 phydev->speed = SPEED_UNKNOWN;
1856 phydev->duplex = DUPLEX_UNKNOWN;
1857 phydev->pause = 0;
1858 phydev->asym_pause = 0;
1859
1860 err = genphy_read_lpa(phydev);
1861 if (err < 0)
1862 return err;
1863
1864 if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
1865 phy_resolve_aneg_linkmode(phydev);
1866 } else if (phydev->autoneg == AUTONEG_DISABLE) {
1867 int bmcr = phy_read(phydev, MII_BMCR);
1868
1869 if (bmcr < 0)
1870 return bmcr;
1871
1872 if (bmcr & BMCR_FULLDPLX)
1873 phydev->duplex = DUPLEX_FULL;
1874 else
1875 phydev->duplex = DUPLEX_HALF;
1876
1877 if (bmcr & BMCR_SPEED1000)
1878 phydev->speed = SPEED_1000;
1879 else if (bmcr & BMCR_SPEED100)
1880 phydev->speed = SPEED_100;
1881 else
1882 phydev->speed = SPEED_10;
1883 }
1884
1885 return 0;
1886}
1887EXPORT_SYMBOL(genphy_read_status);
1888
1889/**
1890 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
1891 * @phydev: target phy_device struct
1892 *
1893 * Description: Perform a software PHY reset using the standard
1894 * BMCR_RESET bit and poll for the reset bit to be cleared.
1895 *
1896 * Returns: 0 on success, < 0 on failure
1897 */
1898int genphy_soft_reset(struct phy_device *phydev)
1899{
1900 u16 res = BMCR_RESET;
1901 int ret;
1902
1903 if (phydev->autoneg == AUTONEG_ENABLE)
1904 res |= BMCR_ANRESTART;
1905
1906 ret = phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, res);
1907 if (ret < 0)
1908 return ret;
1909
1910 ret = phy_poll_reset(phydev);
1911 if (ret)
1912 return ret;
1913
1914 /* BMCR may be reset to defaults */
1915 if (phydev->autoneg == AUTONEG_DISABLE)
1916 ret = genphy_setup_forced(phydev);
1917
1918 return ret;
1919}
1920EXPORT_SYMBOL(genphy_soft_reset);
1921
1922/**
1923 * genphy_read_abilities - read PHY abilities from Clause 22 registers
1924 * @phydev: target phy_device struct
1925 *
1926 * Description: Reads the PHY's abilities and populates
1927 * phydev->supported accordingly.
1928 *
1929 * Returns: 0 on success, < 0 on failure
1930 */
1931int genphy_read_abilities(struct phy_device *phydev)
1932{
1933 int val;
1934
1935 linkmode_set_bit_array(phy_basic_ports_array,
1936 ARRAY_SIZE(phy_basic_ports_array),
1937 phydev->supported);
1938
1939 val = phy_read(phydev, MII_BMSR);
1940 if (val < 0)
1941 return val;
1942
1943 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported,
1944 val & BMSR_ANEGCAPABLE);
1945
1946 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported,
1947 val & BMSR_100FULL);
1948 linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported,
1949 val & BMSR_100HALF);
1950 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported,
1951 val & BMSR_10FULL);
1952 linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported,
1953 val & BMSR_10HALF);
1954
1955 if (val & BMSR_ESTATEN) {
1956 val = phy_read(phydev, MII_ESTATUS);
1957 if (val < 0)
1958 return val;
1959
1960 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
1961 phydev->supported, val & ESTATUS_1000_TFULL);
1962 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
1963 phydev->supported, val & ESTATUS_1000_THALF);
1964 linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT,
1965 phydev->supported, val & ESTATUS_1000_XFULL);
1966 }
1967
1968 return 0;
1969}
1970EXPORT_SYMBOL(genphy_read_abilities);
1971
1972/* This is used for the phy device which doesn't support the MMD extended
1973 * register access, but it does have side effect when we are trying to access
1974 * the MMD register via indirect method.
1975 */
1976int genphy_read_mmd_unsupported(struct phy_device *phdev, int devad, u16 regnum)
1977{
1978 return -EOPNOTSUPP;
1979}
1980EXPORT_SYMBOL(genphy_read_mmd_unsupported);
1981
1982int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
1983 u16 regnum, u16 val)
1984{
1985 return -EOPNOTSUPP;
1986}
1987EXPORT_SYMBOL(genphy_write_mmd_unsupported);
1988
1989int genphy_suspend(struct phy_device *phydev)
1990{
1991 return phy_set_bits(phydev, MII_BMCR, BMCR_PDOWN);
1992}
1993EXPORT_SYMBOL(genphy_suspend);
1994
1995int genphy_resume(struct phy_device *phydev)
1996{
1997 return phy_clear_bits(phydev, MII_BMCR, BMCR_PDOWN);
1998}
1999EXPORT_SYMBOL(genphy_resume);
2000
2001int genphy_loopback(struct phy_device *phydev, bool enable)
2002{
2003 return phy_modify(phydev, MII_BMCR, BMCR_LOOPBACK,
2004 enable ? BMCR_LOOPBACK : 0);
2005}
2006EXPORT_SYMBOL(genphy_loopback);
2007
2008/**
2009 * phy_remove_link_mode - Remove a supported link mode
2010 * @phydev: phy_device structure to remove link mode from
2011 * @link_mode: Link mode to be removed
2012 *
2013 * Description: Some MACs don't support all link modes which the PHY
2014 * does. e.g. a 1G MAC often does not support 1000Half. Add a helper
2015 * to remove a link mode.
2016 */
2017void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode)
2018{
2019 linkmode_clear_bit(link_mode, phydev->supported);
2020 phy_advertise_supported(phydev);
2021}
2022EXPORT_SYMBOL(phy_remove_link_mode);
2023
2024static void phy_copy_pause_bits(unsigned long *dst, unsigned long *src)
2025{
2026 linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, dst,
2027 linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, src));
2028 linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, dst,
2029 linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, src));
2030}
2031
2032/**
2033 * phy_advertise_supported - Advertise all supported modes
2034 * @phydev: target phy_device struct
2035 *
2036 * Description: Called to advertise all supported modes, doesn't touch
2037 * pause mode advertising.
2038 */
2039void phy_advertise_supported(struct phy_device *phydev)
2040{
2041 __ETHTOOL_DECLARE_LINK_MODE_MASK(new);
2042
2043 linkmode_copy(new, phydev->supported);
2044 phy_copy_pause_bits(new, phydev->advertising);
2045 linkmode_copy(phydev->advertising, new);
2046}
2047EXPORT_SYMBOL(phy_advertise_supported);
2048
2049/**
2050 * phy_support_sym_pause - Enable support of symmetrical pause
2051 * @phydev: target phy_device struct
2052 *
2053 * Description: Called by the MAC to indicate is supports symmetrical
2054 * Pause, but not asym pause.
2055 */
2056void phy_support_sym_pause(struct phy_device *phydev)
2057{
2058 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported);
2059 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2060}
2061EXPORT_SYMBOL(phy_support_sym_pause);
2062
2063/**
2064 * phy_support_asym_pause - Enable support of asym pause
2065 * @phydev: target phy_device struct
2066 *
2067 * Description: Called by the MAC to indicate is supports Asym Pause.
2068 */
2069void phy_support_asym_pause(struct phy_device *phydev)
2070{
2071 phy_copy_pause_bits(phydev->advertising, phydev->supported);
2072}
2073EXPORT_SYMBOL(phy_support_asym_pause);
2074
2075/**
2076 * phy_set_sym_pause - Configure symmetric Pause
2077 * @phydev: target phy_device struct
2078 * @rx: Receiver Pause is supported
2079 * @tx: Transmit Pause is supported
2080 * @autoneg: Auto neg should be used
2081 *
2082 * Description: Configure advertised Pause support depending on if
2083 * receiver pause and pause auto neg is supported. Generally called
2084 * from the set_pauseparam .ndo.
2085 */
2086void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
2087 bool autoneg)
2088{
2089 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported);
2090
2091 if (rx && tx && autoneg)
2092 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2093 phydev->supported);
2094
2095 linkmode_copy(phydev->advertising, phydev->supported);
2096}
2097EXPORT_SYMBOL(phy_set_sym_pause);
2098
2099/**
2100 * phy_set_asym_pause - Configure Pause and Asym Pause
2101 * @phydev: target phy_device struct
2102 * @rx: Receiver Pause is supported
2103 * @tx: Transmit Pause is supported
2104 *
2105 * Description: Configure advertised Pause support depending on if
2106 * transmit and receiver pause is supported. If there has been a
2107 * change in adverting, trigger a new autoneg. Generally called from
2108 * the set_pauseparam .ndo.
2109 */
2110void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx)
2111{
2112 __ETHTOOL_DECLARE_LINK_MODE_MASK(oldadv);
2113
2114 linkmode_copy(oldadv, phydev->advertising);
2115
2116 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2117 phydev->advertising);
2118 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2119 phydev->advertising);
2120
2121 if (rx) {
2122 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2123 phydev->advertising);
2124 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2125 phydev->advertising);
2126 }
2127
2128 if (tx)
2129 linkmode_change_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2130 phydev->advertising);
2131
2132 if (!linkmode_equal(oldadv, phydev->advertising) &&
2133 phydev->autoneg)
2134 phy_start_aneg(phydev);
2135}
2136EXPORT_SYMBOL(phy_set_asym_pause);
2137
2138/**
2139 * phy_validate_pause - Test if the PHY/MAC support the pause configuration
2140 * @phydev: phy_device struct
2141 * @pp: requested pause configuration
2142 *
2143 * Description: Test if the PHY/MAC combination supports the Pause
2144 * configuration the user is requesting. Returns True if it is
2145 * supported, false otherwise.
2146 */
2147bool phy_validate_pause(struct phy_device *phydev,
2148 struct ethtool_pauseparam *pp)
2149{
2150 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2151 phydev->supported) && pp->rx_pause)
2152 return false;
2153
2154 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2155 phydev->supported) &&
2156 pp->rx_pause != pp->tx_pause)
2157 return false;
2158
2159 return true;
2160}
2161EXPORT_SYMBOL(phy_validate_pause);
2162
2163static bool phy_drv_supports_irq(struct phy_driver *phydrv)
2164{
2165 return phydrv->config_intr && phydrv->ack_interrupt;
2166}
2167
2168/**
2169 * phy_probe - probe and init a PHY device
2170 * @dev: device to probe and init
2171 *
2172 * Description: Take care of setting up the phy_device structure,
2173 * set the state to READY (the driver's init function should
2174 * set it to STARTING if needed).
2175 */
2176static int phy_probe(struct device *dev)
2177{
2178 struct phy_device *phydev = to_phy_device(dev);
2179 struct device_driver *drv = phydev->mdio.dev.driver;
2180 struct phy_driver *phydrv = to_phy_driver(drv);
2181 int err = 0;
2182
2183 phydev->drv = phydrv;
2184
2185 /* Disable the interrupt if the PHY doesn't support it
2186 * but the interrupt is still a valid one
2187 */
2188 if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev))
2189 phydev->irq = PHY_POLL;
2190
2191 if (phydrv->flags & PHY_IS_INTERNAL)
2192 phydev->is_internal = true;
2193
2194 mutex_lock(&phydev->lock);
2195
2196 if (phydev->drv->probe) {
2197 /* Deassert the reset signal */
2198 phy_device_reset(phydev, 0);
2199
2200 err = phydev->drv->probe(phydev);
2201 if (err) {
2202 /* Assert the reset signal */
2203 phy_device_reset(phydev, 1);
2204 goto out;
2205 }
2206 }
2207
2208 /* Start out supporting everything. Eventually,
2209 * a controller will attach, and may modify one
2210 * or both of these values
2211 */
2212 if (phydrv->features) {
2213 linkmode_copy(phydev->supported, phydrv->features);
2214 } else if (phydrv->get_features) {
2215 err = phydrv->get_features(phydev);
2216 } else if (phydev->is_c45) {
2217 err = genphy_c45_pma_read_abilities(phydev);
2218 } else {
2219 err = genphy_read_abilities(phydev);
2220 }
2221
2222 if (err)
2223 goto out;
2224
2225 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2226 phydev->supported))
2227 phydev->autoneg = 0;
2228
2229 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
2230 phydev->supported))
2231 phydev->is_gigabit_capable = 1;
2232 if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
2233 phydev->supported))
2234 phydev->is_gigabit_capable = 1;
2235
2236 of_set_phy_supported(phydev);
2237 phy_advertise_supported(phydev);
2238
2239 /* Get the EEE modes we want to prohibit. We will ask
2240 * the PHY stop advertising these mode later on
2241 */
2242 of_set_phy_eee_broken(phydev);
2243
2244 /* The Pause Frame bits indicate that the PHY can support passing
2245 * pause frames. During autonegotiation, the PHYs will determine if
2246 * they should allow pause frames to pass. The MAC driver should then
2247 * use that result to determine whether to enable flow control via
2248 * pause frames.
2249 *
2250 * Normally, PHY drivers should not set the Pause bits, and instead
2251 * allow phylib to do that. However, there may be some situations
2252 * (e.g. hardware erratum) where the driver wants to set only one
2253 * of these bits.
2254 */
2255 if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
2256 !test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
2257 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2258 phydev->supported);
2259 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2260 phydev->supported);
2261 }
2262
2263 /* Set the state to READY by default */
2264 phydev->state = PHY_READY;
2265
2266out:
2267 mutex_unlock(&phydev->lock);
2268
2269 return err;
2270}
2271
2272static int phy_remove(struct device *dev)
2273{
2274 struct phy_device *phydev = to_phy_device(dev);
2275
2276 cancel_delayed_work_sync(&phydev->state_queue);
2277
2278 mutex_lock(&phydev->lock);
2279 phydev->state = PHY_DOWN;
2280 mutex_unlock(&phydev->lock);
2281
2282 if (phydev->drv && phydev->drv->remove) {
2283 phydev->drv->remove(phydev);
2284
2285 /* Assert the reset signal */
2286 phy_device_reset(phydev, 1);
2287 }
2288 phydev->drv = NULL;
2289
2290 return 0;
2291}
2292
2293/**
2294 * phy_driver_register - register a phy_driver with the PHY layer
2295 * @new_driver: new phy_driver to register
2296 * @owner: module owning this PHY
2297 */
2298int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
2299{
2300 int retval;
2301
2302 /* Either the features are hard coded, or dynamically
2303 * determined. It cannot be both.
2304 */
2305 if (WARN_ON(new_driver->features && new_driver->get_features)) {
2306 pr_err("%s: features and get_features must not both be set\n",
2307 new_driver->name);
2308 return -EINVAL;
2309 }
2310
2311 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
2312 new_driver->mdiodrv.driver.name = new_driver->name;
2313 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
2314 new_driver->mdiodrv.driver.probe = phy_probe;
2315 new_driver->mdiodrv.driver.remove = phy_remove;
2316 new_driver->mdiodrv.driver.owner = owner;
2317
2318 retval = driver_register(&new_driver->mdiodrv.driver);
2319 if (retval) {
2320 pr_err("%s: Error %d in registering driver\n",
2321 new_driver->name, retval);
2322
2323 return retval;
2324 }
2325
2326 pr_debug("%s: Registered new driver\n", new_driver->name);
2327
2328 return 0;
2329}
2330EXPORT_SYMBOL(phy_driver_register);
2331
2332int phy_drivers_register(struct phy_driver *new_driver, int n,
2333 struct module *owner)
2334{
2335 int i, ret = 0;
2336
2337 for (i = 0; i < n; i++) {
2338 ret = phy_driver_register(new_driver + i, owner);
2339 if (ret) {
2340 while (i-- > 0)
2341 phy_driver_unregister(new_driver + i);
2342 break;
2343 }
2344 }
2345 return ret;
2346}
2347EXPORT_SYMBOL(phy_drivers_register);
2348
2349void phy_driver_unregister(struct phy_driver *drv)
2350{
2351 driver_unregister(&drv->mdiodrv.driver);
2352}
2353EXPORT_SYMBOL(phy_driver_unregister);
2354
2355void phy_drivers_unregister(struct phy_driver *drv, int n)
2356{
2357 int i;
2358
2359 for (i = 0; i < n; i++)
2360 phy_driver_unregister(drv + i);
2361}
2362EXPORT_SYMBOL(phy_drivers_unregister);
2363
2364static struct phy_driver genphy_driver = {
2365 .phy_id = 0xffffffff,
2366 .phy_id_mask = 0xffffffff,
2367 .name = "Generic PHY",
2368 .soft_reset = genphy_no_soft_reset,
2369 .get_features = genphy_read_abilities,
2370 .aneg_done = genphy_aneg_done,
2371 .suspend = genphy_suspend,
2372 .resume = genphy_resume,
2373 .set_loopback = genphy_loopback,
2374};
2375
2376static int __init phy_init(void)
2377{
2378 int rc;
2379
2380 rc = mdio_bus_init();
2381 if (rc)
2382 return rc;
2383
2384 features_init();
2385
2386 rc = phy_driver_register(&genphy_c45_driver, THIS_MODULE);
2387 if (rc)
2388 goto err_c45;
2389
2390 rc = phy_driver_register(&genphy_driver, THIS_MODULE);
2391 if (rc) {
2392 phy_driver_unregister(&genphy_c45_driver);
2393err_c45:
2394 mdio_bus_exit();
2395 }
2396
2397 return rc;
2398}
2399
2400static void __exit phy_exit(void)
2401{
2402 phy_driver_unregister(&genphy_c45_driver);
2403 phy_driver_unregister(&genphy_driver);
2404 mdio_bus_exit();
2405}
2406
2407subsys_initcall(phy_init);
2408module_exit(phy_exit);