git.oblomov.eu Git - linux-2.6/blob - drivers/net/phy/phy_device.c

   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/config.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/string.h>
  21 #include <linux/errno.h>
  22 #include <linux/unistd.h>
  23 #include <linux/slab.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/netdevice.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/skbuff.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/mm.h>
  32 #include <linux/module.h>
  33 #include <linux/version.h>
  34 #include <linux/mii.h>
  35 #include <linux/ethtool.h>
  36 #include <linux/phy.h>
  37
  38 #include <asm/io.h>
  39 #include <asm/irq.h>
  40 #include <asm/uaccess.h>
  41
  42 static struct phy_driver genphy_driver;
  43 extern int mdio_bus_init(void);
  44 extern void mdio_bus_exit(void);
  45
  46 /* get_phy_device
  47  *
  48  * description: Reads the ID registers of the PHY at addr on the
  49  *   bus, then allocates and returns the phy_device to
  50  *   represent it.
  51  */
  52 struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
  53 {
  54         int phy_reg;
  55         u32 phy_id;
  56         struct phy_device *dev = NULL;
  57
  58         /* Grab the bits from PHYIR1, and put them
  59          * in the upper half */
  60         phy_reg = bus->read(bus, addr, MII_PHYSID1);
  61
  62         if (phy_reg < 0)
  63                 return ERR_PTR(phy_reg);
  64
  65         phy_id = (phy_reg & 0xffff) << 16;
  66
  67         /* Grab the bits from PHYIR2, and put them in the lower half */
  68         phy_reg = bus->read(bus, addr, MII_PHYSID2);
  69
  70         if (phy_reg < 0)
  71                 return ERR_PTR(phy_reg);
  72
  73         phy_id |= (phy_reg & 0xffff);
  74
  75         /* If the phy_id is all Fs, there is no device there */
  76         if (0xffffffff == phy_id)
  77                 return NULL;
  78
  79         /* Otherwise, we allocate the device, and initialize the
  80          * default values */
  81         dev = kcalloc(1, sizeof(*dev), GFP_KERNEL);
  82
  83         if (NULL == dev)
  84                 return ERR_PTR(-ENOMEM);
  85
  86         dev->speed = 0;
  87         dev->duplex = -1;
  88         dev->pause = dev->asym_pause = 0;
  89         dev->link = 1;
  90
  91         dev->autoneg = AUTONEG_ENABLE;
  92
  93         dev->addr = addr;
  94         dev->phy_id = phy_id;
  95         dev->bus = bus;
  96
  97         dev->state = PHY_DOWN;
  98
  99         spin_lock_init(&dev->lock);
 100
 101         return dev;
 102 }
 103
 104 /* phy_prepare_link:
 105  *
 106  * description: Tells the PHY infrastructure to handle the
 107  *   gory details on monitoring link status (whether through
 108  *   polling or an interrupt), and to call back to the
 109  *   connected device driver when the link status changes.
 110  *   If you want to monitor your own link state, don't call
 111  *   this function */
 112 void phy_prepare_link(struct phy_device *phydev,
 113                 void (*handler)(struct net_device *))
 114 {
 115         phydev->adjust_link = handler;
 116 }
 117
 118 /* phy_connect:
 119  *
 120  * description: Convenience function for connecting ethernet
 121  *   devices to PHY devices.  The default behavior is for
 122  *   the PHY infrastructure to handle everything, and only notify
 123  *   the connected driver when the link status changes.  If you
 124  *   don't want, or can't use the provided functionality, you may
 125  *   choose to call only the subset of functions which provide
 126  *   the desired functionality.
 127  */
 128 struct phy_device * phy_connect(struct net_device *dev, const char *phy_id,
 129                 void (*handler)(struct net_device *), u32 flags)
 130 {
 131         struct phy_device *phydev;
 132
 133         phydev = phy_attach(dev, phy_id, flags);
 134
 135         if (IS_ERR(phydev))
 136                 return phydev;
 137
 138         phy_prepare_link(phydev, handler);
 139
 140         phy_start_machine(phydev, NULL);
 141
 142         if (phydev->irq > 0)
 143                 phy_start_interrupts(phydev);
 144
 145         return phydev;
 146 }
 147 EXPORT_SYMBOL(phy_connect);
 148
 149 void phy_disconnect(struct phy_device *phydev)
 150 {
 151         if (phydev->irq > 0)
 152                 phy_stop_interrupts(phydev);
 153
 154         phy_stop_machine(phydev);
 155
 156         phydev->adjust_link = NULL;
 157
 158         phy_detach(phydev);
 159 }
 160 EXPORT_SYMBOL(phy_disconnect);
 161
 162 /* phy_attach:
 163  *
 164  *   description: Called by drivers to attach to a particular PHY
 165  *     device. The phy_device is found, and properly hooked up
 166  *     to the phy_driver.  If no driver is attached, then the
 167  *     genphy_driver is used.  The phy_device is given a ptr to
 168  *     the attaching device, and given a callback for link status
 169  *     change.  The phy_device is returned to the attaching
 170  *     driver.
 171  */
 172 static int phy_compare_id(struct device *dev, void *data)
 173 {
 174         return strcmp((char *)data, dev->bus_id) ? 0 : 1;
 175 }
 176
 177 struct phy_device *phy_attach(struct net_device *dev,
 178                 const char *phy_id, u32 flags)
 179 {
 180         struct bus_type *bus = &mdio_bus_type;
 181         struct phy_device *phydev;
 182         struct device *d;
 183
 184         /* Search the list of PHY devices on the mdio bus for the
 185          * PHY with the requested name */
 186         d = bus_find_device(bus, NULL, (void *)phy_id, phy_compare_id);
 187
 188         if (d) {
 189                 phydev = to_phy_device(d);
 190         } else {
 191                 printk(KERN_ERR "%s not found\n", phy_id);
 192                 return ERR_PTR(-ENODEV);
 193         }
 194
 195         /* Assume that if there is no driver, that it doesn't
 196          * exist, and we should use the genphy driver. */
 197         if (NULL == d->driver) {
 198                 int err;
 199                 down_write(&d->bus->subsys.rwsem);
 200                 d->driver = &genphy_driver.driver;
 201
 202                 err = d->driver->probe(d);
 203
 204                 if (err < 0)
 205                         return ERR_PTR(err);
 206
 207                 device_bind_driver(d);
 208                 up_write(&d->bus->subsys.rwsem);
 209         }
 210
 211         if (phydev->attached_dev) {
 212                 printk(KERN_ERR "%s: %s already attached\n",
 213                                 dev->name, phy_id);
 214                 return ERR_PTR(-EBUSY);
 215         }
 216
 217         phydev->attached_dev = dev;
 218
 219         phydev->dev_flags = flags;
 220
 221         return phydev;
 222 }
 223 EXPORT_SYMBOL(phy_attach);
 224
 225 void phy_detach(struct phy_device *phydev)
 226 {
 227         phydev->attached_dev = NULL;
 228
 229         /* If the device had no specific driver before (i.e. - it
 230          * was using the generic driver), we unbind the device
 231          * from the generic driver so that there's a chance a
 232          * real driver could be loaded */
 233         if (phydev->dev.driver == &genphy_driver.driver) {
 234                 down_write(&phydev->dev.bus->subsys.rwsem);
 235                 device_release_driver(&phydev->dev);
 236                 up_write(&phydev->dev.bus->subsys.rwsem);
 237         }
 238 }
 239 EXPORT_SYMBOL(phy_detach);
 240
 241
 242 /* Generic PHY support and helper functions */
 243
 244 /* genphy_config_advert
 245  *
 246  * description: Writes MII_ADVERTISE with the appropriate values,
 247  *   after sanitizing the values to make sure we only advertise
 248  *   what is supported
 249  */
 250 int genphy_config_advert(struct phy_device *phydev)
 251 {
 252         u32 advertise;
 253         int adv;
 254         int err;
 255
 256         /* Only allow advertising what
 257          * this PHY supports */
 258         phydev->advertising &= phydev->supported;
 259         advertise = phydev->advertising;
 260
 261         /* Setup standard advertisement */
 262         adv = phy_read(phydev, MII_ADVERTISE);
 263
 264         if (adv < 0)
 265                 return adv;
 266
 267         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
 268                  ADVERTISE_PAUSE_ASYM);
 269         if (advertise & ADVERTISED_10baseT_Half)
 270                 adv |= ADVERTISE_10HALF;
 271         if (advertise & ADVERTISED_10baseT_Full)
 272                 adv |= ADVERTISE_10FULL;
 273         if (advertise & ADVERTISED_100baseT_Half)
 274                 adv |= ADVERTISE_100HALF;
 275         if (advertise & ADVERTISED_100baseT_Full)
 276                 adv |= ADVERTISE_100FULL;
 277         if (advertise & ADVERTISED_Pause)
 278                 adv |= ADVERTISE_PAUSE_CAP;
 279         if (advertise & ADVERTISED_Asym_Pause)
 280                 adv |= ADVERTISE_PAUSE_ASYM;
 281
 282         err = phy_write(phydev, MII_ADVERTISE, adv);
 283
 284         if (err < 0)
 285                 return err;
 286
 287         /* Configure gigabit if it's supported */
 288         if (phydev->supported & (SUPPORTED_1000baseT_Half |
 289                                 SUPPORTED_1000baseT_Full)) {
 290                 adv = phy_read(phydev, MII_CTRL1000);
 291
 292                 if (adv < 0)
 293                         return adv;
 294
 295                 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
 296                 if (advertise & SUPPORTED_1000baseT_Half)
 297                         adv |= ADVERTISE_1000HALF;
 298                 if (advertise & SUPPORTED_1000baseT_Full)
 299                         adv |= ADVERTISE_1000FULL;
 300                 err = phy_write(phydev, MII_CTRL1000, adv);
 301
 302                 if (err < 0)
 303                         return err;
 304         }
 305
 306         return adv;
 307 }
 308 EXPORT_SYMBOL(genphy_config_advert);
 309
 310 /* genphy_setup_forced
 311  *
 312  * description: Configures MII_BMCR to force speed/duplex
 313  *   to the values in phydev. Assumes that the values are valid.
 314  *   Please see phy_sanitize_settings() */
 315 int genphy_setup_forced(struct phy_device *phydev)
 316 {
 317         int ctl = BMCR_RESET;
 318
 319         phydev->pause = phydev->asym_pause = 0;
 320
 321         if (SPEED_1000 == phydev->speed)
 322                 ctl |= BMCR_SPEED1000;
 323         else if (SPEED_100 == phydev->speed)
 324                 ctl |= BMCR_SPEED100;
 325
 326         if (DUPLEX_FULL == phydev->duplex)
 327                 ctl |= BMCR_FULLDPLX;
 328
 329         ctl = phy_write(phydev, MII_BMCR, ctl);
 330
 331         if (ctl < 0)
 332                 return ctl;
 333
 334         /* We just reset the device, so we'd better configure any
 335          * settings the PHY requires to operate */
 336         if (phydev->drv->config_init)
 337                 ctl = phydev->drv->config_init(phydev);
 338
 339         return ctl;
 340 }
 341
 342
 343 /* Enable and Restart Autonegotiation */
 344 int genphy_restart_aneg(struct phy_device *phydev)
 345 {
 346         int ctl;
 347
 348         ctl = phy_read(phydev, MII_BMCR);
 349
 350         if (ctl < 0)
 351                 return ctl;
 352
 353         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
 354
 355         /* Don't isolate the PHY if we're negotiating */
 356         ctl &= ~(BMCR_ISOLATE);
 357
 358         ctl = phy_write(phydev, MII_BMCR, ctl);
 359
 360         return ctl;
 361 }
 362
 363
 364 /* genphy_config_aneg
 365  *
 366  * description: If auto-negotiation is enabled, we configure the
 367  *   advertising, and then restart auto-negotiation.  If it is not
 368  *   enabled, then we write the BMCR
 369  */
 370 int genphy_config_aneg(struct phy_device *phydev)
 371 {
 372         int err = 0;
 373
 374         if (AUTONEG_ENABLE == phydev->autoneg) {
 375                 err = genphy_config_advert(phydev);
 376
 377                 if (err < 0)
 378                         return err;
 379
 380                 err = genphy_restart_aneg(phydev);
 381         } else
 382                 err = genphy_setup_forced(phydev);
 383
 384         return err;
 385 }
 386 EXPORT_SYMBOL(genphy_config_aneg);
 387
 388 /* genphy_update_link
 389  *
 390  * description: Update the value in phydev->link to reflect the
 391  *   current link value.  In order to do this, we need to read
 392  *   the status register twice, keeping the second value
 393  */
 394 int genphy_update_link(struct phy_device *phydev)
 395 {
 396         int status;
 397
 398         /* Do a fake read */
 399         status = phy_read(phydev, MII_BMSR);
 400
 401         if (status < 0)
 402                 return status;
 403
 404         /* Read link and autonegotiation status */
 405         status = phy_read(phydev, MII_BMSR);
 406
 407         if (status < 0)
 408                 return status;
 409
 410         if ((status & BMSR_LSTATUS) == 0)
 411                 phydev->link = 0;
 412         else
 413                 phydev->link = 1;
 414
 415         return 0;
 416 }
 417
 418 /* genphy_read_status
 419  *
 420  * description: Check the link, then figure out the current state
 421  *   by comparing what we advertise with what the link partner
 422  *   advertises.  Start by checking the gigabit possibilities,
 423  *   then move on to 10/100.
 424  */
 425 int genphy_read_status(struct phy_device *phydev)
 426 {
 427         int adv;
 428         int err;
 429         int lpa;
 430         int lpagb = 0;
 431
 432         /* Update the link, but return if there
 433          * was an error */
 434         err = genphy_update_link(phydev);
 435         if (err)
 436                 return err;
 437
 438         if (AUTONEG_ENABLE == phydev->autoneg) {
 439                 if (phydev->supported & (SUPPORTED_1000baseT_Half
 440                                         | SUPPORTED_1000baseT_Full)) {
 441                         lpagb = phy_read(phydev, MII_STAT1000);
 442
 443                         if (lpagb < 0)
 444                                 return lpagb;
 445
 446                         adv = phy_read(phydev, MII_CTRL1000);
 447
 448                         if (adv < 0)
 449                                 return adv;
 450
 451                         lpagb &= adv << 2;
 452                 }
 453
 454                 lpa = phy_read(phydev, MII_LPA);
 455
 456                 if (lpa < 0)
 457                         return lpa;
 458
 459                 adv = phy_read(phydev, MII_ADVERTISE);
 460
 461                 if (adv < 0)
 462                         return adv;
 463
 464                 lpa &= adv;
 465
 466                 phydev->speed = SPEED_10;
 467                 phydev->duplex = DUPLEX_HALF;
 468                 phydev->pause = phydev->asym_pause = 0;
 469
 470                 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
 471                         phydev->speed = SPEED_1000;
 472
 473                         if (lpagb & LPA_1000FULL)
 474                                 phydev->duplex = DUPLEX_FULL;
 475                 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
 476                         phydev->speed = SPEED_100;
 477
 478                         if (lpa & LPA_100FULL)
 479                                 phydev->duplex = DUPLEX_FULL;
 480                 } else
 481                         if (lpa & LPA_10FULL)
 482                                 phydev->duplex = DUPLEX_FULL;
 483
 484                 if (phydev->duplex == DUPLEX_FULL){
 485                         phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
 486                         phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
 487                 }
 488         } else {
 489                 int bmcr = phy_read(phydev, MII_BMCR);
 490                 if (bmcr < 0)
 491                         return bmcr;
 492
 493                 if (bmcr & BMCR_FULLDPLX)
 494                         phydev->duplex = DUPLEX_FULL;
 495                 else
 496                         phydev->duplex = DUPLEX_HALF;
 497
 498                 if (bmcr & BMCR_SPEED1000)
 499                         phydev->speed = SPEED_1000;
 500                 else if (bmcr & BMCR_SPEED100)
 501                         phydev->speed = SPEED_100;
 502                 else
 503                         phydev->speed = SPEED_10;
 504
 505                 phydev->pause = phydev->asym_pause = 0;
 506         }
 507
 508         return 0;
 509 }
 510 EXPORT_SYMBOL(genphy_read_status);
 511
 512 static int genphy_config_init(struct phy_device *phydev)
 513 {
 514         u32 val;
 515         u32 features;
 516
 517         /* For now, I'll claim that the generic driver supports
 518          * all possible port types */
 519         features = (SUPPORTED_TP | SUPPORTED_MII
 520                         | SUPPORTED_AUI | SUPPORTED_FIBRE |
 521                         SUPPORTED_BNC);
 522
 523         /* Do we support autonegotiation? */
 524         val = phy_read(phydev, MII_BMSR);
 525
 526         if (val < 0)
 527                 return val;
 528
 529         if (val & BMSR_ANEGCAPABLE)
 530                 features |= SUPPORTED_Autoneg;
 531
 532         if (val & BMSR_100FULL)
 533                 features |= SUPPORTED_100baseT_Full;
 534         if (val & BMSR_100HALF)
 535                 features |= SUPPORTED_100baseT_Half;
 536         if (val & BMSR_10FULL)
 537                 features |= SUPPORTED_10baseT_Full;
 538         if (val & BMSR_10HALF)
 539                 features |= SUPPORTED_10baseT_Half;
 540
 541         if (val & BMSR_ESTATEN) {
 542                 val = phy_read(phydev, MII_ESTATUS);
 543
 544                 if (val < 0)
 545                         return val;
 546
 547                 if (val & ESTATUS_1000_TFULL)
 548                         features |= SUPPORTED_1000baseT_Full;
 549                 if (val & ESTATUS_1000_THALF)
 550                         features |= SUPPORTED_1000baseT_Half;
 551         }
 552
 553         phydev->supported = features;
 554         phydev->advertising = features;
 555
 556         return 0;
 557 }
 558
 559
 560 /* phy_probe
 561  *
 562  * description: Take care of setting up the phy_device structure,
 563  *   set the state to READY (the driver's init function should
 564  *   set it to STARTING if needed).
 565  */
 566 static int phy_probe(struct device *dev)
 567 {
 568         struct phy_device *phydev;
 569         struct phy_driver *phydrv;
 570         struct device_driver *drv;
 571         int err = 0;
 572
 573         phydev = to_phy_device(dev);
 574
 575         /* Make sure the driver is held.
 576          * XXX -- Is this correct? */
 577         drv = get_driver(phydev->dev.driver);
 578         phydrv = to_phy_driver(drv);
 579         phydev->drv = phydrv;
 580
 581         /* Disable the interrupt if the PHY doesn't support it */
 582         if (!(phydrv->flags & PHY_HAS_INTERRUPT))
 583                 phydev->irq = PHY_POLL;
 584
 585         spin_lock(&phydev->lock);
 586
 587         /* Start out supporting everything. Eventually,
 588          * a controller will attach, and may modify one
 589          * or both of these values */
 590         phydev->supported = phydrv->features;
 591         phydev->advertising = phydrv->features;
 592
 593         /* Set the state to READY by default */
 594         phydev->state = PHY_READY;
 595
 596         if (phydev->drv->probe)
 597                 err = phydev->drv->probe(phydev);
 598
 599         spin_unlock(&phydev->lock);
 600
 601         if (err < 0)
 602                 return err;
 603
 604         if (phydev->drv->config_init)
 605                 err = phydev->drv->config_init(phydev);
 606
 607         return err;
 608 }
 609
 610 static int phy_remove(struct device *dev)
 611 {
 612         struct phy_device *phydev;
 613
 614         phydev = to_phy_device(dev);
 615
 616         spin_lock(&phydev->lock);
 617         phydev->state = PHY_DOWN;
 618         spin_unlock(&phydev->lock);
 619
 620         if (phydev->drv->remove)
 621                 phydev->drv->remove(phydev);
 622
 623         put_driver(dev->driver);
 624         phydev->drv = NULL;
 625
 626         return 0;
 627 }
 628
 629 int phy_driver_register(struct phy_driver *new_driver)
 630 {
 631         int retval;
 632
 633         memset(&new_driver->driver, 0, sizeof(new_driver->driver));
 634         new_driver->driver.name = new_driver->name;
 635         new_driver->driver.bus = &mdio_bus_type;
 636         new_driver->driver.probe = phy_probe;
 637         new_driver->driver.remove = phy_remove;
 638
 639         retval = driver_register(&new_driver->driver);
 640
 641         if (retval) {
 642                 printk(KERN_ERR "%s: Error %d in registering driver\n",
 643                                 new_driver->name, retval);
 644
 645                 return retval;
 646         }
 647
 648         pr_info("%s: Registered new driver\n", new_driver->name);
 649
 650         return 0;
 651 }
 652 EXPORT_SYMBOL(phy_driver_register);
 653
 654 void phy_driver_unregister(struct phy_driver *drv)
 655 {
 656         driver_unregister(&drv->driver);
 657 }
 658 EXPORT_SYMBOL(phy_driver_unregister);
 659
 660 static struct phy_driver genphy_driver = {
 661         .phy_id         = 0xffffffff,
 662         .phy_id_mask    = 0xffffffff,
 663         .name           = "Generic PHY",
 664         .config_init    = genphy_config_init,
 665         .features       = 0,
 666         .config_aneg    = genphy_config_aneg,
 667         .read_status    = genphy_read_status,
 668         .driver         = {.owner= THIS_MODULE, },
 669 };
 670
 671 static int __init phy_init(void)
 672 {
 673         int rc;
 674
 675         rc = mdio_bus_init();
 676         if (rc)
 677                 return rc;
 678
 679         rc = phy_driver_register(&genphy_driver);
 680         if (rc)
 681                 mdio_bus_exit();
 682
 683         return rc;
 684 }
 685
 686 static void __exit phy_exit(void)
 687 {
 688         phy_driver_unregister(&genphy_driver);
 689         mdio_bus_exit();
 690 }
 691
 692 subsys_initcall(phy_init);
 693 module_exit(phy_exit);