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/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
  38 MODULE_DESCRIPTION("PHY library");
  39 MODULE_AUTHOR("Andy Fleming");
  40 MODULE_LICENSE("GPL");
  41
  42 void phy_device_free(struct phy_device *phydev)
  43 {
  44         kfree(phydev);
  45 }
  46 EXPORT_SYMBOL(phy_device_free);
  47
  48 static void phy_device_release(struct device *dev)
  49 {
  50         phy_device_free(to_phy_device(dev));
  51 }
  52
  53 static struct phy_driver genphy_driver;
  54 extern int mdio_bus_init(void);
  55 extern void mdio_bus_exit(void);
  56
  57 static LIST_HEAD(phy_fixup_list);
  58 static DEFINE_MUTEX(phy_fixup_lock);
  59
  60 static 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  */
  72 int 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 }
  92 EXPORT_SYMBOL(phy_register_fixup);
  93
  94 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
  95 int 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 }
 100 EXPORT_SYMBOL(phy_register_fixup_for_uid);
 101
 102 /* Registers a fixup to be run on the PHY with id string bus_id */
 103 int 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 }
 108 EXPORT_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  */
 114 static 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 */
 129 int 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 }
 150 EXPORT_SYMBOL(phy_scan_fixups);
 151
 152 static 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  */
 210 int 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 }
 233 EXPORT_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  */
 243 struct 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 }
 261 EXPORT_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  */
 267 int 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 }
 292 EXPORT_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  */
 298 struct 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 }
 308 EXPORT_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  */
 322 static 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  */
 336 int 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 }
 353 EXPORT_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  */
 371 struct 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 }
 394 EXPORT_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  */
 400 void 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 }
 411 EXPORT_SYMBOL(phy_disconnect);
 412
 413 int 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  */
 441 static 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  */
 494 struct 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 }
 517 EXPORT_SYMBOL(phy_attach);
 518
 519 /**
 520  * phy_detach - detach a PHY device from its network device
 521  * @phydev: target phy_device struct
 522  */
 523 void 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 }
 535 EXPORT_SYMBOL(phy_detach);
 536
 537
 538 /* Generic PHY support and helper functions */
 539
 540 /**
 541  * genphy_config_advert - sanitize and advertise auto-negotation 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  */
 549 static 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  */
 623 static 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  */
 648 int 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 }
 666 EXPORT_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  */
 677 int 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                 /* Advertisment 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 }
 708 EXPORT_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  */
 718 int 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 }
 741 EXPORT_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  */
 752 int 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 }
 837 EXPORT_SYMBOL(genphy_read_status);
 838
 839 static 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 }
 885 int 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 }
 898 EXPORT_SYMBOL(genphy_suspend);
 899
 900 int 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 }
 913 EXPORT_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  */
 923 static 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
 962 static 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  */
 985 int 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 }
1007 EXPORT_SYMBOL(phy_driver_register);
1008
1009 void phy_driver_unregister(struct phy_driver *drv)
1010 {
1011         driver_unregister(&drv->driver);
1012 }
1013 EXPORT_SYMBOL(phy_driver_unregister);
1014
1015 static 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
1028 static 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
1043 static void __exit phy_exit(void)
1044 {
1045         phy_driver_unregister(&genphy_driver);
1046         mdio_bus_exit();
1047 }
1048
1049 subsys_initcall(phy_init);
1050 module_exit(phy_exit);