2 * drivers/net/phy/phy_device.c
4 * Framework for finding and configuring PHYs.
5 * Also contains generic PHY driver
9 * Copyright (c) 2004 Freescale Semiconductor, Inc.
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.
17 #include <linux/kernel.h>
18 #include <linux/sched.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/unistd.h>
22 #include <linux/slab.h>
23 #include <linux/interrupt.h>
24 #include <linux/init.h>
25 #include <linux/delay.h>
26 #include <linux/netdevice.h>
27 #include <linux/etherdevice.h>
28 #include <linux/skbuff.h>
29 #include <linux/spinlock.h>
31 #include <linux/module.h>
32 #include <linux/mii.h>
33 #include <linux/ethtool.h>
34 #include <linux/phy.h>
38 #include <asm/uaccess.h>
40 MODULE_DESCRIPTION("PHY library");
41 MODULE_AUTHOR("Andy Fleming");
42 MODULE_LICENSE("GPL");
44 static struct phy_driver genphy_driver
;
45 extern int mdio_bus_init(void);
46 extern void mdio_bus_exit(void);
48 struct phy_device
* phy_device_create(struct mii_bus
*bus
, int addr
, int phy_id
)
50 struct phy_device
*dev
;
51 /* We allocate the device, and initialize the
53 dev
= kcalloc(1, sizeof(*dev
), GFP_KERNEL
);
56 return (struct phy_device
*) PTR_ERR((void*)-ENOMEM
);
60 dev
->pause
= dev
->asym_pause
= 0;
63 dev
->autoneg
= AUTONEG_ENABLE
;
69 dev
->state
= PHY_DOWN
;
71 spin_lock_init(&dev
->lock
);
75 EXPORT_SYMBOL(phy_device_create
);
79 * description: Reads the ID registers of the PHY at addr on the
80 * bus, then allocates and returns the phy_device to
83 struct phy_device
* get_phy_device(struct mii_bus
*bus
, int addr
)
87 struct phy_device
*dev
= NULL
;
89 /* Grab the bits from PHYIR1, and put them
90 * in the upper half */
91 phy_reg
= bus
->read(bus
, addr
, MII_PHYSID1
);
94 return ERR_PTR(phy_reg
);
96 phy_id
= (phy_reg
& 0xffff) << 16;
98 /* Grab the bits from PHYIR2, and put them in the lower half */
99 phy_reg
= bus
->read(bus
, addr
, MII_PHYSID2
);
102 return ERR_PTR(phy_reg
);
104 phy_id
|= (phy_reg
& 0xffff);
106 /* If the phy_id is all Fs, there is no device there */
107 if (0xffffffff == phy_id
)
110 dev
= phy_device_create(bus
, addr
, phy_id
);
117 * description: Tells the PHY infrastructure to handle the
118 * gory details on monitoring link status (whether through
119 * polling or an interrupt), and to call back to the
120 * connected device driver when the link status changes.
121 * If you want to monitor your own link state, don't call
123 void phy_prepare_link(struct phy_device
*phydev
,
124 void (*handler
)(struct net_device
*))
126 phydev
->adjust_link
= handler
;
131 * description: Convenience function for connecting ethernet
132 * devices to PHY devices. The default behavior is for
133 * the PHY infrastructure to handle everything, and only notify
134 * the connected driver when the link status changes. If you
135 * don't want, or can't use the provided functionality, you may
136 * choose to call only the subset of functions which provide
137 * the desired functionality.
139 struct phy_device
* phy_connect(struct net_device
*dev
, const char *phy_id
,
140 void (*handler
)(struct net_device
*), u32 flags
)
142 struct phy_device
*phydev
;
144 phydev
= phy_attach(dev
, phy_id
, flags
);
149 phy_prepare_link(phydev
, handler
);
151 phy_start_machine(phydev
, NULL
);
154 phy_start_interrupts(phydev
);
158 EXPORT_SYMBOL(phy_connect
);
160 void phy_disconnect(struct phy_device
*phydev
)
163 phy_stop_interrupts(phydev
);
165 phy_stop_machine(phydev
);
167 phydev
->adjust_link
= NULL
;
171 EXPORT_SYMBOL(phy_disconnect
);
175 * description: Called by drivers to attach to a particular PHY
176 * device. The phy_device is found, and properly hooked up
177 * to the phy_driver. If no driver is attached, then the
178 * genphy_driver is used. The phy_device is given a ptr to
179 * the attaching device, and given a callback for link status
180 * change. The phy_device is returned to the attaching
183 static int phy_compare_id(struct device
*dev
, void *data
)
185 return strcmp((char *)data
, dev
->bus_id
) ? 0 : 1;
188 struct phy_device
*phy_attach(struct net_device
*dev
,
189 const char *phy_id
, u32 flags
)
191 struct bus_type
*bus
= &mdio_bus_type
;
192 struct phy_device
*phydev
;
195 /* Search the list of PHY devices on the mdio bus for the
196 * PHY with the requested name */
197 d
= bus_find_device(bus
, NULL
, (void *)phy_id
, phy_compare_id
);
200 phydev
= to_phy_device(d
);
202 printk(KERN_ERR
"%s not found\n", phy_id
);
203 return ERR_PTR(-ENODEV
);
206 /* Assume that if there is no driver, that it doesn't
207 * exist, and we should use the genphy driver. */
208 if (NULL
== d
->driver
) {
210 down_write(&d
->bus
->subsys
.rwsem
);
211 d
->driver
= &genphy_driver
.driver
;
213 err
= d
->driver
->probe(d
);
216 err
= device_bind_driver(d
);
218 up_write(&d
->bus
->subsys
.rwsem
);
224 if (phydev
->attached_dev
) {
225 printk(KERN_ERR
"%s: %s already attached\n",
227 return ERR_PTR(-EBUSY
);
230 phydev
->attached_dev
= dev
;
232 phydev
->dev_flags
= flags
;
236 EXPORT_SYMBOL(phy_attach
);
238 void phy_detach(struct phy_device
*phydev
)
240 phydev
->attached_dev
= NULL
;
242 /* If the device had no specific driver before (i.e. - it
243 * was using the generic driver), we unbind the device
244 * from the generic driver so that there's a chance a
245 * real driver could be loaded */
246 if (phydev
->dev
.driver
== &genphy_driver
.driver
) {
247 down_write(&phydev
->dev
.bus
->subsys
.rwsem
);
248 device_release_driver(&phydev
->dev
);
249 up_write(&phydev
->dev
.bus
->subsys
.rwsem
);
252 EXPORT_SYMBOL(phy_detach
);
255 /* Generic PHY support and helper functions */
257 /* genphy_config_advert
259 * description: Writes MII_ADVERTISE with the appropriate values,
260 * after sanitizing the values to make sure we only advertise
263 int genphy_config_advert(struct phy_device
*phydev
)
269 /* Only allow advertising what
270 * this PHY supports */
271 phydev
->advertising
&= phydev
->supported
;
272 advertise
= phydev
->advertising
;
274 /* Setup standard advertisement */
275 adv
= phy_read(phydev
, MII_ADVERTISE
);
280 adv
&= ~(ADVERTISE_ALL
| ADVERTISE_100BASE4
| ADVERTISE_PAUSE_CAP
|
281 ADVERTISE_PAUSE_ASYM
);
282 if (advertise
& ADVERTISED_10baseT_Half
)
283 adv
|= ADVERTISE_10HALF
;
284 if (advertise
& ADVERTISED_10baseT_Full
)
285 adv
|= ADVERTISE_10FULL
;
286 if (advertise
& ADVERTISED_100baseT_Half
)
287 adv
|= ADVERTISE_100HALF
;
288 if (advertise
& ADVERTISED_100baseT_Full
)
289 adv
|= ADVERTISE_100FULL
;
290 if (advertise
& ADVERTISED_Pause
)
291 adv
|= ADVERTISE_PAUSE_CAP
;
292 if (advertise
& ADVERTISED_Asym_Pause
)
293 adv
|= ADVERTISE_PAUSE_ASYM
;
295 err
= phy_write(phydev
, MII_ADVERTISE
, adv
);
300 /* Configure gigabit if it's supported */
301 if (phydev
->supported
& (SUPPORTED_1000baseT_Half
|
302 SUPPORTED_1000baseT_Full
)) {
303 adv
= phy_read(phydev
, MII_CTRL1000
);
308 adv
&= ~(ADVERTISE_1000FULL
| ADVERTISE_1000HALF
);
309 if (advertise
& SUPPORTED_1000baseT_Half
)
310 adv
|= ADVERTISE_1000HALF
;
311 if (advertise
& SUPPORTED_1000baseT_Full
)
312 adv
|= ADVERTISE_1000FULL
;
313 err
= phy_write(phydev
, MII_CTRL1000
, adv
);
321 EXPORT_SYMBOL(genphy_config_advert
);
323 /* genphy_setup_forced
325 * description: Configures MII_BMCR to force speed/duplex
326 * to the values in phydev. Assumes that the values are valid.
327 * Please see phy_sanitize_settings() */
328 int genphy_setup_forced(struct phy_device
*phydev
)
330 int ctl
= BMCR_RESET
;
332 phydev
->pause
= phydev
->asym_pause
= 0;
334 if (SPEED_1000
== phydev
->speed
)
335 ctl
|= BMCR_SPEED1000
;
336 else if (SPEED_100
== phydev
->speed
)
337 ctl
|= BMCR_SPEED100
;
339 if (DUPLEX_FULL
== phydev
->duplex
)
340 ctl
|= BMCR_FULLDPLX
;
342 ctl
= phy_write(phydev
, MII_BMCR
, ctl
);
347 /* We just reset the device, so we'd better configure any
348 * settings the PHY requires to operate */
349 if (phydev
->drv
->config_init
)
350 ctl
= phydev
->drv
->config_init(phydev
);
356 /* Enable and Restart Autonegotiation */
357 int genphy_restart_aneg(struct phy_device
*phydev
)
361 ctl
= phy_read(phydev
, MII_BMCR
);
366 ctl
|= (BMCR_ANENABLE
| BMCR_ANRESTART
);
368 /* Don't isolate the PHY if we're negotiating */
369 ctl
&= ~(BMCR_ISOLATE
);
371 ctl
= phy_write(phydev
, MII_BMCR
, ctl
);
377 /* genphy_config_aneg
379 * description: If auto-negotiation is enabled, we configure the
380 * advertising, and then restart auto-negotiation. If it is not
381 * enabled, then we write the BMCR
383 int genphy_config_aneg(struct phy_device
*phydev
)
387 if (AUTONEG_ENABLE
== phydev
->autoneg
) {
388 err
= genphy_config_advert(phydev
);
393 err
= genphy_restart_aneg(phydev
);
395 err
= genphy_setup_forced(phydev
);
399 EXPORT_SYMBOL(genphy_config_aneg
);
401 /* genphy_update_link
403 * description: Update the value in phydev->link to reflect the
404 * current link value. In order to do this, we need to read
405 * the status register twice, keeping the second value
407 int genphy_update_link(struct phy_device
*phydev
)
412 status
= phy_read(phydev
, MII_BMSR
);
417 /* Read link and autonegotiation status */
418 status
= phy_read(phydev
, MII_BMSR
);
423 if ((status
& BMSR_LSTATUS
) == 0)
430 EXPORT_SYMBOL(genphy_update_link
);
432 /* genphy_read_status
434 * description: Check the link, then figure out the current state
435 * by comparing what we advertise with what the link partner
436 * advertises. Start by checking the gigabit possibilities,
437 * then move on to 10/100.
439 int genphy_read_status(struct phy_device
*phydev
)
446 /* Update the link, but return if there
448 err
= genphy_update_link(phydev
);
452 if (AUTONEG_ENABLE
== phydev
->autoneg
) {
453 if (phydev
->supported
& (SUPPORTED_1000baseT_Half
454 | SUPPORTED_1000baseT_Full
)) {
455 lpagb
= phy_read(phydev
, MII_STAT1000
);
460 adv
= phy_read(phydev
, MII_CTRL1000
);
468 lpa
= phy_read(phydev
, MII_LPA
);
473 adv
= phy_read(phydev
, MII_ADVERTISE
);
480 phydev
->speed
= SPEED_10
;
481 phydev
->duplex
= DUPLEX_HALF
;
482 phydev
->pause
= phydev
->asym_pause
= 0;
484 if (lpagb
& (LPA_1000FULL
| LPA_1000HALF
)) {
485 phydev
->speed
= SPEED_1000
;
487 if (lpagb
& LPA_1000FULL
)
488 phydev
->duplex
= DUPLEX_FULL
;
489 } else if (lpa
& (LPA_100FULL
| LPA_100HALF
)) {
490 phydev
->speed
= SPEED_100
;
492 if (lpa
& LPA_100FULL
)
493 phydev
->duplex
= DUPLEX_FULL
;
495 if (lpa
& LPA_10FULL
)
496 phydev
->duplex
= DUPLEX_FULL
;
498 if (phydev
->duplex
== DUPLEX_FULL
){
499 phydev
->pause
= lpa
& LPA_PAUSE_CAP
? 1 : 0;
500 phydev
->asym_pause
= lpa
& LPA_PAUSE_ASYM
? 1 : 0;
503 int bmcr
= phy_read(phydev
, MII_BMCR
);
507 if (bmcr
& BMCR_FULLDPLX
)
508 phydev
->duplex
= DUPLEX_FULL
;
510 phydev
->duplex
= DUPLEX_HALF
;
512 if (bmcr
& BMCR_SPEED1000
)
513 phydev
->speed
= SPEED_1000
;
514 else if (bmcr
& BMCR_SPEED100
)
515 phydev
->speed
= SPEED_100
;
517 phydev
->speed
= SPEED_10
;
519 phydev
->pause
= phydev
->asym_pause
= 0;
524 EXPORT_SYMBOL(genphy_read_status
);
526 static int genphy_config_init(struct phy_device
*phydev
)
531 /* For now, I'll claim that the generic driver supports
532 * all possible port types */
533 features
= (SUPPORTED_TP
| SUPPORTED_MII
534 | SUPPORTED_AUI
| SUPPORTED_FIBRE
|
537 /* Do we support autonegotiation? */
538 val
= phy_read(phydev
, MII_BMSR
);
543 if (val
& BMSR_ANEGCAPABLE
)
544 features
|= SUPPORTED_Autoneg
;
546 if (val
& BMSR_100FULL
)
547 features
|= SUPPORTED_100baseT_Full
;
548 if (val
& BMSR_100HALF
)
549 features
|= SUPPORTED_100baseT_Half
;
550 if (val
& BMSR_10FULL
)
551 features
|= SUPPORTED_10baseT_Full
;
552 if (val
& BMSR_10HALF
)
553 features
|= SUPPORTED_10baseT_Half
;
555 if (val
& BMSR_ESTATEN
) {
556 val
= phy_read(phydev
, MII_ESTATUS
);
561 if (val
& ESTATUS_1000_TFULL
)
562 features
|= SUPPORTED_1000baseT_Full
;
563 if (val
& ESTATUS_1000_THALF
)
564 features
|= SUPPORTED_1000baseT_Half
;
567 phydev
->supported
= features
;
568 phydev
->advertising
= features
;
576 * description: Take care of setting up the phy_device structure,
577 * set the state to READY (the driver's init function should
578 * set it to STARTING if needed).
580 static int phy_probe(struct device
*dev
)
582 struct phy_device
*phydev
;
583 struct phy_driver
*phydrv
;
584 struct device_driver
*drv
;
587 phydev
= to_phy_device(dev
);
589 /* Make sure the driver is held.
590 * XXX -- Is this correct? */
591 drv
= get_driver(phydev
->dev
.driver
);
592 phydrv
= to_phy_driver(drv
);
593 phydev
->drv
= phydrv
;
595 /* Disable the interrupt if the PHY doesn't support it */
596 if (!(phydrv
->flags
& PHY_HAS_INTERRUPT
))
597 phydev
->irq
= PHY_POLL
;
599 spin_lock(&phydev
->lock
);
601 /* Start out supporting everything. Eventually,
602 * a controller will attach, and may modify one
603 * or both of these values */
604 phydev
->supported
= phydrv
->features
;
605 phydev
->advertising
= phydrv
->features
;
607 /* Set the state to READY by default */
608 phydev
->state
= PHY_READY
;
610 if (phydev
->drv
->probe
)
611 err
= phydev
->drv
->probe(phydev
);
613 spin_unlock(&phydev
->lock
);
618 if (phydev
->drv
->config_init
)
619 err
= phydev
->drv
->config_init(phydev
);
624 static int phy_remove(struct device
*dev
)
626 struct phy_device
*phydev
;
628 phydev
= to_phy_device(dev
);
630 spin_lock(&phydev
->lock
);
631 phydev
->state
= PHY_DOWN
;
632 spin_unlock(&phydev
->lock
);
634 if (phydev
->drv
->remove
)
635 phydev
->drv
->remove(phydev
);
637 put_driver(dev
->driver
);
643 int phy_driver_register(struct phy_driver
*new_driver
)
647 memset(&new_driver
->driver
, 0, sizeof(new_driver
->driver
));
648 new_driver
->driver
.name
= new_driver
->name
;
649 new_driver
->driver
.bus
= &mdio_bus_type
;
650 new_driver
->driver
.probe
= phy_probe
;
651 new_driver
->driver
.remove
= phy_remove
;
653 retval
= driver_register(&new_driver
->driver
);
656 printk(KERN_ERR
"%s: Error %d in registering driver\n",
657 new_driver
->name
, retval
);
662 pr_info("%s: Registered new driver\n", new_driver
->name
);
666 EXPORT_SYMBOL(phy_driver_register
);
668 void phy_driver_unregister(struct phy_driver
*drv
)
670 driver_unregister(&drv
->driver
);
672 EXPORT_SYMBOL(phy_driver_unregister
);
674 static struct phy_driver genphy_driver
= {
675 .phy_id
= 0xffffffff,
676 .phy_id_mask
= 0xffffffff,
677 .name
= "Generic PHY",
678 .config_init
= genphy_config_init
,
680 .config_aneg
= genphy_config_aneg
,
681 .read_status
= genphy_read_status
,
682 .driver
= {.owner
= THIS_MODULE
, },
685 static int __init
phy_init(void)
689 rc
= mdio_bus_init();
693 rc
= phy_driver_register(&genphy_driver
);
700 static void __exit
phy_exit(void)
702 phy_driver_unregister(&genphy_driver
);
706 subsys_initcall(phy_init
);
707 module_exit(phy_exit
);