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