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/* Framework for finding and configuring PHYs.
2 * Also contains generic PHY driver
3 *
4 * Author: Andy Fleming
5 *
6 * Copyright (c) 2004 Freescale Semiconductor, Inc.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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#include <linux/phy_led_triggers.h>
34#include <linux/mdio.h>
35#include <linux/io.h>
36#include <linux/uaccess.h>
37#include <linux/of.h>
38
39#include <asm/irq.h>
40
41MODULE_DESCRIPTION("PHY library");
42MODULE_AUTHOR("Andy Fleming");
43MODULE_LICENSE("GPL");
44
45void phy_device_free(struct phy_device *phydev)
46{
47 put_device(&phydev->mdio.dev);
48}
49EXPORT_SYMBOL(phy_device_free);
50
51static void phy_mdio_device_free(struct mdio_device *mdiodev)
52{
53 struct phy_device *phydev;
54
55 phydev = container_of(mdiodev, struct phy_device, mdio);
56 phy_device_free(phydev);
57}
58
59static void phy_device_release(struct device *dev)
60{
61 kfree(to_phy_device(dev));
62}
63
64static void phy_mdio_device_remove(struct mdio_device *mdiodev)
65{
66 struct phy_device *phydev;
67
68 phydev = container_of(mdiodev, struct phy_device, mdio);
69 phy_device_remove(phydev);
70}
71
72enum genphy_driver {
73 GENPHY_DRV_1G,
74 GENPHY_DRV_10G,
75 GENPHY_DRV_MAX
76};
77
78static struct phy_driver genphy_driver[GENPHY_DRV_MAX];
79
80static LIST_HEAD(phy_fixup_list);
81static DEFINE_MUTEX(phy_fixup_lock);
82
83#ifdef CONFIG_PM
84static bool mdio_bus_phy_may_suspend(struct phy_device *phydev)
85{
86 struct device_driver *drv = phydev->mdio.dev.driver;
87 struct phy_driver *phydrv = to_phy_driver(drv);
88 struct net_device *netdev = phydev->attached_dev;
89
90 if (!drv || !phydrv->suspend)
91 return false;
92
93 /* PHY not attached? May suspend if the PHY has not already been
94 * suspended as part of a prior call to phy_disconnect() ->
95 * phy_detach() -> phy_suspend() because the parent netdev might be the
96 * MDIO bus driver and clock gated at this point.
97 */
98 if (!netdev)
99 return !phydev->suspended;
100
101 /* Don't suspend PHY if the attached netdev parent may wakeup.
102 * The parent may point to a PCI device, as in tg3 driver.
103 */
104 if (netdev->dev.parent && device_may_wakeup(netdev->dev.parent))
105 return false;
106
107 /* Also don't suspend PHY if the netdev itself may wakeup. This
108 * is the case for devices w/o underlaying pwr. mgmt. aware bus,
109 * e.g. SoC devices.
110 */
111 if (device_may_wakeup(&netdev->dev))
112 return false;
113
114 return true;
115}
116
117static int mdio_bus_phy_suspend(struct device *dev)
118{
119 struct phy_device *phydev = to_phy_device(dev);
120
121 /* We must stop the state machine manually, otherwise it stops out of
122 * control, possibly with the phydev->lock held. Upon resume, netdev
123 * may call phy routines that try to grab the same lock, and that may
124 * lead to a deadlock.
125 */
126 if (phydev->attached_dev && phydev->adjust_link)
127 phy_stop_machine(phydev);
128
129 if (!mdio_bus_phy_may_suspend(phydev))
130 return 0;
131
132 return phy_suspend(phydev);
133}
134
135static int mdio_bus_phy_resume(struct device *dev)
136{
137 struct phy_device *phydev = to_phy_device(dev);
138 int ret;
139
140 if (!mdio_bus_phy_may_suspend(phydev))
141 goto no_resume;
142
143 ret = phy_resume(phydev);
144 if (ret < 0)
145 return ret;
146
147no_resume:
148 if (phydev->attached_dev && phydev->adjust_link)
149 phy_start_machine(phydev);
150
151 return 0;
152}
153
154static int mdio_bus_phy_restore(struct device *dev)
155{
156 struct phy_device *phydev = to_phy_device(dev);
157 struct net_device *netdev = phydev->attached_dev;
158 int ret;
159
160 if (!netdev)
161 return 0;
162
163 ret = phy_init_hw(phydev);
164 if (ret < 0)
165 return ret;
166
167 /* The PHY needs to renegotiate. */
168 phydev->link = 0;
169 phydev->state = PHY_UP;
170
171 phy_start_machine(phydev);
172
173 return 0;
174}
175
176static const struct dev_pm_ops mdio_bus_phy_pm_ops = {
177 .suspend = mdio_bus_phy_suspend,
178 .resume = mdio_bus_phy_resume,
179 .freeze = mdio_bus_phy_suspend,
180 .thaw = mdio_bus_phy_resume,
181 .restore = mdio_bus_phy_restore,
182};
183
184#define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
185
186#else
187
188#define MDIO_BUS_PHY_PM_OPS NULL
189
190#endif /* CONFIG_PM */
191
192/**
193 * phy_register_fixup - creates a new phy_fixup and adds it to the list
194 * @bus_id: A string which matches phydev->mdio.dev.bus_id (or PHY_ANY_ID)
195 * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
196 * It can also be PHY_ANY_UID
197 * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
198 * comparison
199 * @run: The actual code to be run when a matching PHY is found
200 */
201int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
202 int (*run)(struct phy_device *))
203{
204 struct phy_fixup *fixup = kzalloc(sizeof(*fixup), GFP_KERNEL);
205
206 if (!fixup)
207 return -ENOMEM;
208
209 strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
210 fixup->phy_uid = phy_uid;
211 fixup->phy_uid_mask = phy_uid_mask;
212 fixup->run = run;
213
214 mutex_lock(&phy_fixup_lock);
215 list_add_tail(&fixup->list, &phy_fixup_list);
216 mutex_unlock(&phy_fixup_lock);
217
218 return 0;
219}
220EXPORT_SYMBOL(phy_register_fixup);
221
222/* Registers a fixup to be run on any PHY with the UID in phy_uid */
223int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
224 int (*run)(struct phy_device *))
225{
226 return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
227}
228EXPORT_SYMBOL(phy_register_fixup_for_uid);
229
230/* Registers a fixup to be run on the PHY with id string bus_id */
231int phy_register_fixup_for_id(const char *bus_id,
232 int (*run)(struct phy_device *))
233{
234 return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
235}
236EXPORT_SYMBOL(phy_register_fixup_for_id);
237
238/**
239 * phy_unregister_fixup - remove a phy_fixup from the list
240 * @bus_id: A string matches fixup->bus_id (or PHY_ANY_ID) in phy_fixup_list
241 * @phy_uid: A phy id matches fixup->phy_id (or PHY_ANY_UID) in phy_fixup_list
242 * @phy_uid_mask: Applied to phy_uid and fixup->phy_uid before comparison
243 */
244int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask)
245{
246 struct list_head *pos, *n;
247 struct phy_fixup *fixup;
248 int ret;
249
250 ret = -ENODEV;
251
252 mutex_lock(&phy_fixup_lock);
253 list_for_each_safe(pos, n, &phy_fixup_list) {
254 fixup = list_entry(pos, struct phy_fixup, list);
255
256 if ((!strcmp(fixup->bus_id, bus_id)) &&
257 ((fixup->phy_uid & phy_uid_mask) ==
258 (phy_uid & phy_uid_mask))) {
259 list_del(&fixup->list);
260 kfree(fixup);
261 ret = 0;
262 break;
263 }
264 }
265 mutex_unlock(&phy_fixup_lock);
266
267 return ret;
268}
269EXPORT_SYMBOL(phy_unregister_fixup);
270
271/* Unregisters a fixup of any PHY with the UID in phy_uid */
272int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask)
273{
274 return phy_unregister_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask);
275}
276EXPORT_SYMBOL(phy_unregister_fixup_for_uid);
277
278/* Unregisters a fixup of the PHY with id string bus_id */
279int phy_unregister_fixup_for_id(const char *bus_id)
280{
281 return phy_unregister_fixup(bus_id, PHY_ANY_UID, 0xffffffff);
282}
283EXPORT_SYMBOL(phy_unregister_fixup_for_id);
284
285/* Returns 1 if fixup matches phydev in bus_id and phy_uid.
286 * Fixups can be set to match any in one or more fields.
287 */
288static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
289{
290 if (strcmp(fixup->bus_id, phydev_name(phydev)) != 0)
291 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
292 return 0;
293
294 if ((fixup->phy_uid & fixup->phy_uid_mask) !=
295 (phydev->phy_id & fixup->phy_uid_mask))
296 if (fixup->phy_uid != PHY_ANY_UID)
297 return 0;
298
299 return 1;
300}
301
302/* Runs any matching fixups for this phydev */
303static int phy_scan_fixups(struct phy_device *phydev)
304{
305 struct phy_fixup *fixup;
306
307 mutex_lock(&phy_fixup_lock);
308 list_for_each_entry(fixup, &phy_fixup_list, list) {
309 if (phy_needs_fixup(phydev, fixup)) {
310 int err = fixup->run(phydev);
311
312 if (err < 0) {
313 mutex_unlock(&phy_fixup_lock);
314 return err;
315 }
316 phydev->has_fixups = true;
317 }
318 }
319 mutex_unlock(&phy_fixup_lock);
320
321 return 0;
322}
323
324static int phy_bus_match(struct device *dev, struct device_driver *drv)
325{
326 struct phy_device *phydev = to_phy_device(dev);
327 struct phy_driver *phydrv = to_phy_driver(drv);
328 const int num_ids = ARRAY_SIZE(phydev->c45_ids.device_ids);
329 int i;
330
331 if (!(phydrv->mdiodrv.flags & MDIO_DEVICE_IS_PHY))
332 return 0;
333
334 if (phydrv->match_phy_device)
335 return phydrv->match_phy_device(phydev);
336
337 if (phydev->is_c45) {
338 for (i = 1; i < num_ids; i++) {
339 if (!(phydev->c45_ids.devices_in_package & (1 << i)))
340 continue;
341
342 if ((phydrv->phy_id & phydrv->phy_id_mask) ==
343 (phydev->c45_ids.device_ids[i] &
344 phydrv->phy_id_mask))
345 return 1;
346 }
347 return 0;
348 } else {
349 return (phydrv->phy_id & phydrv->phy_id_mask) ==
350 (phydev->phy_id & phydrv->phy_id_mask);
351 }
352}
353
354struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
355 bool is_c45,
356 struct phy_c45_device_ids *c45_ids)
357{
358 struct phy_device *dev;
359 struct mdio_device *mdiodev;
360
361 /* We allocate the device, and initialize the default values */
362 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
363 if (!dev)
364 return ERR_PTR(-ENOMEM);
365
366 mdiodev = &dev->mdio;
367 mdiodev->dev.release = phy_device_release;
368 mdiodev->dev.parent = &bus->dev;
369 mdiodev->dev.bus = &mdio_bus_type;
370 mdiodev->bus = bus;
371 mdiodev->pm_ops = MDIO_BUS_PHY_PM_OPS;
372 mdiodev->bus_match = phy_bus_match;
373 mdiodev->addr = addr;
374 mdiodev->flags = MDIO_DEVICE_FLAG_PHY;
375 mdiodev->device_free = phy_mdio_device_free;
376 mdiodev->device_remove = phy_mdio_device_remove;
377
378 dev->speed = 0;
379 dev->duplex = -1;
380 dev->pause = 0;
381 dev->asym_pause = 0;
382 dev->link = 1;
383 dev->interface = PHY_INTERFACE_MODE_GMII;
384
385 dev->autoneg = AUTONEG_ENABLE;
386
387 dev->is_c45 = is_c45;
388 dev->phy_id = phy_id;
389 if (c45_ids)
390 dev->c45_ids = *c45_ids;
391 dev->irq = bus->irq[addr];
392 dev_set_name(&mdiodev->dev, PHY_ID_FMT, bus->id, addr);
393
394 dev->state = PHY_DOWN;
395
396 mutex_init(&dev->lock);
397 INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
398 INIT_WORK(&dev->phy_queue, phy_change_work);
399
400 /* Request the appropriate module unconditionally; don't
401 * bother trying to do so only if it isn't already loaded,
402 * because that gets complicated. A hotplug event would have
403 * done an unconditional modprobe anyway.
404 * We don't do normal hotplug because it won't work for MDIO
405 * -- because it relies on the device staying around for long
406 * enough for the driver to get loaded. With MDIO, the NIC
407 * driver will get bored and give up as soon as it finds that
408 * there's no driver _already_ loaded.
409 */
410 request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
411
412 device_initialize(&mdiodev->dev);
413
414 return dev;
415}
416EXPORT_SYMBOL(phy_device_create);
417
418/* get_phy_c45_devs_in_pkg - reads a MMD's devices in package registers.
419 * @bus: the target MII bus
420 * @addr: PHY address on the MII bus
421 * @dev_addr: MMD address in the PHY.
422 * @devices_in_package: where to store the devices in package information.
423 *
424 * Description: reads devices in package registers of a MMD at @dev_addr
425 * from PHY at @addr on @bus.
426 *
427 * Returns: 0 on success, -EIO on failure.
428 */
429static int get_phy_c45_devs_in_pkg(struct mii_bus *bus, int addr, int dev_addr,
430 u32 *devices_in_package)
431{
432 int phy_reg, reg_addr;
433
434 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS2;
435 phy_reg = mdiobus_read(bus, addr, reg_addr);
436 if (phy_reg < 0)
437 return -EIO;
438 *devices_in_package = (phy_reg & 0xffff) << 16;
439
440 reg_addr = MII_ADDR_C45 | dev_addr << 16 | MDIO_DEVS1;
441 phy_reg = mdiobus_read(bus, addr, reg_addr);
442 if (phy_reg < 0)
443 return -EIO;
444 *devices_in_package |= (phy_reg & 0xffff);
445
446 return 0;
447}
448
449/**
450 * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
451 * @bus: the target MII bus
452 * @addr: PHY address on the MII bus
453 * @phy_id: where to store the ID retrieved.
454 * @c45_ids: where to store the c45 ID information.
455 *
456 * If the PHY devices-in-package appears to be valid, it and the
457 * corresponding identifiers are stored in @c45_ids, zero is stored
458 * in @phy_id. Otherwise 0xffffffff is stored in @phy_id. Returns
459 * zero on success.
460 *
461 */
462static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
463 struct phy_c45_device_ids *c45_ids) {
464 int phy_reg;
465 int i, reg_addr;
466 const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
467 u32 *devs = &c45_ids->devices_in_package;
468
469 /* Find first non-zero Devices In package. Device zero is reserved
470 * for 802.3 c45 complied PHYs, so don't probe it at first.
471 */
472 for (i = 1; i < num_ids && *devs == 0; i++) {
473 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, i, devs);
474 if (phy_reg < 0)
475 return -EIO;
476
477 if ((*devs & 0x1fffffff) == 0x1fffffff) {
478 /* If mostly Fs, there is no device there,
479 * then let's continue to probe more, as some
480 * 10G PHYs have zero Devices In package,
481 * e.g. Cortina CS4315/CS4340 PHY.
482 */
483 phy_reg = get_phy_c45_devs_in_pkg(bus, addr, 0, devs);
484 if (phy_reg < 0)
485 return -EIO;
486 /* no device there, let's get out of here */
487 if ((*devs & 0x1fffffff) == 0x1fffffff) {
488 *phy_id = 0xffffffff;
489 return 0;
490 } else {
491 break;
492 }
493 }
494 }
495
496 /* Now probe Device Identifiers for each device present. */
497 for (i = 1; i < num_ids; i++) {
498 if (!(c45_ids->devices_in_package & (1 << i)))
499 continue;
500
501 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
502 phy_reg = mdiobus_read(bus, addr, reg_addr);
503 if (phy_reg < 0)
504 return -EIO;
505 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
506
507 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
508 phy_reg = mdiobus_read(bus, addr, reg_addr);
509 if (phy_reg < 0)
510 return -EIO;
511 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
512 }
513 *phy_id = 0;
514 return 0;
515}
516
517/**
518 * get_phy_id - reads the specified addr for its ID.
519 * @bus: the target MII bus
520 * @addr: PHY address on the MII bus
521 * @phy_id: where to store the ID retrieved.
522 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
523 * @c45_ids: where to store the c45 ID information.
524 *
525 * Description: In the case of a 802.3-c22 PHY, reads the ID registers
526 * of the PHY at @addr on the @bus, stores it in @phy_id and returns
527 * zero on success.
528 *
529 * In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
530 * its return value is in turn returned.
531 *
532 */
533static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
534 bool is_c45, struct phy_c45_device_ids *c45_ids)
535{
536 int phy_reg;
537
538 if (is_c45)
539 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
540
541 /* Grab the bits from PHYIR1, and put them in the upper half */
542 phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
543 if (phy_reg < 0)
544 return -EIO;
545
546 *phy_id = (phy_reg & 0xffff) << 16;
547
548 /* Grab the bits from PHYIR2, and put them in the lower half */
549 phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
550 if (phy_reg < 0)
551 return -EIO;
552
553 *phy_id |= (phy_reg & 0xffff);
554
555 return 0;
556}
557
558/**
559 * get_phy_device - reads the specified PHY device and returns its @phy_device
560 * struct
561 * @bus: the target MII bus
562 * @addr: PHY address on the MII bus
563 * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
564 *
565 * Description: Reads the ID registers of the PHY at @addr on the
566 * @bus, then allocates and returns the phy_device to represent it.
567 */
568struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
569{
570 struct phy_c45_device_ids c45_ids = {0};
571 u32 phy_id = 0;
572 int r;
573
574 r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
575 if (r)
576 return ERR_PTR(r);
577
578 /* If the phy_id is mostly Fs, there is no device there */
579 if ((phy_id & 0x1fffffff) == 0x1fffffff)
580 return ERR_PTR(-ENODEV);
581
582 return phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
583}
584EXPORT_SYMBOL(get_phy_device);
585
586static ssize_t
587phy_id_show(struct device *dev, struct device_attribute *attr, char *buf)
588{
589 struct phy_device *phydev = to_phy_device(dev);
590
591 return sprintf(buf, "0x%.8lx\n", (unsigned long)phydev->phy_id);
592}
593static DEVICE_ATTR_RO(phy_id);
594
595static ssize_t
596phy_interface_show(struct device *dev, struct device_attribute *attr, char *buf)
597{
598 struct phy_device *phydev = to_phy_device(dev);
599 const char *mode = NULL;
600
601 if (phy_is_internal(phydev))
602 mode = "internal";
603 else
604 mode = phy_modes(phydev->interface);
605
606 return sprintf(buf, "%s\n", mode);
607}
608static DEVICE_ATTR_RO(phy_interface);
609
610static ssize_t
611phy_has_fixups_show(struct device *dev, struct device_attribute *attr,
612 char *buf)
613{
614 struct phy_device *phydev = to_phy_device(dev);
615
616 return sprintf(buf, "%d\n", phydev->has_fixups);
617}
618static DEVICE_ATTR_RO(phy_has_fixups);
619
620static struct attribute *phy_dev_attrs[] = {
621 &dev_attr_phy_id.attr,
622 &dev_attr_phy_interface.attr,
623 &dev_attr_phy_has_fixups.attr,
624 NULL,
625};
626ATTRIBUTE_GROUPS(phy_dev);
627
628/**
629 * phy_device_register - Register the phy device on the MDIO bus
630 * @phydev: phy_device structure to be added to the MDIO bus
631 */
632int phy_device_register(struct phy_device *phydev)
633{
634 int err;
635
636 err = mdiobus_register_device(&phydev->mdio);
637 if (err)
638 return err;
639
640 /* Run all of the fixups for this PHY */
641 err = phy_scan_fixups(phydev);
642 if (err) {
643 pr_err("PHY %d failed to initialize\n", phydev->mdio.addr);
644 goto out;
645 }
646
647 phydev->mdio.dev.groups = phy_dev_groups;
648
649 err = device_add(&phydev->mdio.dev);
650 if (err) {
651 pr_err("PHY %d failed to add\n", phydev->mdio.addr);
652 goto out;
653 }
654
655 return 0;
656
657 out:
658 mdiobus_unregister_device(&phydev->mdio);
659 return err;
660}
661EXPORT_SYMBOL(phy_device_register);
662
663/**
664 * phy_device_remove - Remove a previously registered phy device from the MDIO bus
665 * @phydev: phy_device structure to remove
666 *
667 * This doesn't free the phy_device itself, it merely reverses the effects
668 * of phy_device_register(). Use phy_device_free() to free the device
669 * after calling this function.
670 */
671void phy_device_remove(struct phy_device *phydev)
672{
673 device_del(&phydev->mdio.dev);
674 mdiobus_unregister_device(&phydev->mdio);
675}
676EXPORT_SYMBOL(phy_device_remove);
677
678/**
679 * phy_find_first - finds the first PHY device on the bus
680 * @bus: the target MII bus
681 */
682struct phy_device *phy_find_first(struct mii_bus *bus)
683{
684 struct phy_device *phydev;
685 int addr;
686
687 for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
688 phydev = mdiobus_get_phy(bus, addr);
689 if (phydev)
690 return phydev;
691 }
692 return NULL;
693}
694EXPORT_SYMBOL(phy_find_first);
695
696/**
697 * phy_prepare_link - prepares the PHY layer to monitor link status
698 * @phydev: target phy_device struct
699 * @handler: callback function for link status change notifications
700 *
701 * Description: Tells the PHY infrastructure to handle the
702 * gory details on monitoring link status (whether through
703 * polling or an interrupt), and to call back to the
704 * connected device driver when the link status changes.
705 * If you want to monitor your own link state, don't call
706 * this function.
707 */
708static void phy_prepare_link(struct phy_device *phydev,
709 void (*handler)(struct net_device *))
710{
711 phydev->adjust_link = handler;
712}
713
714/**
715 * phy_connect_direct - connect an ethernet device to a specific phy_device
716 * @dev: the network device to connect
717 * @phydev: the pointer to the phy device
718 * @handler: callback function for state change notifications
719 * @interface: PHY device's interface
720 */
721int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
722 void (*handler)(struct net_device *),
723 phy_interface_t interface)
724{
725 int rc;
726
727 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
728 if (rc)
729 return rc;
730
731 phy_prepare_link(phydev, handler);
732 phy_start_machine(phydev);
733 if (phydev->irq > 0)
734 phy_start_interrupts(phydev);
735
736 return 0;
737}
738EXPORT_SYMBOL(phy_connect_direct);
739
740/**
741 * phy_connect - connect an ethernet device to a PHY device
742 * @dev: the network device to connect
743 * @bus_id: the id string of the PHY device to connect
744 * @handler: callback function for state change notifications
745 * @interface: PHY device's interface
746 *
747 * Description: Convenience function for connecting ethernet
748 * devices to PHY devices. The default behavior is for
749 * the PHY infrastructure to handle everything, and only notify
750 * the connected driver when the link status changes. If you
751 * don't want, or can't use the provided functionality, you may
752 * choose to call only the subset of functions which provide
753 * the desired functionality.
754 */
755struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
756 void (*handler)(struct net_device *),
757 phy_interface_t interface)
758{
759 struct phy_device *phydev;
760 struct device *d;
761 int rc;
762
763 /* Search the list of PHY devices on the mdio bus for the
764 * PHY with the requested name
765 */
766 d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
767 if (!d) {
768 pr_err("PHY %s not found\n", bus_id);
769 return ERR_PTR(-ENODEV);
770 }
771 phydev = to_phy_device(d);
772
773 rc = phy_connect_direct(dev, phydev, handler, interface);
774 put_device(d);
775 if (rc)
776 return ERR_PTR(rc);
777
778 return phydev;
779}
780EXPORT_SYMBOL(phy_connect);
781
782/**
783 * phy_disconnect - disable interrupts, stop state machine, and detach a PHY
784 * device
785 * @phydev: target phy_device struct
786 */
787void phy_disconnect(struct phy_device *phydev)
788{
789 if (phydev->irq > 0)
790 phy_stop_interrupts(phydev);
791
792 phy_stop_machine(phydev);
793
794 phydev->adjust_link = NULL;
795
796 phy_detach(phydev);
797}
798EXPORT_SYMBOL(phy_disconnect);
799
800/**
801 * phy_poll_reset - Safely wait until a PHY reset has properly completed
802 * @phydev: The PHY device to poll
803 *
804 * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
805 * published in 2008, a PHY reset may take up to 0.5 seconds. The MII BMCR
806 * register must be polled until the BMCR_RESET bit clears.
807 *
808 * Furthermore, any attempts to write to PHY registers may have no effect
809 * or even generate MDIO bus errors until this is complete.
810 *
811 * Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
812 * standard and do not fully reset after the BMCR_RESET bit is set, and may
813 * even *REQUIRE* a soft-reset to properly restart autonegotiation. In an
814 * effort to support such broken PHYs, this function is separate from the
815 * standard phy_init_hw() which will zero all the other bits in the BMCR
816 * and reapply all driver-specific and board-specific fixups.
817 */
818static int phy_poll_reset(struct phy_device *phydev)
819{
820 /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
821 unsigned int retries = 12;
822 int ret;
823
824 do {
825 msleep(50);
826 ret = phy_read(phydev, MII_BMCR);
827 if (ret < 0)
828 return ret;
829 } while (ret & BMCR_RESET && --retries);
830 if (ret & BMCR_RESET)
831 return -ETIMEDOUT;
832
833 /* Some chips (smsc911x) may still need up to another 1ms after the
834 * BMCR_RESET bit is cleared before they are usable.
835 */
836 msleep(1);
837 return 0;
838}
839
840int phy_init_hw(struct phy_device *phydev)
841{
842 int ret = 0;
843
844 if (!phydev->drv || !phydev->drv->config_init)
845 return 0;
846
847 if (phydev->drv->soft_reset)
848 ret = phydev->drv->soft_reset(phydev);
849 else
850 ret = genphy_soft_reset(phydev);
851
852 if (ret < 0)
853 return ret;
854
855 ret = phy_scan_fixups(phydev);
856 if (ret < 0)
857 return ret;
858
859 return phydev->drv->config_init(phydev);
860}
861EXPORT_SYMBOL(phy_init_hw);
862
863void phy_attached_info(struct phy_device *phydev)
864{
865 phy_attached_print(phydev, NULL);
866}
867EXPORT_SYMBOL(phy_attached_info);
868
869#define ATTACHED_FMT "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)"
870void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
871{
872 if (!fmt) {
873 dev_info(&phydev->mdio.dev, ATTACHED_FMT "\n",
874 phydev->drv->name, phydev_name(phydev),
875 phydev->irq);
876 } else {
877 va_list ap;
878
879 dev_info(&phydev->mdio.dev, ATTACHED_FMT,
880 phydev->drv->name, phydev_name(phydev),
881 phydev->irq);
882
883 va_start(ap, fmt);
884 vprintk(fmt, ap);
885 va_end(ap);
886 }
887}
888EXPORT_SYMBOL(phy_attached_print);
889
890/**
891 * phy_attach_direct - attach a network device to a given PHY device pointer
892 * @dev: network device to attach
893 * @phydev: Pointer to phy_device to attach
894 * @flags: PHY device's dev_flags
895 * @interface: PHY device's interface
896 *
897 * Description: Called by drivers to attach to a particular PHY
898 * device. The phy_device is found, and properly hooked up
899 * to the phy_driver. If no driver is attached, then a
900 * generic driver is used. The phy_device is given a ptr to
901 * the attaching device, and given a callback for link status
902 * change. The phy_device is returned to the attaching driver.
903 * This function takes a reference on the phy device.
904 */
905int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
906 u32 flags, phy_interface_t interface)
907{
908 struct module *ndev_owner = dev->dev.parent->driver->owner;
909 struct mii_bus *bus = phydev->mdio.bus;
910 struct device *d = &phydev->mdio.dev;
911 bool using_genphy = false;
912 int err;
913
914 /* For Ethernet device drivers that register their own MDIO bus, we
915 * will have bus->owner match ndev_mod, so we do not want to increment
916 * our own module->refcnt here, otherwise we would not be able to
917 * unload later on.
918 */
919 if (ndev_owner != bus->owner && !try_module_get(bus->owner)) {
920 dev_err(&dev->dev, "failed to get the bus module\n");
921 return -EIO;
922 }
923
924 get_device(d);
925
926 /* Assume that if there is no driver, that it doesn't
927 * exist, and we should use the genphy driver.
928 */
929 if (!d->driver) {
930 if (phydev->is_c45)
931 d->driver =
932 &genphy_driver[GENPHY_DRV_10G].mdiodrv.driver;
933 else
934 d->driver =
935 &genphy_driver[GENPHY_DRV_1G].mdiodrv.driver;
936
937 using_genphy = true;
938 }
939
940 if (!try_module_get(d->driver->owner)) {
941 dev_err(&dev->dev, "failed to get the device driver module\n");
942 err = -EIO;
943 goto error_put_device;
944 }
945
946 if (using_genphy) {
947 err = d->driver->probe(d);
948 if (err >= 0)
949 err = device_bind_driver(d);
950
951 if (err)
952 goto error_module_put;
953 }
954
955 if (phydev->attached_dev) {
956 dev_err(&dev->dev, "PHY already attached\n");
957 err = -EBUSY;
958 goto error;
959 }
960
961 phydev->attached_dev = dev;
962 dev->phydev = phydev;
963
964 phydev->dev_flags = flags;
965
966 phydev->interface = interface;
967
968 phydev->state = PHY_READY;
969
970 /* Initial carrier state is off as the phy is about to be
971 * (re)initialized.
972 */
973 netif_carrier_off(phydev->attached_dev);
974
975 /* Do initial configuration here, now that
976 * we have certain key parameters
977 * (dev_flags and interface)
978 */
979 err = phy_init_hw(phydev);
980 if (err)
981 goto error;
982
983 phy_resume(phydev);
984 phy_led_triggers_register(phydev);
985
986 return err;
987
988error:
989 /* phy_detach() does all of the cleanup below */
990 phy_detach(phydev);
991 return err;
992
993error_module_put:
994 module_put(d->driver->owner);
995error_put_device:
996 put_device(d);
997 if (ndev_owner != bus->owner)
998 module_put(bus->owner);
999 return err;
1000}
1001EXPORT_SYMBOL(phy_attach_direct);
1002
1003/**
1004 * phy_attach - attach a network device to a particular PHY device
1005 * @dev: network device to attach
1006 * @bus_id: Bus ID of PHY device to attach
1007 * @interface: PHY device's interface
1008 *
1009 * Description: Same as phy_attach_direct() except that a PHY bus_id
1010 * string is passed instead of a pointer to a struct phy_device.
1011 */
1012struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
1013 phy_interface_t interface)
1014{
1015 struct bus_type *bus = &mdio_bus_type;
1016 struct phy_device *phydev;
1017 struct device *d;
1018 int rc;
1019
1020 /* Search the list of PHY devices on the mdio bus for the
1021 * PHY with the requested name
1022 */
1023 d = bus_find_device_by_name(bus, NULL, bus_id);
1024 if (!d) {
1025 pr_err("PHY %s not found\n", bus_id);
1026 return ERR_PTR(-ENODEV);
1027 }
1028 phydev = to_phy_device(d);
1029
1030 rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
1031 put_device(d);
1032 if (rc)
1033 return ERR_PTR(rc);
1034
1035 return phydev;
1036}
1037EXPORT_SYMBOL(phy_attach);
1038
1039/**
1040 * phy_detach - detach a PHY device from its network device
1041 * @phydev: target phy_device struct
1042 *
1043 * This detaches the phy device from its network device and the phy
1044 * driver, and drops the reference count taken in phy_attach_direct().
1045 */
1046void phy_detach(struct phy_device *phydev)
1047{
1048 struct net_device *dev = phydev->attached_dev;
1049 struct module *ndev_owner = dev->dev.parent->driver->owner;
1050 struct mii_bus *bus;
1051 int i;
1052
1053 phydev->attached_dev->phydev = NULL;
1054 phydev->attached_dev = NULL;
1055 phy_suspend(phydev);
1056
1057 phy_led_triggers_unregister(phydev);
1058
1059 module_put(phydev->mdio.dev.driver->owner);
1060
1061 /* If the device had no specific driver before (i.e. - it
1062 * was using the generic driver), we unbind the device
1063 * from the generic driver so that there's a chance a
1064 * real driver could be loaded
1065 */
1066 for (i = 0; i < ARRAY_SIZE(genphy_driver); i++) {
1067 if (phydev->mdio.dev.driver ==
1068 &genphy_driver[i].mdiodrv.driver) {
1069 device_release_driver(&phydev->mdio.dev);
1070 break;
1071 }
1072 }
1073
1074 /*
1075 * The phydev might go away on the put_device() below, so avoid
1076 * a use-after-free bug by reading the underlying bus first.
1077 */
1078 bus = phydev->mdio.bus;
1079
1080 put_device(&phydev->mdio.dev);
1081 if (ndev_owner != bus->owner)
1082 module_put(bus->owner);
1083}
1084EXPORT_SYMBOL(phy_detach);
1085
1086int phy_suspend(struct phy_device *phydev)
1087{
1088 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1089 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1090 int ret = 0;
1091
1092 /* If the device has WOL enabled, we cannot suspend the PHY */
1093 phy_ethtool_get_wol(phydev, &wol);
1094 if (wol.wolopts)
1095 return -EBUSY;
1096
1097 if (phydrv->suspend)
1098 ret = phydrv->suspend(phydev);
1099
1100 if (ret)
1101 return ret;
1102
1103 phydev->suspended = true;
1104
1105 return ret;
1106}
1107EXPORT_SYMBOL(phy_suspend);
1108
1109int phy_resume(struct phy_device *phydev)
1110{
1111 struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver);
1112 int ret = 0;
1113
1114 if (phydrv->resume)
1115 ret = phydrv->resume(phydev);
1116
1117 if (ret)
1118 return ret;
1119
1120 phydev->suspended = false;
1121
1122 return ret;
1123}
1124EXPORT_SYMBOL(phy_resume);
1125
1126/* Generic PHY support and helper functions */
1127
1128/**
1129 * genphy_config_advert - sanitize and advertise auto-negotiation parameters
1130 * @phydev: target phy_device struct
1131 *
1132 * Description: Writes MII_ADVERTISE with the appropriate values,
1133 * after sanitizing the values to make sure we only advertise
1134 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement
1135 * hasn't changed, and > 0 if it has changed.
1136 */
1137static int genphy_config_advert(struct phy_device *phydev)
1138{
1139 u32 advertise;
1140 int oldadv, adv, bmsr;
1141 int err, changed = 0;
1142
1143 /* Only allow advertising what this PHY supports */
1144 phydev->advertising &= phydev->supported;
1145 advertise = phydev->advertising;
1146
1147 /* Setup standard advertisement */
1148 adv = phy_read(phydev, MII_ADVERTISE);
1149 if (adv < 0)
1150 return adv;
1151
1152 oldadv = adv;
1153 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
1154 ADVERTISE_PAUSE_ASYM);
1155 adv |= ethtool_adv_to_mii_adv_t(advertise);
1156
1157 if (adv != oldadv) {
1158 err = phy_write(phydev, MII_ADVERTISE, adv);
1159
1160 if (err < 0)
1161 return err;
1162 changed = 1;
1163 }
1164
1165 bmsr = phy_read(phydev, MII_BMSR);
1166 if (bmsr < 0)
1167 return bmsr;
1168
1169 /* Per 802.3-2008, Section 22.2.4.2.16 Extended status all
1170 * 1000Mbits/sec capable PHYs shall have the BMSR_ESTATEN bit set to a
1171 * logical 1.
1172 */
1173 if (!(bmsr & BMSR_ESTATEN))
1174 return changed;
1175
1176 /* Configure gigabit if it's supported */
1177 adv = phy_read(phydev, MII_CTRL1000);
1178 if (adv < 0)
1179 return adv;
1180
1181 oldadv = adv;
1182 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
1183
1184 if (phydev->supported & (SUPPORTED_1000baseT_Half |
1185 SUPPORTED_1000baseT_Full)) {
1186 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
1187 }
1188
1189 if (adv != oldadv)
1190 changed = 1;
1191
1192 err = phy_write(phydev, MII_CTRL1000, adv);
1193 if (err < 0)
1194 return err;
1195
1196 return changed;
1197}
1198
1199/**
1200 * genphy_config_eee_advert - disable unwanted eee mode advertisement
1201 * @phydev: target phy_device struct
1202 *
1203 * Description: Writes MDIO_AN_EEE_ADV after disabling unsupported energy
1204 * efficent ethernet modes. Returns 0 if the PHY's advertisement hasn't
1205 * changed, and 1 if it has changed.
1206 */
1207static int genphy_config_eee_advert(struct phy_device *phydev)
1208{
1209 int broken = phydev->eee_broken_modes;
1210 int old_adv, adv;
1211
1212 /* Nothing to disable */
1213 if (!broken)
1214 return 0;
1215
1216 /* If the following call fails, we assume that EEE is not
1217 * supported by the phy. If we read 0, EEE is not advertised
1218 * In both case, we don't need to continue
1219 */
1220 adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN);
1221 if (adv <= 0)
1222 return 0;
1223
1224 old_adv = adv;
1225 adv &= ~broken;
1226
1227 /* Advertising remains unchanged with the broken mask */
1228 if (old_adv == adv)
1229 return 0;
1230
1231 phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN, adv);
1232
1233 return 1;
1234}
1235
1236/**
1237 * genphy_setup_forced - configures/forces speed/duplex from @phydev
1238 * @phydev: target phy_device struct
1239 *
1240 * Description: Configures MII_BMCR to force speed/duplex
1241 * to the values in phydev. Assumes that the values are valid.
1242 * Please see phy_sanitize_settings().
1243 */
1244int genphy_setup_forced(struct phy_device *phydev)
1245{
1246 int ctl = phy_read(phydev, MII_BMCR);
1247
1248 ctl &= BMCR_LOOPBACK | BMCR_ISOLATE | BMCR_PDOWN;
1249 phydev->pause = 0;
1250 phydev->asym_pause = 0;
1251
1252 if (SPEED_1000 == phydev->speed)
1253 ctl |= BMCR_SPEED1000;
1254 else if (SPEED_100 == phydev->speed)
1255 ctl |= BMCR_SPEED100;
1256
1257 if (DUPLEX_FULL == phydev->duplex)
1258 ctl |= BMCR_FULLDPLX;
1259
1260 return phy_write(phydev, MII_BMCR, ctl);
1261}
1262EXPORT_SYMBOL(genphy_setup_forced);
1263
1264/**
1265 * genphy_restart_aneg - Enable and Restart Autonegotiation
1266 * @phydev: target phy_device struct
1267 */
1268int genphy_restart_aneg(struct phy_device *phydev)
1269{
1270 int ctl = phy_read(phydev, MII_BMCR);
1271
1272 if (ctl < 0)
1273 return ctl;
1274
1275 ctl |= BMCR_ANENABLE | BMCR_ANRESTART;
1276
1277 /* Don't isolate the PHY if we're negotiating */
1278 ctl &= ~BMCR_ISOLATE;
1279
1280 return phy_write(phydev, MII_BMCR, ctl);
1281}
1282EXPORT_SYMBOL(genphy_restart_aneg);
1283
1284/**
1285 * genphy_config_aneg - restart auto-negotiation or write BMCR
1286 * @phydev: target phy_device struct
1287 *
1288 * Description: If auto-negotiation is enabled, we configure the
1289 * advertising, and then restart auto-negotiation. If it is not
1290 * enabled, then we write the BMCR.
1291 */
1292int genphy_config_aneg(struct phy_device *phydev)
1293{
1294 int err, changed;
1295
1296 changed = genphy_config_eee_advert(phydev);
1297
1298 if (AUTONEG_ENABLE != phydev->autoneg)
1299 return genphy_setup_forced(phydev);
1300
1301 err = genphy_config_advert(phydev);
1302 if (err < 0) /* error */
1303 return err;
1304
1305 changed |= err;
1306
1307 if (changed == 0) {
1308 /* Advertisement hasn't changed, but maybe aneg was never on to
1309 * begin with? Or maybe phy was isolated?
1310 */
1311 int ctl = phy_read(phydev, MII_BMCR);
1312
1313 if (ctl < 0)
1314 return ctl;
1315
1316 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
1317 changed = 1; /* do restart aneg */
1318 }
1319
1320 /* Only restart aneg if we are advertising something different
1321 * than we were before.
1322 */
1323 if (changed > 0)
1324 return genphy_restart_aneg(phydev);
1325
1326 return 0;
1327}
1328EXPORT_SYMBOL(genphy_config_aneg);
1329
1330/**
1331 * genphy_aneg_done - return auto-negotiation status
1332 * @phydev: target phy_device struct
1333 *
1334 * Description: Reads the status register and returns 0 either if
1335 * auto-negotiation is incomplete, or if there was an error.
1336 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done.
1337 */
1338int genphy_aneg_done(struct phy_device *phydev)
1339{
1340 int retval = phy_read(phydev, MII_BMSR);
1341
1342 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE);
1343}
1344EXPORT_SYMBOL(genphy_aneg_done);
1345
1346static int gen10g_config_aneg(struct phy_device *phydev)
1347{
1348 return 0;
1349}
1350
1351/**
1352 * genphy_update_link - update link status in @phydev
1353 * @phydev: target phy_device struct
1354 *
1355 * Description: Update the value in phydev->link to reflect the
1356 * current link value. In order to do this, we need to read
1357 * the status register twice, keeping the second value.
1358 */
1359int genphy_update_link(struct phy_device *phydev)
1360{
1361 int status;
1362
1363 /* Do a fake read */
1364 status = phy_read(phydev, MII_BMSR);
1365 if (status < 0)
1366 return status;
1367
1368 /* Read link and autonegotiation status */
1369 status = phy_read(phydev, MII_BMSR);
1370 if (status < 0)
1371 return status;
1372
1373 if ((status & BMSR_LSTATUS) == 0)
1374 phydev->link = 0;
1375 else
1376 phydev->link = 1;
1377
1378 return 0;
1379}
1380EXPORT_SYMBOL(genphy_update_link);
1381
1382/**
1383 * genphy_read_status - check the link status and update current link state
1384 * @phydev: target phy_device struct
1385 *
1386 * Description: Check the link, then figure out the current state
1387 * by comparing what we advertise with what the link partner
1388 * advertises. Start by checking the gigabit possibilities,
1389 * then move on to 10/100.
1390 */
1391int genphy_read_status(struct phy_device *phydev)
1392{
1393 int adv;
1394 int err;
1395 int lpa;
1396 int lpagb = 0;
1397 int common_adv;
1398 int common_adv_gb = 0;
1399
1400 /* Update the link, but return if there was an error */
1401 err = genphy_update_link(phydev);
1402 if (err)
1403 return err;
1404
1405 phydev->lp_advertising = 0;
1406
1407 if (AUTONEG_ENABLE == phydev->autoneg) {
1408 if (phydev->supported & (SUPPORTED_1000baseT_Half
1409 | SUPPORTED_1000baseT_Full)) {
1410 lpagb = phy_read(phydev, MII_STAT1000);
1411 if (lpagb < 0)
1412 return lpagb;
1413
1414 adv = phy_read(phydev, MII_CTRL1000);
1415 if (adv < 0)
1416 return adv;
1417
1418 phydev->lp_advertising =
1419 mii_stat1000_to_ethtool_lpa_t(lpagb);
1420 common_adv_gb = lpagb & adv << 2;
1421 }
1422
1423 lpa = phy_read(phydev, MII_LPA);
1424 if (lpa < 0)
1425 return lpa;
1426
1427 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
1428
1429 adv = phy_read(phydev, MII_ADVERTISE);
1430 if (adv < 0)
1431 return adv;
1432
1433 common_adv = lpa & adv;
1434
1435 phydev->speed = SPEED_10;
1436 phydev->duplex = DUPLEX_HALF;
1437 phydev->pause = 0;
1438 phydev->asym_pause = 0;
1439
1440 if (common_adv_gb & (LPA_1000FULL | LPA_1000HALF)) {
1441 phydev->speed = SPEED_1000;
1442
1443 if (common_adv_gb & LPA_1000FULL)
1444 phydev->duplex = DUPLEX_FULL;
1445 } else if (common_adv & (LPA_100FULL | LPA_100HALF)) {
1446 phydev->speed = SPEED_100;
1447
1448 if (common_adv & LPA_100FULL)
1449 phydev->duplex = DUPLEX_FULL;
1450 } else
1451 if (common_adv & LPA_10FULL)
1452 phydev->duplex = DUPLEX_FULL;
1453
1454 if (phydev->duplex == DUPLEX_FULL) {
1455 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
1456 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
1457 }
1458 } else {
1459 int bmcr = phy_read(phydev, MII_BMCR);
1460
1461 if (bmcr < 0)
1462 return bmcr;
1463
1464 if (bmcr & BMCR_FULLDPLX)
1465 phydev->duplex = DUPLEX_FULL;
1466 else
1467 phydev->duplex = DUPLEX_HALF;
1468
1469 if (bmcr & BMCR_SPEED1000)
1470 phydev->speed = SPEED_1000;
1471 else if (bmcr & BMCR_SPEED100)
1472 phydev->speed = SPEED_100;
1473 else
1474 phydev->speed = SPEED_10;
1475
1476 phydev->pause = 0;
1477 phydev->asym_pause = 0;
1478 }
1479
1480 return 0;
1481}
1482EXPORT_SYMBOL(genphy_read_status);
1483
1484static int gen10g_read_status(struct phy_device *phydev)
1485{
1486 int devad, reg;
1487 u32 mmd_mask = phydev->c45_ids.devices_in_package;
1488
1489 phydev->link = 1;
1490
1491 /* For now just lie and say it's 10G all the time */
1492 phydev->speed = SPEED_10000;
1493 phydev->duplex = DUPLEX_FULL;
1494
1495 for (devad = 0; mmd_mask; devad++, mmd_mask = mmd_mask >> 1) {
1496 if (!(mmd_mask & 1))
1497 continue;
1498
1499 /* Read twice because link state is latched and a
1500 * read moves the current state into the register
1501 */
1502 phy_read_mmd(phydev, devad, MDIO_STAT1);
1503 reg = phy_read_mmd(phydev, devad, MDIO_STAT1);
1504 if (reg < 0 || !(reg & MDIO_STAT1_LSTATUS))
1505 phydev->link = 0;
1506 }
1507
1508 return 0;
1509}
1510
1511/**
1512 * genphy_soft_reset - software reset the PHY via BMCR_RESET bit
1513 * @phydev: target phy_device struct
1514 *
1515 * Description: Perform a software PHY reset using the standard
1516 * BMCR_RESET bit and poll for the reset bit to be cleared.
1517 *
1518 * Returns: 0 on success, < 0 on failure
1519 */
1520int genphy_soft_reset(struct phy_device *phydev)
1521{
1522 int ret;
1523
1524 ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
1525 if (ret < 0)
1526 return ret;
1527
1528 return phy_poll_reset(phydev);
1529}
1530EXPORT_SYMBOL(genphy_soft_reset);
1531
1532int genphy_config_init(struct phy_device *phydev)
1533{
1534 int val;
1535 u32 features;
1536
1537 features = (SUPPORTED_TP | SUPPORTED_MII
1538 | SUPPORTED_AUI | SUPPORTED_FIBRE |
1539 SUPPORTED_BNC | SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1540
1541 /* Do we support autonegotiation? */
1542 val = phy_read(phydev, MII_BMSR);
1543 if (val < 0)
1544 return val;
1545
1546 if (val & BMSR_ANEGCAPABLE)
1547 features |= SUPPORTED_Autoneg;
1548
1549 if (val & BMSR_100FULL)
1550 features |= SUPPORTED_100baseT_Full;
1551 if (val & BMSR_100HALF)
1552 features |= SUPPORTED_100baseT_Half;
1553 if (val & BMSR_10FULL)
1554 features |= SUPPORTED_10baseT_Full;
1555 if (val & BMSR_10HALF)
1556 features |= SUPPORTED_10baseT_Half;
1557
1558 if (val & BMSR_ESTATEN) {
1559 val = phy_read(phydev, MII_ESTATUS);
1560 if (val < 0)
1561 return val;
1562
1563 if (val & ESTATUS_1000_TFULL)
1564 features |= SUPPORTED_1000baseT_Full;
1565 if (val & ESTATUS_1000_THALF)
1566 features |= SUPPORTED_1000baseT_Half;
1567 }
1568
1569 phydev->supported &= features;
1570 phydev->advertising &= features;
1571
1572 return 0;
1573}
1574
1575static int gen10g_soft_reset(struct phy_device *phydev)
1576{
1577 /* Do nothing for now */
1578 return 0;
1579}
1580EXPORT_SYMBOL(genphy_config_init);
1581
1582static int gen10g_config_init(struct phy_device *phydev)
1583{
1584 /* Temporarily just say we support everything */
1585 phydev->supported = SUPPORTED_10000baseT_Full;
1586 phydev->advertising = SUPPORTED_10000baseT_Full;
1587
1588 return 0;
1589}
1590
1591int genphy_suspend(struct phy_device *phydev)
1592{
1593 int value;
1594
1595 mutex_lock(&phydev->lock);
1596
1597 value = phy_read(phydev, MII_BMCR);
1598 phy_write(phydev, MII_BMCR, value | BMCR_PDOWN);
1599
1600 mutex_unlock(&phydev->lock);
1601
1602 return 0;
1603}
1604EXPORT_SYMBOL(genphy_suspend);
1605
1606static int gen10g_suspend(struct phy_device *phydev)
1607{
1608 return 0;
1609}
1610
1611int genphy_resume(struct phy_device *phydev)
1612{
1613 int value;
1614
1615 mutex_lock(&phydev->lock);
1616
1617 value = phy_read(phydev, MII_BMCR);
1618 phy_write(phydev, MII_BMCR, value & ~BMCR_PDOWN);
1619
1620 mutex_unlock(&phydev->lock);
1621
1622 return 0;
1623}
1624EXPORT_SYMBOL(genphy_resume);
1625
1626static int gen10g_resume(struct phy_device *phydev)
1627{
1628 return 0;
1629}
1630
1631static int __set_phy_supported(struct phy_device *phydev, u32 max_speed)
1632{
1633 /* The default values for phydev->supported are provided by the PHY
1634 * driver "features" member, we want to reset to sane defaults first
1635 * before supporting higher speeds.
1636 */
1637 phydev->supported &= PHY_DEFAULT_FEATURES;
1638
1639 switch (max_speed) {
1640 default:
1641 return -ENOTSUPP;
1642 case SPEED_1000:
1643 phydev->supported |= PHY_1000BT_FEATURES;
1644 /* fall through */
1645 case SPEED_100:
1646 phydev->supported |= PHY_100BT_FEATURES;
1647 /* fall through */
1648 case SPEED_10:
1649 phydev->supported |= PHY_10BT_FEATURES;
1650 }
1651
1652 return 0;
1653}
1654
1655int phy_set_max_speed(struct phy_device *phydev, u32 max_speed)
1656{
1657 int err;
1658
1659 err = __set_phy_supported(phydev, max_speed);
1660 if (err)
1661 return err;
1662
1663 phydev->advertising = phydev->supported;
1664
1665 return 0;
1666}
1667EXPORT_SYMBOL(phy_set_max_speed);
1668
1669static void of_set_phy_supported(struct phy_device *phydev)
1670{
1671 struct device_node *node = phydev->mdio.dev.of_node;
1672 u32 max_speed;
1673
1674 if (!IS_ENABLED(CONFIG_OF_MDIO))
1675 return;
1676
1677 if (!node)
1678 return;
1679
1680 if (!of_property_read_u32(node, "max-speed", &max_speed))
1681 __set_phy_supported(phydev, max_speed);
1682}
1683
1684static void of_set_phy_eee_broken(struct phy_device *phydev)
1685{
1686 struct device_node *node = phydev->mdio.dev.of_node;
1687 u32 broken = 0;
1688
1689 if (!IS_ENABLED(CONFIG_OF_MDIO))
1690 return;
1691
1692 if (!node)
1693 return;
1694
1695 if (of_property_read_bool(node, "eee-broken-100tx"))
1696 broken |= MDIO_EEE_100TX;
1697 if (of_property_read_bool(node, "eee-broken-1000t"))
1698 broken |= MDIO_EEE_1000T;
1699 if (of_property_read_bool(node, "eee-broken-10gt"))
1700 broken |= MDIO_EEE_10GT;
1701 if (of_property_read_bool(node, "eee-broken-1000kx"))
1702 broken |= MDIO_EEE_1000KX;
1703 if (of_property_read_bool(node, "eee-broken-10gkx4"))
1704 broken |= MDIO_EEE_10GKX4;
1705 if (of_property_read_bool(node, "eee-broken-10gkr"))
1706 broken |= MDIO_EEE_10GKR;
1707
1708 phydev->eee_broken_modes = broken;
1709}
1710
1711/**
1712 * phy_probe - probe and init a PHY device
1713 * @dev: device to probe and init
1714 *
1715 * Description: Take care of setting up the phy_device structure,
1716 * set the state to READY (the driver's init function should
1717 * set it to STARTING if needed).
1718 */
1719static int phy_probe(struct device *dev)
1720{
1721 struct phy_device *phydev = to_phy_device(dev);
1722 struct device_driver *drv = phydev->mdio.dev.driver;
1723 struct phy_driver *phydrv = to_phy_driver(drv);
1724 int err = 0;
1725
1726 phydev->drv = phydrv;
1727
1728 /* Disable the interrupt if the PHY doesn't support it
1729 * but the interrupt is still a valid one
1730 */
1731 if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1732 phy_interrupt_is_valid(phydev))
1733 phydev->irq = PHY_POLL;
1734
1735 if (phydrv->flags & PHY_IS_INTERNAL)
1736 phydev->is_internal = true;
1737
1738 mutex_lock(&phydev->lock);
1739
1740 /* Start out supporting everything. Eventually,
1741 * a controller will attach, and may modify one
1742 * or both of these values
1743 */
1744 phydev->supported = phydrv->features;
1745 of_set_phy_supported(phydev);
1746 phydev->advertising = phydev->supported;
1747
1748 /* Get the EEE modes we want to prohibit. We will ask
1749 * the PHY stop advertising these mode later on
1750 */
1751 of_set_phy_eee_broken(phydev);
1752
1753 /* The Pause Frame bits indicate that the PHY can support passing
1754 * pause frames. During autonegotiation, the PHYs will determine if
1755 * they should allow pause frames to pass. The MAC driver should then
1756 * use that result to determine whether to enable flow control via
1757 * pause frames.
1758 *
1759 * Normally, PHY drivers should not set the Pause bits, and instead
1760 * allow phylib to do that. However, there may be some situations
1761 * (e.g. hardware erratum) where the driver wants to set only one
1762 * of these bits.
1763 */
1764 if (phydrv->features & (SUPPORTED_Pause | SUPPORTED_Asym_Pause)) {
1765 phydev->supported &= ~(SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1766 phydev->supported |= phydrv->features &
1767 (SUPPORTED_Pause | SUPPORTED_Asym_Pause);
1768 } else {
1769 phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1770 }
1771
1772 /* Set the state to READY by default */
1773 phydev->state = PHY_READY;
1774
1775 if (phydev->drv->probe)
1776 err = phydev->drv->probe(phydev);
1777
1778 mutex_unlock(&phydev->lock);
1779
1780 return err;
1781}
1782
1783static int phy_remove(struct device *dev)
1784{
1785 struct phy_device *phydev = to_phy_device(dev);
1786
1787 mutex_lock(&phydev->lock);
1788 phydev->state = PHY_DOWN;
1789 mutex_unlock(&phydev->lock);
1790
1791 if (phydev->drv->remove)
1792 phydev->drv->remove(phydev);
1793 phydev->drv = NULL;
1794
1795 return 0;
1796}
1797
1798/**
1799 * phy_driver_register - register a phy_driver with the PHY layer
1800 * @new_driver: new phy_driver to register
1801 * @owner: module owning this PHY
1802 */
1803int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
1804{
1805 int retval;
1806
1807 new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
1808 new_driver->mdiodrv.driver.name = new_driver->name;
1809 new_driver->mdiodrv.driver.bus = &mdio_bus_type;
1810 new_driver->mdiodrv.driver.probe = phy_probe;
1811 new_driver->mdiodrv.driver.remove = phy_remove;
1812 new_driver->mdiodrv.driver.owner = owner;
1813
1814 retval = driver_register(&new_driver->mdiodrv.driver);
1815 if (retval) {
1816 pr_err("%s: Error %d in registering driver\n",
1817 new_driver->name, retval);
1818
1819 return retval;
1820 }
1821
1822 pr_debug("%s: Registered new driver\n", new_driver->name);
1823
1824 return 0;
1825}
1826EXPORT_SYMBOL(phy_driver_register);
1827
1828int phy_drivers_register(struct phy_driver *new_driver, int n,
1829 struct module *owner)
1830{
1831 int i, ret = 0;
1832
1833 for (i = 0; i < n; i++) {
1834 ret = phy_driver_register(new_driver + i, owner);
1835 if (ret) {
1836 while (i-- > 0)
1837 phy_driver_unregister(new_driver + i);
1838 break;
1839 }
1840 }
1841 return ret;
1842}
1843EXPORT_SYMBOL(phy_drivers_register);
1844
1845void phy_driver_unregister(struct phy_driver *drv)
1846{
1847 driver_unregister(&drv->mdiodrv.driver);
1848}
1849EXPORT_SYMBOL(phy_driver_unregister);
1850
1851void phy_drivers_unregister(struct phy_driver *drv, int n)
1852{
1853 int i;
1854
1855 for (i = 0; i < n; i++)
1856 phy_driver_unregister(drv + i);
1857}
1858EXPORT_SYMBOL(phy_drivers_unregister);
1859
1860static struct phy_driver genphy_driver[] = {
1861{
1862 .phy_id = 0xffffffff,
1863 .phy_id_mask = 0xffffffff,
1864 .name = "Generic PHY",
1865 .soft_reset = genphy_soft_reset,
1866 .config_init = genphy_config_init,
1867 .features = PHY_GBIT_FEATURES | SUPPORTED_MII |
1868 SUPPORTED_AUI | SUPPORTED_FIBRE |
1869 SUPPORTED_BNC,
1870 .config_aneg = genphy_config_aneg,
1871 .aneg_done = genphy_aneg_done,
1872 .read_status = genphy_read_status,
1873 .suspend = genphy_suspend,
1874 .resume = genphy_resume,
1875}, {
1876 .phy_id = 0xffffffff,
1877 .phy_id_mask = 0xffffffff,
1878 .name = "Generic 10G PHY",
1879 .soft_reset = gen10g_soft_reset,
1880 .config_init = gen10g_config_init,
1881 .features = 0,
1882 .config_aneg = gen10g_config_aneg,
1883 .read_status = gen10g_read_status,
1884 .suspend = gen10g_suspend,
1885 .resume = gen10g_resume,
1886} };
1887
1888static int __init phy_init(void)
1889{
1890 int rc;
1891
1892 rc = mdio_bus_init();
1893 if (rc)
1894 return rc;
1895
1896 rc = phy_drivers_register(genphy_driver,
1897 ARRAY_SIZE(genphy_driver), THIS_MODULE);
1898 if (rc)
1899 mdio_bus_exit();
1900
1901 return rc;
1902}
1903
1904static void __exit phy_exit(void)
1905{
1906 phy_drivers_unregister(genphy_driver,
1907 ARRAY_SIZE(genphy_driver));
1908 mdio_bus_exit();
1909}
1910
1911subsys_initcall(phy_init);
1912module_exit(phy_exit);