Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / net / phy / phy_device.c
bloba4d7529ef41515d464282c883fe6c191b8b4366d
1 /*
2 * drivers/net/phy/phy_device.c
4 * Framework for finding and configuring PHYs.
5 * Also contains generic PHY driver
7 * Author: Andy Fleming
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>
30 #include <linux/mm.h>
31 #include <linux/module.h>
32 #include <linux/mii.h>
33 #include <linux/ethtool.h>
34 #include <linux/phy.h>
36 #include <asm/io.h>
37 #include <asm/irq.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
52 * default values */
53 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
55 if (NULL == dev)
56 return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
58 dev->speed = 0;
59 dev->duplex = -1;
60 dev->pause = dev->asym_pause = 0;
61 dev->link = 1;
62 dev->interface = PHY_INTERFACE_MODE_GMII;
64 dev->autoneg = AUTONEG_ENABLE;
66 dev->addr = addr;
67 dev->phy_id = phy_id;
68 dev->bus = bus;
70 dev->state = PHY_DOWN;
72 spin_lock_init(&dev->lock);
74 return dev;
76 EXPORT_SYMBOL(phy_device_create);
78 /* get_phy_device
80 * description: Reads the ID registers of the PHY at addr on the
81 * bus, then allocates and returns the phy_device to
82 * represent it.
84 struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
86 int phy_reg;
87 u32 phy_id;
88 struct phy_device *dev = NULL;
90 /* Grab the bits from PHYIR1, and put them
91 * in the upper half */
92 phy_reg = bus->read(bus, addr, MII_PHYSID1);
94 if (phy_reg < 0)
95 return ERR_PTR(phy_reg);
97 phy_id = (phy_reg & 0xffff) << 16;
99 /* Grab the bits from PHYIR2, and put them in the lower half */
100 phy_reg = bus->read(bus, addr, MII_PHYSID2);
102 if (phy_reg < 0)
103 return ERR_PTR(phy_reg);
105 phy_id |= (phy_reg & 0xffff);
107 /* If the phy_id is all Fs, there is no device there */
108 if (0xffffffff == phy_id)
109 return NULL;
111 dev = phy_device_create(bus, addr, phy_id);
113 return dev;
116 /* phy_prepare_link:
118 * description: Tells the PHY infrastructure to handle the
119 * gory details on monitoring link status (whether through
120 * polling or an interrupt), and to call back to the
121 * connected device driver when the link status changes.
122 * If you want to monitor your own link state, don't call
123 * this function */
124 void phy_prepare_link(struct phy_device *phydev,
125 void (*handler)(struct net_device *))
127 phydev->adjust_link = handler;
130 /* phy_connect:
132 * description: Convenience function for connecting ethernet
133 * devices to PHY devices. The default behavior is for
134 * the PHY infrastructure to handle everything, and only notify
135 * the connected driver when the link status changes. If you
136 * don't want, or can't use the provided functionality, you may
137 * choose to call only the subset of functions which provide
138 * the desired functionality.
140 struct phy_device * phy_connect(struct net_device *dev, const char *phy_id,
141 void (*handler)(struct net_device *), u32 flags,
142 u32 interface)
144 struct phy_device *phydev;
146 phydev = phy_attach(dev, phy_id, flags, interface);
148 if (IS_ERR(phydev))
149 return phydev;
151 phy_prepare_link(phydev, handler);
153 phy_start_machine(phydev, NULL);
155 if (phydev->irq > 0)
156 phy_start_interrupts(phydev);
158 return phydev;
160 EXPORT_SYMBOL(phy_connect);
162 void phy_disconnect(struct phy_device *phydev)
164 if (phydev->irq > 0)
165 phy_stop_interrupts(phydev);
167 phy_stop_machine(phydev);
169 phydev->adjust_link = NULL;
171 phy_detach(phydev);
173 EXPORT_SYMBOL(phy_disconnect);
175 /* phy_attach:
177 * description: Called by drivers to attach to a particular PHY
178 * device. The phy_device is found, and properly hooked up
179 * to the phy_driver. If no driver is attached, then the
180 * genphy_driver is used. The phy_device is given a ptr to
181 * the attaching device, and given a callback for link status
182 * change. The phy_device is returned to the attaching
183 * driver.
185 static int phy_compare_id(struct device *dev, void *data)
187 return strcmp((char *)data, dev->bus_id) ? 0 : 1;
190 struct phy_device *phy_attach(struct net_device *dev,
191 const char *phy_id, u32 flags, u32 interface)
193 struct bus_type *bus = &mdio_bus_type;
194 struct phy_device *phydev;
195 struct device *d;
197 /* Search the list of PHY devices on the mdio bus for the
198 * PHY with the requested name */
199 d = bus_find_device(bus, NULL, (void *)phy_id, phy_compare_id);
201 if (d) {
202 phydev = to_phy_device(d);
203 } else {
204 printk(KERN_ERR "%s not found\n", phy_id);
205 return ERR_PTR(-ENODEV);
208 /* Assume that if there is no driver, that it doesn't
209 * exist, and we should use the genphy driver. */
210 if (NULL == d->driver) {
211 int err;
212 down_write(&d->bus->subsys.rwsem);
213 d->driver = &genphy_driver.driver;
215 err = d->driver->probe(d);
217 if (err >= 0)
218 err = device_bind_driver(d);
220 up_write(&d->bus->subsys.rwsem);
222 if (err)
223 return ERR_PTR(err);
226 if (phydev->attached_dev) {
227 printk(KERN_ERR "%s: %s already attached\n",
228 dev->name, phy_id);
229 return ERR_PTR(-EBUSY);
232 phydev->attached_dev = dev;
234 phydev->dev_flags = flags;
236 phydev->interface = interface;
238 /* Do initial configuration here, now that
239 * we have certain key parameters
240 * (dev_flags and interface) */
241 if (phydev->drv->config_init) {
242 int err;
244 err = phydev->drv->config_init(phydev);
246 if (err < 0)
247 return ERR_PTR(err);
250 return phydev;
252 EXPORT_SYMBOL(phy_attach);
254 void phy_detach(struct phy_device *phydev)
256 phydev->attached_dev = NULL;
258 /* If the device had no specific driver before (i.e. - it
259 * was using the generic driver), we unbind the device
260 * from the generic driver so that there's a chance a
261 * real driver could be loaded */
262 if (phydev->dev.driver == &genphy_driver.driver) {
263 down_write(&phydev->dev.bus->subsys.rwsem);
264 device_release_driver(&phydev->dev);
265 up_write(&phydev->dev.bus->subsys.rwsem);
268 EXPORT_SYMBOL(phy_detach);
271 /* Generic PHY support and helper functions */
273 /* genphy_config_advert
275 * description: Writes MII_ADVERTISE with the appropriate values,
276 * after sanitizing the values to make sure we only advertise
277 * what is supported
279 int genphy_config_advert(struct phy_device *phydev)
281 u32 advertise;
282 int adv;
283 int err;
285 /* Only allow advertising what
286 * this PHY supports */
287 phydev->advertising &= phydev->supported;
288 advertise = phydev->advertising;
290 /* Setup standard advertisement */
291 adv = phy_read(phydev, MII_ADVERTISE);
293 if (adv < 0)
294 return adv;
296 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
297 ADVERTISE_PAUSE_ASYM);
298 if (advertise & ADVERTISED_10baseT_Half)
299 adv |= ADVERTISE_10HALF;
300 if (advertise & ADVERTISED_10baseT_Full)
301 adv |= ADVERTISE_10FULL;
302 if (advertise & ADVERTISED_100baseT_Half)
303 adv |= ADVERTISE_100HALF;
304 if (advertise & ADVERTISED_100baseT_Full)
305 adv |= ADVERTISE_100FULL;
306 if (advertise & ADVERTISED_Pause)
307 adv |= ADVERTISE_PAUSE_CAP;
308 if (advertise & ADVERTISED_Asym_Pause)
309 adv |= ADVERTISE_PAUSE_ASYM;
311 err = phy_write(phydev, MII_ADVERTISE, adv);
313 if (err < 0)
314 return err;
316 /* Configure gigabit if it's supported */
317 if (phydev->supported & (SUPPORTED_1000baseT_Half |
318 SUPPORTED_1000baseT_Full)) {
319 adv = phy_read(phydev, MII_CTRL1000);
321 if (adv < 0)
322 return adv;
324 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
325 if (advertise & SUPPORTED_1000baseT_Half)
326 adv |= ADVERTISE_1000HALF;
327 if (advertise & SUPPORTED_1000baseT_Full)
328 adv |= ADVERTISE_1000FULL;
329 err = phy_write(phydev, MII_CTRL1000, adv);
331 if (err < 0)
332 return err;
335 return adv;
337 EXPORT_SYMBOL(genphy_config_advert);
339 /* genphy_setup_forced
341 * description: Configures MII_BMCR to force speed/duplex
342 * to the values in phydev. Assumes that the values are valid.
343 * Please see phy_sanitize_settings() */
344 int genphy_setup_forced(struct phy_device *phydev)
346 int ctl = BMCR_RESET;
348 phydev->pause = phydev->asym_pause = 0;
350 if (SPEED_1000 == phydev->speed)
351 ctl |= BMCR_SPEED1000;
352 else if (SPEED_100 == phydev->speed)
353 ctl |= BMCR_SPEED100;
355 if (DUPLEX_FULL == phydev->duplex)
356 ctl |= BMCR_FULLDPLX;
358 ctl = phy_write(phydev, MII_BMCR, ctl);
360 if (ctl < 0)
361 return ctl;
363 /* We just reset the device, so we'd better configure any
364 * settings the PHY requires to operate */
365 if (phydev->drv->config_init)
366 ctl = phydev->drv->config_init(phydev);
368 return ctl;
372 /* Enable and Restart Autonegotiation */
373 int genphy_restart_aneg(struct phy_device *phydev)
375 int ctl;
377 ctl = phy_read(phydev, MII_BMCR);
379 if (ctl < 0)
380 return ctl;
382 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
384 /* Don't isolate the PHY if we're negotiating */
385 ctl &= ~(BMCR_ISOLATE);
387 ctl = phy_write(phydev, MII_BMCR, ctl);
389 return ctl;
393 /* genphy_config_aneg
395 * description: If auto-negotiation is enabled, we configure the
396 * advertising, and then restart auto-negotiation. If it is not
397 * enabled, then we write the BMCR
399 int genphy_config_aneg(struct phy_device *phydev)
401 int err = 0;
403 if (AUTONEG_ENABLE == phydev->autoneg) {
404 err = genphy_config_advert(phydev);
406 if (err < 0)
407 return err;
409 err = genphy_restart_aneg(phydev);
410 } else
411 err = genphy_setup_forced(phydev);
413 return err;
415 EXPORT_SYMBOL(genphy_config_aneg);
417 /* genphy_update_link
419 * description: Update the value in phydev->link to reflect the
420 * current link value. In order to do this, we need to read
421 * the status register twice, keeping the second value
423 int genphy_update_link(struct phy_device *phydev)
425 int status;
427 /* Do a fake read */
428 status = phy_read(phydev, MII_BMSR);
430 if (status < 0)
431 return status;
433 /* Read link and autonegotiation status */
434 status = phy_read(phydev, MII_BMSR);
436 if (status < 0)
437 return status;
439 if ((status & BMSR_LSTATUS) == 0)
440 phydev->link = 0;
441 else
442 phydev->link = 1;
444 return 0;
446 EXPORT_SYMBOL(genphy_update_link);
448 /* genphy_read_status
450 * description: Check the link, then figure out the current state
451 * by comparing what we advertise with what the link partner
452 * advertises. Start by checking the gigabit possibilities,
453 * then move on to 10/100.
455 int genphy_read_status(struct phy_device *phydev)
457 int adv;
458 int err;
459 int lpa;
460 int lpagb = 0;
462 /* Update the link, but return if there
463 * was an error */
464 err = genphy_update_link(phydev);
465 if (err)
466 return err;
468 if (AUTONEG_ENABLE == phydev->autoneg) {
469 if (phydev->supported & (SUPPORTED_1000baseT_Half
470 | SUPPORTED_1000baseT_Full)) {
471 lpagb = phy_read(phydev, MII_STAT1000);
473 if (lpagb < 0)
474 return lpagb;
476 adv = phy_read(phydev, MII_CTRL1000);
478 if (adv < 0)
479 return adv;
481 lpagb &= adv << 2;
484 lpa = phy_read(phydev, MII_LPA);
486 if (lpa < 0)
487 return lpa;
489 adv = phy_read(phydev, MII_ADVERTISE);
491 if (adv < 0)
492 return adv;
494 lpa &= adv;
496 phydev->speed = SPEED_10;
497 phydev->duplex = DUPLEX_HALF;
498 phydev->pause = phydev->asym_pause = 0;
500 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
501 phydev->speed = SPEED_1000;
503 if (lpagb & LPA_1000FULL)
504 phydev->duplex = DUPLEX_FULL;
505 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
506 phydev->speed = SPEED_100;
508 if (lpa & LPA_100FULL)
509 phydev->duplex = DUPLEX_FULL;
510 } else
511 if (lpa & LPA_10FULL)
512 phydev->duplex = DUPLEX_FULL;
514 if (phydev->duplex == DUPLEX_FULL){
515 phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
516 phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
518 } else {
519 int bmcr = phy_read(phydev, MII_BMCR);
520 if (bmcr < 0)
521 return bmcr;
523 if (bmcr & BMCR_FULLDPLX)
524 phydev->duplex = DUPLEX_FULL;
525 else
526 phydev->duplex = DUPLEX_HALF;
528 if (bmcr & BMCR_SPEED1000)
529 phydev->speed = SPEED_1000;
530 else if (bmcr & BMCR_SPEED100)
531 phydev->speed = SPEED_100;
532 else
533 phydev->speed = SPEED_10;
535 phydev->pause = phydev->asym_pause = 0;
538 return 0;
540 EXPORT_SYMBOL(genphy_read_status);
542 static int genphy_config_init(struct phy_device *phydev)
544 int val;
545 u32 features;
547 /* For now, I'll claim that the generic driver supports
548 * all possible port types */
549 features = (SUPPORTED_TP | SUPPORTED_MII
550 | SUPPORTED_AUI | SUPPORTED_FIBRE |
551 SUPPORTED_BNC);
553 /* Do we support autonegotiation? */
554 val = phy_read(phydev, MII_BMSR);
556 if (val < 0)
557 return val;
559 if (val & BMSR_ANEGCAPABLE)
560 features |= SUPPORTED_Autoneg;
562 if (val & BMSR_100FULL)
563 features |= SUPPORTED_100baseT_Full;
564 if (val & BMSR_100HALF)
565 features |= SUPPORTED_100baseT_Half;
566 if (val & BMSR_10FULL)
567 features |= SUPPORTED_10baseT_Full;
568 if (val & BMSR_10HALF)
569 features |= SUPPORTED_10baseT_Half;
571 if (val & BMSR_ESTATEN) {
572 val = phy_read(phydev, MII_ESTATUS);
574 if (val < 0)
575 return val;
577 if (val & ESTATUS_1000_TFULL)
578 features |= SUPPORTED_1000baseT_Full;
579 if (val & ESTATUS_1000_THALF)
580 features |= SUPPORTED_1000baseT_Half;
583 phydev->supported = features;
584 phydev->advertising = features;
586 return 0;
590 /* phy_probe
592 * description: Take care of setting up the phy_device structure,
593 * set the state to READY (the driver's init function should
594 * set it to STARTING if needed).
596 static int phy_probe(struct device *dev)
598 struct phy_device *phydev;
599 struct phy_driver *phydrv;
600 struct device_driver *drv;
601 int err = 0;
603 phydev = to_phy_device(dev);
605 /* Make sure the driver is held.
606 * XXX -- Is this correct? */
607 drv = get_driver(phydev->dev.driver);
608 phydrv = to_phy_driver(drv);
609 phydev->drv = phydrv;
611 /* Disable the interrupt if the PHY doesn't support it */
612 if (!(phydrv->flags & PHY_HAS_INTERRUPT))
613 phydev->irq = PHY_POLL;
615 spin_lock(&phydev->lock);
617 /* Start out supporting everything. Eventually,
618 * a controller will attach, and may modify one
619 * or both of these values */
620 phydev->supported = phydrv->features;
621 phydev->advertising = phydrv->features;
623 /* Set the state to READY by default */
624 phydev->state = PHY_READY;
626 if (phydev->drv->probe)
627 err = phydev->drv->probe(phydev);
629 spin_unlock(&phydev->lock);
631 return err;
635 static int phy_remove(struct device *dev)
637 struct phy_device *phydev;
639 phydev = to_phy_device(dev);
641 spin_lock(&phydev->lock);
642 phydev->state = PHY_DOWN;
643 spin_unlock(&phydev->lock);
645 if (phydev->drv->remove)
646 phydev->drv->remove(phydev);
648 put_driver(dev->driver);
649 phydev->drv = NULL;
651 return 0;
654 int phy_driver_register(struct phy_driver *new_driver)
656 int retval;
658 memset(&new_driver->driver, 0, sizeof(new_driver->driver));
659 new_driver->driver.name = new_driver->name;
660 new_driver->driver.bus = &mdio_bus_type;
661 new_driver->driver.probe = phy_probe;
662 new_driver->driver.remove = phy_remove;
664 retval = driver_register(&new_driver->driver);
666 if (retval) {
667 printk(KERN_ERR "%s: Error %d in registering driver\n",
668 new_driver->name, retval);
670 return retval;
673 pr_info("%s: Registered new driver\n", new_driver->name);
675 return 0;
677 EXPORT_SYMBOL(phy_driver_register);
679 void phy_driver_unregister(struct phy_driver *drv)
681 driver_unregister(&drv->driver);
683 EXPORT_SYMBOL(phy_driver_unregister);
685 static struct phy_driver genphy_driver = {
686 .phy_id = 0xffffffff,
687 .phy_id_mask = 0xffffffff,
688 .name = "Generic PHY",
689 .config_init = genphy_config_init,
690 .features = 0,
691 .config_aneg = genphy_config_aneg,
692 .read_status = genphy_read_status,
693 .driver = {.owner= THIS_MODULE, },
696 static int __init phy_init(void)
698 int rc;
700 rc = mdio_bus_init();
701 if (rc)
702 return rc;
704 rc = phy_driver_register(&genphy_driver);
705 if (rc)
706 mdio_bus_exit();
708 return rc;
711 static void __exit phy_exit(void)
713 phy_driver_unregister(&genphy_driver);
714 mdio_bus_exit();
717 subsys_initcall(phy_init);
718 module_exit(phy_exit);