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
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/kernel.h>
  21 #include <linux/string.h>
  22 #include <linux/errno.h>
  23 #include <linux/unistd.h>
  24 #include <linux/slab.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/netdevice.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/mm.h>
  32 #include <linux/module.h>
  33 #include <linux/mii.h>
  34 #include <linux/ethtool.h>
  35 #include <linux/phy.h>
  36
  37 #include <asm/io.h>
  38 #include <asm/irq.h>
  39 #include <asm/uaccess.h>
  40
  41 MODULE_DESCRIPTION("PHY library");
  42 MODULE_AUTHOR("Andy Fleming");
  43 MODULE_LICENSE("GPL");
  44
  45 void phy_device_free(struct phy_device *phydev)
  46 {
  47         put_device(&phydev->dev);
  48 }
  49 EXPORT_SYMBOL(phy_device_free);
  50
  51 static void phy_device_release(struct device *dev)
  52 {
  53         kfree(to_phy_device(dev));
  54 }
  55
  56 static struct phy_driver genphy_driver;
  57 extern int mdio_bus_init(void);
  58 extern void mdio_bus_exit(void);
  59
  60 static LIST_HEAD(phy_fixup_list);
  61 static DEFINE_MUTEX(phy_fixup_lock);
  62
  63 static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
  64                              u32 flags, phy_interface_t interface);
  65
  66 /*
  67  * Creates a new phy_fixup and adds it to the list
  68  * @bus_id: A string which matches phydev->dev.bus_id (or PHY_ANY_ID)
  69  * @phy_uid: Used to match against phydev->phy_id (the UID of the PHY)
  70  *      It can also be PHY_ANY_UID
  71  * @phy_uid_mask: Applied to phydev->phy_id and fixup->phy_uid before
  72  *      comparison
  73  * @run: The actual code to be run when a matching PHY is found
  74  */
  75 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
  76                 int (*run)(struct phy_device *))
  77 {
  78         struct phy_fixup *fixup;
  79
  80         fixup = kzalloc(sizeof(struct phy_fixup), GFP_KERNEL);
  81         if (!fixup)
  82                 return -ENOMEM;
  83
  84         strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
  85         fixup->phy_uid = phy_uid;
  86         fixup->phy_uid_mask = phy_uid_mask;
  87         fixup->run = run;
  88
  89         mutex_lock(&phy_fixup_lock);
  90         list_add_tail(&fixup->list, &phy_fixup_list);
  91         mutex_unlock(&phy_fixup_lock);
  92
  93         return 0;
  94 }
  95 EXPORT_SYMBOL(phy_register_fixup);
  96
  97 /* Registers a fixup to be run on any PHY with the UID in phy_uid */
  98 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
  99                 int (*run)(struct phy_device *))
 100 {
 101         return phy_register_fixup(PHY_ANY_ID, phy_uid, phy_uid_mask, run);
 102 }
 103 EXPORT_SYMBOL(phy_register_fixup_for_uid);
 104
 105 /* Registers a fixup to be run on the PHY with id string bus_id */
 106 int phy_register_fixup_for_id(const char *bus_id,
 107                 int (*run)(struct phy_device *))
 108 {
 109         return phy_register_fixup(bus_id, PHY_ANY_UID, 0xffffffff, run);
 110 }
 111 EXPORT_SYMBOL(phy_register_fixup_for_id);
 112
 113 /*
 114  * Returns 1 if fixup matches phydev in bus_id and phy_uid.
 115  * Fixups can be set to match any in one or more fields.
 116  */
 117 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
 118 {
 119         if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
 120                 if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
 121                         return 0;
 122
 123         if ((fixup->phy_uid & fixup->phy_uid_mask) !=
 124                         (phydev->phy_id & fixup->phy_uid_mask))
 125                 if (fixup->phy_uid != PHY_ANY_UID)
 126                         return 0;
 127
 128         return 1;
 129 }
 130
 131 /* Runs any matching fixups for this phydev */
 132 int phy_scan_fixups(struct phy_device *phydev)
 133 {
 134         struct phy_fixup *fixup;
 135
 136         mutex_lock(&phy_fixup_lock);
 137         list_for_each_entry(fixup, &phy_fixup_list, list) {
 138                 if (phy_needs_fixup(phydev, fixup)) {
 139                         int err;
 140
 141                         err = fixup->run(phydev);
 142
 143                         if (err < 0) {
 144                                 mutex_unlock(&phy_fixup_lock);
 145                                 return err;
 146                         }
 147                 }
 148         }
 149         mutex_unlock(&phy_fixup_lock);
 150
 151         return 0;
 152 }
 153 EXPORT_SYMBOL(phy_scan_fixups);
 154
 155 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
 156                         bool is_c45, struct phy_c45_device_ids *c45_ids)
 157 {
 158         struct phy_device *dev;
 159
 160         /* We allocate the device, and initialize the
 161          * default values */
 162         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 163
 164         if (NULL == dev)
 165                 return (struct phy_device*) PTR_ERR((void*)-ENOMEM);
 166
 167         dev->dev.release = phy_device_release;
 168
 169         dev->speed = 0;
 170         dev->duplex = -1;
 171         dev->pause = dev->asym_pause = 0;
 172         dev->link = 1;
 173         dev->interface = PHY_INTERFACE_MODE_GMII;
 174
 175         dev->autoneg = AUTONEG_ENABLE;
 176
 177         dev->is_c45 = is_c45;
 178         dev->addr = addr;
 179         dev->phy_id = phy_id;
 180         if (c45_ids)
 181                 dev->c45_ids = *c45_ids;
 182         dev->bus = bus;
 183         dev->dev.parent = bus->parent;
 184         dev->dev.bus = &mdio_bus_type;
 185         dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
 186         dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
 187
 188         dev->state = PHY_DOWN;
 189
 190         mutex_init(&dev->lock);
 191         INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
 192         INIT_WORK(&dev->phy_queue, phy_change);
 193
 194         /* Request the appropriate module unconditionally; don't
 195            bother trying to do so only if it isn't already loaded,
 196            because that gets complicated. A hotplug event would have
 197            done an unconditional modprobe anyway.
 198            We don't do normal hotplug because it won't work for MDIO
 199            -- because it relies on the device staying around for long
 200            enough for the driver to get loaded. With MDIO, the NIC
 201            driver will get bored and give up as soon as it finds that
 202            there's no driver _already_ loaded. */
 203         request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id));
 204
 205         device_initialize(&dev->dev);
 206
 207         return dev;
 208 }
 209 EXPORT_SYMBOL(phy_device_create);
 210
 211 /**
 212  * get_phy_c45_ids - reads the specified addr for its 802.3-c45 IDs.
 213  * @bus: the target MII bus
 214  * @addr: PHY address on the MII bus
 215  * @phy_id: where to store the ID retrieved.
 216  * @c45_ids: where to store the c45 ID information.
 217  *
 218  *   If the PHY devices-in-package appears to be valid, it and the
 219  *   corresponding identifiers are stored in @c45_ids, zero is stored
 220  *   in @phy_id.  Otherwise 0xffffffff is stored in @phy_id.  Returns
 221  *   zero on success.
 222  *
 223  */
 224 static int get_phy_c45_ids(struct mii_bus *bus, int addr, u32 *phy_id,
 225                            struct phy_c45_device_ids *c45_ids) {
 226         int phy_reg;
 227         int i, reg_addr;
 228         const int num_ids = ARRAY_SIZE(c45_ids->device_ids);
 229
 230         /* Find first non-zero Devices In package.  Device
 231          * zero is reserved, so don't probe it.
 232          */
 233         for (i = 1;
 234              i < num_ids && c45_ids->devices_in_package == 0;
 235              i++) {
 236                 reg_addr = MII_ADDR_C45 | i << 16 | 6;
 237                 phy_reg = mdiobus_read(bus, addr, reg_addr);
 238                 if (phy_reg < 0)
 239                         return -EIO;
 240                 c45_ids->devices_in_package = (phy_reg & 0xffff) << 16;
 241
 242                 reg_addr = MII_ADDR_C45 | i << 16 | 5;
 243                 phy_reg = mdiobus_read(bus, addr, reg_addr);
 244                 if (phy_reg < 0)
 245                         return -EIO;
 246                 c45_ids->devices_in_package |= (phy_reg & 0xffff);
 247
 248                 /* If mostly Fs, there is no device there,
 249                  * let's get out of here.
 250                  */
 251                 if ((c45_ids->devices_in_package & 0x1fffffff) == 0x1fffffff) {
 252                         *phy_id = 0xffffffff;
 253                         return 0;
 254                 }
 255         }
 256
 257         /* Now probe Device Identifiers for each device present. */
 258         for (i = 1; i < num_ids; i++) {
 259                 if (!(c45_ids->devices_in_package & (1 << i)))
 260                         continue;
 261
 262                 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID1;
 263                 phy_reg = mdiobus_read(bus, addr, reg_addr);
 264                 if (phy_reg < 0)
 265                         return -EIO;
 266                 c45_ids->device_ids[i] = (phy_reg & 0xffff) << 16;
 267
 268                 reg_addr = MII_ADDR_C45 | i << 16 | MII_PHYSID2;
 269                 phy_reg = mdiobus_read(bus, addr, reg_addr);
 270                 if (phy_reg < 0)
 271                         return -EIO;
 272                 c45_ids->device_ids[i] |= (phy_reg & 0xffff);
 273         }
 274         *phy_id = 0;
 275         return 0;
 276 }
 277
 278 /**
 279  * get_phy_id - reads the specified addr for its ID.
 280  * @bus: the target MII bus
 281  * @addr: PHY address on the MII bus
 282  * @phy_id: where to store the ID retrieved.
 283  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
 284  * @c45_ids: where to store the c45 ID information.
 285  *
 286  * Description: In the case of a 802.3-c22 PHY, reads the ID registers
 287  *   of the PHY at @addr on the @bus, stores it in @phy_id and returns
 288  *   zero on success.
 289  *
 290  *   In the case of a 802.3-c45 PHY, get_phy_c45_ids() is invoked, and
 291  *   its return value is in turn returned.
 292  *
 293  */
 294 static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
 295                       bool is_c45, struct phy_c45_device_ids *c45_ids)
 296 {
 297         int phy_reg;
 298
 299         if (is_c45)
 300                 return get_phy_c45_ids(bus, addr, phy_id, c45_ids);
 301
 302         /* Grab the bits from PHYIR1, and put them
 303          * in the upper half */
 304         phy_reg = mdiobus_read(bus, addr, MII_PHYSID1);
 305
 306         if (phy_reg < 0)
 307                 return -EIO;
 308
 309         *phy_id = (phy_reg & 0xffff) << 16;
 310
 311         /* Grab the bits from PHYIR2, and put them in the lower half */
 312         phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
 313
 314         if (phy_reg < 0)
 315                 return -EIO;
 316
 317         *phy_id |= (phy_reg & 0xffff);
 318
 319         return 0;
 320 }
 321
 322 /**
 323  * get_phy_device - reads the specified PHY device and returns its @phy_device struct
 324  * @bus: the target MII bus
 325  * @addr: PHY address on the MII bus
 326  * @is_c45: If true the PHY uses the 802.3 clause 45 protocol
 327  *
 328  * Description: Reads the ID registers of the PHY at @addr on the
 329  *   @bus, then allocates and returns the phy_device to represent it.
 330  */
 331 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
 332 {
 333         struct phy_c45_device_ids c45_ids = {0};
 334         struct phy_device *dev = NULL;
 335         u32 phy_id = 0;
 336         int r;
 337
 338         r = get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);
 339         if (r)
 340                 return ERR_PTR(r);
 341
 342         /* If the phy_id is mostly Fs, there is no device there */
 343         if ((phy_id & 0x1fffffff) == 0x1fffffff)
 344                 return NULL;
 345
 346         dev = phy_device_create(bus, addr, phy_id, is_c45, &c45_ids);
 347
 348         return dev;
 349 }
 350 EXPORT_SYMBOL(get_phy_device);
 351
 352 /**
 353  * phy_device_register - Register the phy device on the MDIO bus
 354  * @phydev: phy_device structure to be added to the MDIO bus
 355  */
 356 int phy_device_register(struct phy_device *phydev)
 357 {
 358         int err;
 359
 360         /* Don't register a phy if one is already registered at this
 361          * address */
 362         if (phydev->bus->phy_map[phydev->addr])
 363                 return -EINVAL;
 364         phydev->bus->phy_map[phydev->addr] = phydev;
 365
 366         /* Run all of the fixups for this PHY */
 367         err = phy_init_hw(phydev);
 368         if (err) {
 369                 pr_err("PHY %d failed to initialize\n", phydev->addr);
 370                 goto out;
 371         }
 372
 373         err = device_add(&phydev->dev);
 374         if (err) {
 375                 pr_err("PHY %d failed to add\n", phydev->addr);
 376                 goto out;
 377         }
 378
 379         return 0;
 380
 381  out:
 382         phydev->bus->phy_map[phydev->addr] = NULL;
 383         return err;
 384 }
 385 EXPORT_SYMBOL(phy_device_register);
 386
 387 /**
 388  * phy_find_first - finds the first PHY device on the bus
 389  * @bus: the target MII bus
 390  */
 391 struct phy_device *phy_find_first(struct mii_bus *bus)
 392 {
 393         int addr;
 394
 395         for (addr = 0; addr < PHY_MAX_ADDR; addr++) {
 396                 if (bus->phy_map[addr])
 397                         return bus->phy_map[addr];
 398         }
 399         return NULL;
 400 }
 401 EXPORT_SYMBOL(phy_find_first);
 402
 403 /**
 404  * phy_prepare_link - prepares the PHY layer to monitor link status
 405  * @phydev: target phy_device struct
 406  * @handler: callback function for link status change notifications
 407  *
 408  * Description: Tells the PHY infrastructure to handle the
 409  *   gory details on monitoring link status (whether through
 410  *   polling or an interrupt), and to call back to the
 411  *   connected device driver when the link status changes.
 412  *   If you want to monitor your own link state, don't call
 413  *   this function.
 414  */
 415 static void phy_prepare_link(struct phy_device *phydev,
 416                 void (*handler)(struct net_device *))
 417 {
 418         phydev->adjust_link = handler;
 419 }
 420
 421 /**
 422  * phy_connect_direct - connect an ethernet device to a specific phy_device
 423  * @dev: the network device to connect
 424  * @phydev: the pointer to the phy device
 425  * @handler: callback function for state change notifications
 426  * @interface: PHY device's interface
 427  */
 428 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
 429                        void (*handler)(struct net_device *),
 430                        phy_interface_t interface)
 431 {
 432         int rc;
 433
 434         rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
 435         if (rc)
 436                 return rc;
 437
 438         phy_prepare_link(phydev, handler);
 439         phy_start_machine(phydev, NULL);
 440         if (phydev->irq > 0)
 441                 phy_start_interrupts(phydev);
 442
 443         return 0;
 444 }
 445 EXPORT_SYMBOL(phy_connect_direct);
 446
 447 /**
 448  * phy_connect - connect an ethernet device to a PHY device
 449  * @dev: the network device to connect
 450  * @bus_id: the id string of the PHY device to connect
 451  * @handler: callback function for state change notifications
 452  * @interface: PHY device's interface
 453  *
 454  * Description: Convenience function for connecting ethernet
 455  *   devices to PHY devices.  The default behavior is for
 456  *   the PHY infrastructure to handle everything, and only notify
 457  *   the connected driver when the link status changes.  If you
 458  *   don't want, or can't use the provided functionality, you may
 459  *   choose to call only the subset of functions which provide
 460  *   the desired functionality.
 461  */
 462 struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
 463                 void (*handler)(struct net_device *),
 464                 phy_interface_t interface)
 465 {
 466         struct phy_device *phydev;
 467         struct device *d;
 468         int rc;
 469
 470         /* Search the list of PHY devices on the mdio bus for the
 471          * PHY with the requested name */
 472         d = bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);
 473         if (!d) {
 474                 pr_err("PHY %s not found\n", bus_id);
 475                 return ERR_PTR(-ENODEV);
 476         }
 477         phydev = to_phy_device(d);
 478
 479         rc = phy_connect_direct(dev, phydev, handler, interface);
 480         if (rc)
 481                 return ERR_PTR(rc);
 482
 483         return phydev;
 484 }
 485 EXPORT_SYMBOL(phy_connect);
 486
 487 /**
 488  * phy_disconnect - disable interrupts, stop state machine, and detach a PHY device
 489  * @phydev: target phy_device struct
 490  */
 491 void phy_disconnect(struct phy_device *phydev)
 492 {
 493         if (phydev->irq > 0)
 494                 phy_stop_interrupts(phydev);
 495
 496         phy_stop_machine(phydev);
 497
 498         phydev->adjust_link = NULL;
 499
 500         phy_detach(phydev);
 501 }
 502 EXPORT_SYMBOL(phy_disconnect);
 503
 504 /**
 505  * phy_poll_reset - Safely wait until a PHY reset has properly completed
 506  * @phydev: The PHY device to poll
 507  *
 508  * Description: According to IEEE 802.3, Section 2, Subsection 22.2.4.1.1, as
 509  *   published in 2008, a PHY reset may take up to 0.5 seconds.  The MII BMCR
 510  *   register must be polled until the BMCR_RESET bit clears.
 511  *
 512  *   Furthermore, any attempts to write to PHY registers may have no effect
 513  *   or even generate MDIO bus errors until this is complete.
 514  *
 515  *   Some PHYs (such as the Marvell 88E1111) don't entirely conform to the
 516  *   standard and do not fully reset after the BMCR_RESET bit is set, and may
 517  *   even *REQUIRE* a soft-reset to properly restart autonegotiation.  In an
 518  *   effort to support such broken PHYs, this function is separate from the
 519  *   standard phy_init_hw() which will zero all the other bits in the BMCR
 520  *   and reapply all driver-specific and board-specific fixups.
 521  */
 522 static int phy_poll_reset(struct phy_device *phydev)
 523 {
 524         /* Poll until the reset bit clears (50ms per retry == 0.6 sec) */
 525         unsigned int retries = 12;
 526         int ret;
 527
 528         do {
 529                 msleep(50);
 530                 ret = phy_read(phydev, MII_BMCR);
 531                 if (ret < 0)
 532                         return ret;
 533         } while (ret & BMCR_RESET && --retries);
 534         if (ret & BMCR_RESET)
 535                 return -ETIMEDOUT;
 536
 537         /*
 538          * Some chips (smsc911x) may still need up to another 1ms after the
 539          * BMCR_RESET bit is cleared before they are usable.
 540          */
 541         msleep(1);
 542         return 0;
 543 }
 544
 545 int phy_init_hw(struct phy_device *phydev)
 546 {
 547         int ret;
 548
 549         if (!phydev->drv || !phydev->drv->config_init)
 550                 return 0;
 551
 552         ret = phy_write(phydev, MII_BMCR, BMCR_RESET);
 553         if (ret < 0)
 554                 return ret;
 555
 556         ret = phy_poll_reset(phydev);
 557         if (ret < 0)
 558                 return ret;
 559
 560         ret = phy_scan_fixups(phydev);
 561         if (ret < 0)
 562                 return ret;
 563
 564         return phydev->drv->config_init(phydev);
 565 }
 566 EXPORT_SYMBOL(phy_init_hw);
 567
 568 /**
 569  * phy_attach_direct - attach a network device to a given PHY device pointer
 570  * @dev: network device to attach
 571  * @phydev: Pointer to phy_device to attach
 572  * @flags: PHY device's dev_flags
 573  * @interface: PHY device's interface
 574  *
 575  * Description: Called by drivers to attach to a particular PHY
 576  *     device. The phy_device is found, and properly hooked up
 577  *     to the phy_driver.  If no driver is attached, then the
 578  *     genphy_driver is used.  The phy_device is given a ptr to
 579  *     the attaching device, and given a callback for link status
 580  *     change.  The phy_device is returned to the attaching driver.
 581  */
 582 static int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
 583                              u32 flags, phy_interface_t interface)
 584 {
 585         struct device *d = &phydev->dev;
 586         int err;
 587
 588         /* Assume that if there is no driver, that it doesn't
 589          * exist, and we should use the genphy driver. */
 590         if (NULL == d->driver) {
 591                 if (phydev->is_c45) {
 592                         pr_err("No driver for phy %x\n", phydev->phy_id);
 593                         return -ENODEV;
 594                 }
 595
 596                 d->driver = &genphy_driver.driver;
 597
 598                 err = d->driver->probe(d);
 599                 if (err >= 0)
 600                         err = device_bind_driver(d);
 601
 602                 if (err)
 603                         return err;
 604         }
 605
 606         if (phydev->attached_dev) {
 607                 dev_err(&dev->dev, "PHY already attached\n");
 608                 return -EBUSY;
 609         }
 610
 611         phydev->attached_dev = dev;
 612         dev->phydev = phydev;
 613
 614         phydev->dev_flags = flags;
 615
 616         phydev->interface = interface;
 617
 618         phydev->state = PHY_READY;
 619
 620         /* Do initial configuration here, now that
 621          * we have certain key parameters
 622          * (dev_flags and interface) */
 623         err = phy_init_hw(phydev);
 624         if (err)
 625                 phy_detach(phydev);
 626
 627         return err;
 628 }
 629
 630 /**
 631  * phy_attach - attach a network device to a particular PHY device
 632  * @dev: network device to attach
 633  * @bus_id: Bus ID of PHY device to attach
 634  * @interface: PHY device's interface
 635  *
 636  * Description: Same as phy_attach_direct() except that a PHY bus_id
 637  *     string is passed instead of a pointer to a struct phy_device.
 638  */
 639 struct phy_device *phy_attach(struct net_device *dev,
 640                 const char *bus_id, phy_interface_t interface)
 641 {
 642         struct bus_type *bus = &mdio_bus_type;
 643         struct phy_device *phydev;
 644         struct device *d;
 645         int rc;
 646
 647         /* Search the list of PHY devices on the mdio bus for the
 648          * PHY with the requested name */
 649         d = bus_find_device_by_name(bus, NULL, bus_id);
 650         if (!d) {
 651                 pr_err("PHY %s not found\n", bus_id);
 652                 return ERR_PTR(-ENODEV);
 653         }
 654         phydev = to_phy_device(d);
 655
 656         rc = phy_attach_direct(dev, phydev, phydev->dev_flags, interface);
 657         if (rc)
 658                 return ERR_PTR(rc);
 659
 660         return phydev;
 661 }
 662 EXPORT_SYMBOL(phy_attach);
 663
 664 /**
 665  * phy_detach - detach a PHY device from its network device
 666  * @phydev: target phy_device struct
 667  */
 668 void phy_detach(struct phy_device *phydev)
 669 {
 670         phydev->attached_dev->phydev = NULL;
 671         phydev->attached_dev = NULL;
 672
 673         /* If the device had no specific driver before (i.e. - it
 674          * was using the generic driver), we unbind the device
 675          * from the generic driver so that there's a chance a
 676          * real driver could be loaded */
 677         if (phydev->dev.driver == &genphy_driver.driver)
 678                 device_release_driver(&phydev->dev);
 679 }
 680 EXPORT_SYMBOL(phy_detach);
 681
 682
 683 /* Generic PHY support and helper functions */
 684
 685 /**
 686  * genphy_config_advert - sanitize and advertise auto-negotiation parameters
 687  * @phydev: target phy_device struct
 688  *
 689  * Description: Writes MII_ADVERTISE with the appropriate values,
 690  *   after sanitizing the values to make sure we only advertise
 691  *   what is supported.  Returns < 0 on error, 0 if the PHY's advertisement
 692  *   hasn't changed, and > 0 if it has changed.
 693  */
 694 static int genphy_config_advert(struct phy_device *phydev)
 695 {
 696         u32 advertise;
 697         int oldadv, adv;
 698         int err, changed = 0;
 699
 700         /* Only allow advertising what
 701          * this PHY supports */
 702         phydev->advertising &= phydev->supported;
 703         advertise = phydev->advertising;
 704
 705         /* Setup standard advertisement */
 706         oldadv = adv = phy_read(phydev, MII_ADVERTISE);
 707
 708         if (adv < 0)
 709                 return adv;
 710
 711         adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP |
 712                  ADVERTISE_PAUSE_ASYM);
 713         adv |= ethtool_adv_to_mii_adv_t(advertise);
 714
 715         if (adv != oldadv) {
 716                 err = phy_write(phydev, MII_ADVERTISE, adv);
 717
 718                 if (err < 0)
 719                         return err;
 720                 changed = 1;
 721         }
 722
 723         /* Configure gigabit if it's supported */
 724         if (phydev->supported & (SUPPORTED_1000baseT_Half |
 725                                 SUPPORTED_1000baseT_Full)) {
 726                 oldadv = adv = phy_read(phydev, MII_CTRL1000);
 727
 728                 if (adv < 0)
 729                         return adv;
 730
 731                 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
 732                 adv |= ethtool_adv_to_mii_ctrl1000_t(advertise);
 733
 734                 if (adv != oldadv) {
 735                         err = phy_write(phydev, MII_CTRL1000, adv);
 736
 737                         if (err < 0)
 738                                 return err;
 739                         changed = 1;
 740                 }
 741         }
 742
 743         return changed;
 744 }
 745
 746 /**
 747  * genphy_setup_forced - configures/forces speed/duplex from @phydev
 748  * @phydev: target phy_device struct
 749  *
 750  * Description: Configures MII_BMCR to force speed/duplex
 751  *   to the values in phydev. Assumes that the values are valid.
 752  *   Please see phy_sanitize_settings().
 753  */
 754 int genphy_setup_forced(struct phy_device *phydev)
 755 {
 756         int err;
 757         int ctl = 0;
 758
 759         phydev->pause = phydev->asym_pause = 0;
 760
 761         if (SPEED_1000 == phydev->speed)
 762                 ctl |= BMCR_SPEED1000;
 763         else if (SPEED_100 == phydev->speed)
 764                 ctl |= BMCR_SPEED100;
 765
 766         if (DUPLEX_FULL == phydev->duplex)
 767                 ctl |= BMCR_FULLDPLX;
 768
 769         err = phy_write(phydev, MII_BMCR, ctl);
 770
 771         return err;
 772 }
 773 EXPORT_SYMBOL(genphy_setup_forced);
 774
 775 /**
 776  * genphy_restart_aneg - Enable and Restart Autonegotiation
 777  * @phydev: target phy_device struct
 778  */
 779 int genphy_restart_aneg(struct phy_device *phydev)
 780 {
 781         int ctl;
 782
 783         ctl = phy_read(phydev, MII_BMCR);
 784
 785         if (ctl < 0)
 786                 return ctl;
 787
 788         ctl |= (BMCR_ANENABLE | BMCR_ANRESTART);
 789
 790         /* Don't isolate the PHY if we're negotiating */
 791         ctl &= ~(BMCR_ISOLATE);
 792
 793         ctl = phy_write(phydev, MII_BMCR, ctl);
 794
 795         return ctl;
 796 }
 797 EXPORT_SYMBOL(genphy_restart_aneg);
 798
 799
 800 /**
 801  * genphy_config_aneg - restart auto-negotiation or write BMCR
 802  * @phydev: target phy_device struct
 803  *
 804  * Description: If auto-negotiation is enabled, we configure the
 805  *   advertising, and then restart auto-negotiation.  If it is not
 806  *   enabled, then we write the BMCR.
 807  */
 808 int genphy_config_aneg(struct phy_device *phydev)
 809 {
 810         int result;
 811
 812         if (AUTONEG_ENABLE != phydev->autoneg)
 813                 return genphy_setup_forced(phydev);
 814
 815         result = genphy_config_advert(phydev);
 816
 817         if (result < 0) /* error */
 818                 return result;
 819
 820         if (result == 0) {
 821                 /* Advertisement hasn't changed, but maybe aneg was never on to
 822                  * begin with?  Or maybe phy was isolated? */
 823                 int ctl = phy_read(phydev, MII_BMCR);
 824
 825                 if (ctl < 0)
 826                         return ctl;
 827
 828                 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE))
 829                         result = 1; /* do restart aneg */
 830         }
 831
 832         /* Only restart aneg if we are advertising something different
 833          * than we were before.  */
 834         if (result > 0)
 835                 result = genphy_restart_aneg(phydev);
 836
 837         return result;
 838 }
 839 EXPORT_SYMBOL(genphy_config_aneg);
 840
 841 /**
 842  * genphy_update_link - update link status in @phydev
 843  * @phydev: target phy_device struct
 844  *
 845  * Description: Update the value in phydev->link to reflect the
 846  *   current link value.  In order to do this, we need to read
 847  *   the status register twice, keeping the second value.
 848  */
 849 int genphy_update_link(struct phy_device *phydev)
 850 {
 851         int status;
 852
 853         /* Do a fake read */
 854         status = phy_read(phydev, MII_BMSR);
 855
 856         if (status < 0)
 857                 return status;
 858
 859         /* Read link and autonegotiation status */
 860         status = phy_read(phydev, MII_BMSR);
 861
 862         if (status < 0)
 863                 return status;
 864
 865         if ((status & BMSR_LSTATUS) == 0)
 866                 phydev->link = 0;
 867         else
 868                 phydev->link = 1;
 869
 870         return 0;
 871 }
 872 EXPORT_SYMBOL(genphy_update_link);
 873
 874 /**
 875  * genphy_read_status - check the link status and update current link state
 876  * @phydev: target phy_device struct
 877  *
 878  * Description: Check the link, then figure out the current state
 879  *   by comparing what we advertise with what the link partner
 880  *   advertises.  Start by checking the gigabit possibilities,
 881  *   then move on to 10/100.
 882  */
 883 int genphy_read_status(struct phy_device *phydev)
 884 {
 885         int adv;
 886         int err;
 887         int lpa;
 888         int lpagb = 0;
 889
 890         /* Update the link, but return if there
 891          * was an error */
 892         err = genphy_update_link(phydev);
 893         if (err)
 894                 return err;
 895
 896         phydev->lp_advertising = 0;
 897
 898         if (AUTONEG_ENABLE == phydev->autoneg) {
 899                 if (phydev->supported & (SUPPORTED_1000baseT_Half
 900                                         | SUPPORTED_1000baseT_Full)) {
 901                         lpagb = phy_read(phydev, MII_STAT1000);
 902
 903                         if (lpagb < 0)
 904                                 return lpagb;
 905
 906                         adv = phy_read(phydev, MII_CTRL1000);
 907
 908                         if (adv < 0)
 909                                 return adv;
 910
 911                         phydev->lp_advertising =
 912                                 mii_stat1000_to_ethtool_lpa_t(lpagb);
 913                         lpagb &= adv << 2;
 914                 }
 915
 916                 lpa = phy_read(phydev, MII_LPA);
 917
 918                 if (lpa < 0)
 919                         return lpa;
 920
 921                 phydev->lp_advertising |= mii_lpa_to_ethtool_lpa_t(lpa);
 922
 923                 adv = phy_read(phydev, MII_ADVERTISE);
 924
 925                 if (adv < 0)
 926                         return adv;
 927
 928                 lpa &= adv;
 929
 930                 phydev->speed = SPEED_10;
 931                 phydev->duplex = DUPLEX_HALF;
 932                 phydev->pause = phydev->asym_pause = 0;
 933
 934                 if (lpagb & (LPA_1000FULL | LPA_1000HALF)) {
 935                         phydev->speed = SPEED_1000;
 936
 937                         if (lpagb & LPA_1000FULL)
 938                                 phydev->duplex = DUPLEX_FULL;
 939                 } else if (lpa & (LPA_100FULL | LPA_100HALF)) {
 940                         phydev->speed = SPEED_100;
 941
 942                         if (lpa & LPA_100FULL)
 943                                 phydev->duplex = DUPLEX_FULL;
 944                 } else
 945                         if (lpa & LPA_10FULL)
 946                                 phydev->duplex = DUPLEX_FULL;
 947
 948                 if (phydev->duplex == DUPLEX_FULL){
 949                         phydev->pause = lpa & LPA_PAUSE_CAP ? 1 : 0;
 950                         phydev->asym_pause = lpa & LPA_PAUSE_ASYM ? 1 : 0;
 951                 }
 952         } else {
 953                 int bmcr = phy_read(phydev, MII_BMCR);
 954                 if (bmcr < 0)
 955                         return bmcr;
 956
 957                 if (bmcr & BMCR_FULLDPLX)
 958                         phydev->duplex = DUPLEX_FULL;
 959                 else
 960                         phydev->duplex = DUPLEX_HALF;
 961
 962                 if (bmcr & BMCR_SPEED1000)
 963                         phydev->speed = SPEED_1000;
 964                 else if (bmcr & BMCR_SPEED100)
 965                         phydev->speed = SPEED_100;
 966                 else
 967                         phydev->speed = SPEED_10;
 968
 969                 phydev->pause = phydev->asym_pause = 0;
 970         }
 971
 972         return 0;
 973 }
 974 EXPORT_SYMBOL(genphy_read_status);
 975
 976 static int genphy_config_init(struct phy_device *phydev)
 977 {
 978         int val;
 979         u32 features;
 980
 981         /* For now, I'll claim that the generic driver supports
 982          * all possible port types */
 983         features = (SUPPORTED_TP | SUPPORTED_MII
 984                         | SUPPORTED_AUI | SUPPORTED_FIBRE |
 985                         SUPPORTED_BNC);
 986
 987         /* Do we support autonegotiation? */
 988         val = phy_read(phydev, MII_BMSR);
 989
 990         if (val < 0)
 991                 return val;
 992
 993         if (val & BMSR_ANEGCAPABLE)
 994                 features |= SUPPORTED_Autoneg;
 995
 996         if (val & BMSR_100FULL)
 997                 features |= SUPPORTED_100baseT_Full;
 998         if (val & BMSR_100HALF)
 999                 features |= SUPPORTED_100baseT_Half;
1000         if (val & BMSR_10FULL)
1001                 features |= SUPPORTED_10baseT_Full;
1002         if (val & BMSR_10HALF)
1003                 features |= SUPPORTED_10baseT_Half;
1004
1005         if (val & BMSR_ESTATEN) {
1006                 val = phy_read(phydev, MII_ESTATUS);
1007
1008                 if (val < 0)
1009                         return val;
1010
1011                 if (val & ESTATUS_1000_TFULL)
1012                         features |= SUPPORTED_1000baseT_Full;
1013                 if (val & ESTATUS_1000_THALF)
1014                         features |= SUPPORTED_1000baseT_Half;
1015         }
1016
1017         phydev->supported = features;
1018         phydev->advertising = features;
1019
1020         return 0;
1021 }
1022 int genphy_suspend(struct phy_device *phydev)
1023 {
1024         int value;
1025
1026         mutex_lock(&phydev->lock);
1027
1028         value = phy_read(phydev, MII_BMCR);
1029         phy_write(phydev, MII_BMCR, (value | BMCR_PDOWN));
1030
1031         mutex_unlock(&phydev->lock);
1032
1033         return 0;
1034 }
1035 EXPORT_SYMBOL(genphy_suspend);
1036
1037 int genphy_resume(struct phy_device *phydev)
1038 {
1039         int value;
1040
1041         mutex_lock(&phydev->lock);
1042
1043         value = phy_read(phydev, MII_BMCR);
1044         phy_write(phydev, MII_BMCR, (value & ~BMCR_PDOWN));
1045
1046         mutex_unlock(&phydev->lock);
1047
1048         return 0;
1049 }
1050 EXPORT_SYMBOL(genphy_resume);
1051
1052 /**
1053  * phy_probe - probe and init a PHY device
1054  * @dev: device to probe and init
1055  *
1056  * Description: Take care of setting up the phy_device structure,
1057  *   set the state to READY (the driver's init function should
1058  *   set it to STARTING if needed).
1059  */
1060 static int phy_probe(struct device *dev)
1061 {
1062         struct phy_device *phydev;
1063         struct phy_driver *phydrv;
1064         struct device_driver *drv;
1065         int err = 0;
1066
1067         phydev = to_phy_device(dev);
1068
1069         drv = phydev->dev.driver;
1070         phydrv = to_phy_driver(drv);
1071         phydev->drv = phydrv;
1072
1073         /* Disable the interrupt if the PHY doesn't support it
1074          * but the interrupt is still a valid one
1075          */
1076         if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
1077                         phy_interrupt_is_valid(phydev))
1078                 phydev->irq = PHY_POLL;
1079
1080         if (phydrv->flags & PHY_IS_INTERNAL)
1081                 phydev->is_internal = true;
1082
1083         mutex_lock(&phydev->lock);
1084
1085         /* Start out supporting everything. Eventually,
1086          * a controller will attach, and may modify one
1087          * or both of these values */
1088         phydev->supported = phydrv->features;
1089         phydev->advertising = phydrv->features;
1090
1091         /* Set the state to READY by default */
1092         phydev->state = PHY_READY;
1093
1094         if (phydev->drv->probe)
1095                 err = phydev->drv->probe(phydev);
1096
1097         mutex_unlock(&phydev->lock);
1098
1099         return err;
1100
1101 }
1102
1103 static int phy_remove(struct device *dev)
1104 {
1105         struct phy_device *phydev;
1106
1107         phydev = to_phy_device(dev);
1108
1109         mutex_lock(&phydev->lock);
1110         phydev->state = PHY_DOWN;
1111         mutex_unlock(&phydev->lock);
1112
1113         if (phydev->drv->remove)
1114                 phydev->drv->remove(phydev);
1115         phydev->drv = NULL;
1116
1117         return 0;
1118 }
1119
1120 /**
1121  * phy_driver_register - register a phy_driver with the PHY layer
1122  * @new_driver: new phy_driver to register
1123  */
1124 int phy_driver_register(struct phy_driver *new_driver)
1125 {
1126         int retval;
1127
1128         new_driver->driver.name = new_driver->name;
1129         new_driver->driver.bus = &mdio_bus_type;
1130         new_driver->driver.probe = phy_probe;
1131         new_driver->driver.remove = phy_remove;
1132
1133         retval = driver_register(&new_driver->driver);
1134
1135         if (retval) {
1136                 pr_err("%s: Error %d in registering driver\n",
1137                        new_driver->name, retval);
1138
1139                 return retval;
1140         }
1141
1142         pr_debug("%s: Registered new driver\n", new_driver->name);
1143
1144         return 0;
1145 }
1146 EXPORT_SYMBOL(phy_driver_register);
1147
1148 int phy_drivers_register(struct phy_driver *new_driver, int n)
1149 {
1150         int i, ret = 0;
1151
1152         for (i = 0; i < n; i++) {
1153                 ret = phy_driver_register(new_driver + i);
1154                 if (ret) {
1155                         while (i-- > 0)
1156                                 phy_driver_unregister(new_driver + i);
1157                         break;
1158                 }
1159         }
1160         return ret;
1161 }
1162 EXPORT_SYMBOL(phy_drivers_register);
1163
1164 void phy_driver_unregister(struct phy_driver *drv)
1165 {
1166         driver_unregister(&drv->driver);
1167 }
1168 EXPORT_SYMBOL(phy_driver_unregister);
1169
1170 void phy_drivers_unregister(struct phy_driver *drv, int n)
1171 {
1172         int i;
1173         for (i = 0; i < n; i++) {
1174                 phy_driver_unregister(drv + i);
1175         }
1176 }
1177 EXPORT_SYMBOL(phy_drivers_unregister);
1178
1179 static struct phy_driver genphy_driver = {
1180         .phy_id         = 0xffffffff,
1181         .phy_id_mask    = 0xffffffff,
1182         .name           = "Generic PHY",
1183         .config_init    = genphy_config_init,
1184         .features       = 0,
1185         .config_aneg    = genphy_config_aneg,
1186         .read_status    = genphy_read_status,
1187         .suspend        = genphy_suspend,
1188         .resume         = genphy_resume,
1189         .driver         = {.owner= THIS_MODULE, },
1190 };
1191
1192 static int __init phy_init(void)
1193 {
1194         int rc;
1195
1196         rc = mdio_bus_init();
1197         if (rc)
1198                 return rc;
1199
1200         rc = phy_driver_register(&genphy_driver);
1201         if (rc)
1202                 mdio_bus_exit();
1203
1204         return rc;
1205 }
1206
1207 static void __exit phy_exit(void)
1208 {
1209         phy_driver_unregister(&genphy_driver);
1210         mdio_bus_exit();
1211 }
1212
1213 subsys_initcall(phy_init);
1214 module_exit(phy_exit);