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