1 /* 2 * Generic PHY Management code 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation; either version 2 of 7 * the License, or (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 17 * MA 02111-1307 USA 18 * 19 * 20 * Copyright 2011 Freescale Semiconductor, Inc. 21 * author Andy Fleming 22 * 23 * Based loosely off of Linux's PHY Lib 24 */ 25 26 #include <config.h> 27 #include <common.h> 28 #include <malloc.h> 29 #include <net.h> 30 #include <command.h> 31 #include <miiphy.h> 32 #include <phy.h> 33 #include <errno.h> 34 35 /* Generic PHY support and helper functions */ 36 37 /** 38 * genphy_config_advert - sanitize and advertise auto-negotation parameters 39 * @phydev: target phy_device struct 40 * 41 * Description: Writes MII_ADVERTISE with the appropriate values, 42 * after sanitizing the values to make sure we only advertise 43 * what is supported. Returns < 0 on error, 0 if the PHY's advertisement 44 * hasn't changed, and > 0 if it has changed. 45 */ 46 static int genphy_config_advert(struct phy_device *phydev) 47 { 48 u32 advertise; 49 int oldadv, adv; 50 int err, changed = 0; 51 52 /* Only allow advertising what 53 * this PHY supports */ 54 phydev->advertising &= phydev->supported; 55 advertise = phydev->advertising; 56 57 /* Setup standard advertisement */ 58 oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE); 59 60 if (adv < 0) 61 return adv; 62 63 adv &= ~(ADVERTISE_ALL | ADVERTISE_100BASE4 | ADVERTISE_PAUSE_CAP | 64 ADVERTISE_PAUSE_ASYM); 65 if (advertise & ADVERTISED_10baseT_Half) 66 adv |= ADVERTISE_10HALF; 67 if (advertise & ADVERTISED_10baseT_Full) 68 adv |= ADVERTISE_10FULL; 69 if (advertise & ADVERTISED_100baseT_Half) 70 adv |= ADVERTISE_100HALF; 71 if (advertise & ADVERTISED_100baseT_Full) 72 adv |= ADVERTISE_100FULL; 73 if (advertise & ADVERTISED_Pause) 74 adv |= ADVERTISE_PAUSE_CAP; 75 if (advertise & ADVERTISED_Asym_Pause) 76 adv |= ADVERTISE_PAUSE_ASYM; 77 78 if (adv != oldadv) { 79 err = phy_write(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE, adv); 80 81 if (err < 0) 82 return err; 83 changed = 1; 84 } 85 86 /* Configure gigabit if it's supported */ 87 if (phydev->supported & (SUPPORTED_1000baseT_Half | 88 SUPPORTED_1000baseT_Full)) { 89 oldadv = adv = phy_read(phydev, MDIO_DEVAD_NONE, MII_CTRL1000); 90 91 if (adv < 0) 92 return adv; 93 94 adv &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF); 95 if (advertise & SUPPORTED_1000baseT_Half) 96 adv |= ADVERTISE_1000HALF; 97 if (advertise & SUPPORTED_1000baseT_Full) 98 adv |= ADVERTISE_1000FULL; 99 100 if (adv != oldadv) { 101 err = phy_write(phydev, MDIO_DEVAD_NONE, MII_CTRL1000, 102 adv); 103 104 if (err < 0) 105 return err; 106 changed = 1; 107 } 108 } 109 110 return changed; 111 } 112 113 114 /** 115 * genphy_setup_forced - configures/forces speed/duplex from @phydev 116 * @phydev: target phy_device struct 117 * 118 * Description: Configures MII_BMCR to force speed/duplex 119 * to the values in phydev. Assumes that the values are valid. 120 */ 121 static int genphy_setup_forced(struct phy_device *phydev) 122 { 123 int err; 124 int ctl = 0; 125 126 phydev->pause = phydev->asym_pause = 0; 127 128 if (SPEED_1000 == phydev->speed) 129 ctl |= BMCR_SPEED1000; 130 else if (SPEED_100 == phydev->speed) 131 ctl |= BMCR_SPEED100; 132 133 if (DUPLEX_FULL == phydev->duplex) 134 ctl |= BMCR_FULLDPLX; 135 136 err = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl); 137 138 return err; 139 } 140 141 142 /** 143 * genphy_restart_aneg - Enable and Restart Autonegotiation 144 * @phydev: target phy_device struct 145 */ 146 int genphy_restart_aneg(struct phy_device *phydev) 147 { 148 int ctl; 149 150 ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR); 151 152 if (ctl < 0) 153 return ctl; 154 155 ctl |= (BMCR_ANENABLE | BMCR_ANRESTART); 156 157 /* Don't isolate the PHY if we're negotiating */ 158 ctl &= ~(BMCR_ISOLATE); 159 160 ctl = phy_write(phydev, MDIO_DEVAD_NONE, MII_BMCR, ctl); 161 162 return ctl; 163 } 164 165 166 /** 167 * genphy_config_aneg - restart auto-negotiation or write BMCR 168 * @phydev: target phy_device struct 169 * 170 * Description: If auto-negotiation is enabled, we configure the 171 * advertising, and then restart auto-negotiation. If it is not 172 * enabled, then we write the BMCR. 173 */ 174 int genphy_config_aneg(struct phy_device *phydev) 175 { 176 int result; 177 178 if (AUTONEG_ENABLE != phydev->autoneg) 179 return genphy_setup_forced(phydev); 180 181 result = genphy_config_advert(phydev); 182 183 if (result < 0) /* error */ 184 return result; 185 186 if (result == 0) { 187 /* Advertisment hasn't changed, but maybe aneg was never on to 188 * begin with? Or maybe phy was isolated? */ 189 int ctl = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR); 190 191 if (ctl < 0) 192 return ctl; 193 194 if (!(ctl & BMCR_ANENABLE) || (ctl & BMCR_ISOLATE)) 195 result = 1; /* do restart aneg */ 196 } 197 198 /* Only restart aneg if we are advertising something different 199 * than we were before. */ 200 if (result > 0) 201 result = genphy_restart_aneg(phydev); 202 203 return result; 204 } 205 206 /** 207 * genphy_update_link - update link status in @phydev 208 * @phydev: target phy_device struct 209 * 210 * Description: Update the value in phydev->link to reflect the 211 * current link value. In order to do this, we need to read 212 * the status register twice, keeping the second value. 213 */ 214 int genphy_update_link(struct phy_device *phydev) 215 { 216 unsigned int mii_reg; 217 218 /* 219 * Wait if the link is up, and autonegotiation is in progress 220 * (ie - we're capable and it's not done) 221 */ 222 mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR); 223 224 /* 225 * If we already saw the link up, and it hasn't gone down, then 226 * we don't need to wait for autoneg again 227 */ 228 if (phydev->link && mii_reg & BMSR_LSTATUS) 229 return 0; 230 231 if ((mii_reg & BMSR_ANEGCAPABLE) && !(mii_reg & BMSR_ANEGCOMPLETE)) { 232 int i = 0; 233 234 printf("%s Waiting for PHY auto negotiation to complete", 235 phydev->dev->name); 236 while (!(mii_reg & BMSR_ANEGCOMPLETE)) { 237 /* 238 * Timeout reached ? 239 */ 240 if (i > PHY_ANEG_TIMEOUT) { 241 printf(" TIMEOUT !\n"); 242 phydev->link = 0; 243 return 0; 244 } 245 246 if (ctrlc()) { 247 puts("user interrupt!\n"); 248 phydev->link = 0; 249 return -EINTR; 250 } 251 252 if ((i++ % 500) == 0) 253 printf("."); 254 255 udelay(1000); /* 1 ms */ 256 mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR); 257 } 258 printf(" done\n"); 259 phydev->link = 1; 260 } else { 261 /* Read the link a second time to clear the latched state */ 262 mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR); 263 264 if (mii_reg & BMSR_LSTATUS) 265 phydev->link = 1; 266 else 267 phydev->link = 0; 268 } 269 270 return 0; 271 } 272 273 /* 274 * Generic function which updates the speed and duplex. If 275 * autonegotiation is enabled, it uses the AND of the link 276 * partner's advertised capabilities and our advertised 277 * capabilities. If autonegotiation is disabled, we use the 278 * appropriate bits in the control register. 279 * 280 * Stolen from Linux's mii.c and phy_device.c 281 */ 282 static int genphy_parse_link(struct phy_device *phydev) 283 { 284 int mii_reg = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR); 285 286 /* We're using autonegotiation */ 287 if (mii_reg & BMSR_ANEGCAPABLE) { 288 u32 lpa = 0; 289 u32 gblpa = 0; 290 291 /* Check for gigabit capability */ 292 if (mii_reg & BMSR_ERCAP) { 293 /* We want a list of states supported by 294 * both PHYs in the link 295 */ 296 gblpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_STAT1000); 297 gblpa &= phy_read(phydev, 298 MDIO_DEVAD_NONE, MII_CTRL1000) << 2; 299 } 300 301 /* Set the baseline so we only have to set them 302 * if they're different 303 */ 304 phydev->speed = SPEED_10; 305 phydev->duplex = DUPLEX_HALF; 306 307 /* Check the gigabit fields */ 308 if (gblpa & (PHY_1000BTSR_1000FD | PHY_1000BTSR_1000HD)) { 309 phydev->speed = SPEED_1000; 310 311 if (gblpa & PHY_1000BTSR_1000FD) 312 phydev->duplex = DUPLEX_FULL; 313 314 /* We're done! */ 315 return 0; 316 } 317 318 lpa = phy_read(phydev, MDIO_DEVAD_NONE, MII_ADVERTISE); 319 lpa &= phy_read(phydev, MDIO_DEVAD_NONE, MII_LPA); 320 321 if (lpa & (LPA_100FULL | LPA_100HALF)) { 322 phydev->speed = SPEED_100; 323 324 if (lpa & LPA_100FULL) 325 phydev->duplex = DUPLEX_FULL; 326 327 } else if (lpa & LPA_10FULL) 328 phydev->duplex = DUPLEX_FULL; 329 } else { 330 u32 bmcr = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMCR); 331 332 phydev->speed = SPEED_10; 333 phydev->duplex = DUPLEX_HALF; 334 335 if (bmcr & BMCR_FULLDPLX) 336 phydev->duplex = DUPLEX_FULL; 337 338 if (bmcr & BMCR_SPEED1000) 339 phydev->speed = SPEED_1000; 340 else if (bmcr & BMCR_SPEED100) 341 phydev->speed = SPEED_100; 342 } 343 344 return 0; 345 } 346 347 int genphy_config(struct phy_device *phydev) 348 { 349 int val; 350 u32 features; 351 352 /* For now, I'll claim that the generic driver supports 353 * all possible port types */ 354 features = (SUPPORTED_TP | SUPPORTED_MII 355 | SUPPORTED_AUI | SUPPORTED_FIBRE | 356 SUPPORTED_BNC); 357 358 /* Do we support autonegotiation? */ 359 val = phy_read(phydev, MDIO_DEVAD_NONE, MII_BMSR); 360 361 if (val < 0) 362 return val; 363 364 if (val & BMSR_ANEGCAPABLE) 365 features |= SUPPORTED_Autoneg; 366 367 if (val & BMSR_100FULL) 368 features |= SUPPORTED_100baseT_Full; 369 if (val & BMSR_100HALF) 370 features |= SUPPORTED_100baseT_Half; 371 if (val & BMSR_10FULL) 372 features |= SUPPORTED_10baseT_Full; 373 if (val & BMSR_10HALF) 374 features |= SUPPORTED_10baseT_Half; 375 376 if (val & BMSR_ESTATEN) { 377 val = phy_read(phydev, MDIO_DEVAD_NONE, MII_ESTATUS); 378 379 if (val < 0) 380 return val; 381 382 if (val & ESTATUS_1000_TFULL) 383 features |= SUPPORTED_1000baseT_Full; 384 if (val & ESTATUS_1000_THALF) 385 features |= SUPPORTED_1000baseT_Half; 386 } 387 388 phydev->supported = features; 389 phydev->advertising = features; 390 391 genphy_config_aneg(phydev); 392 393 return 0; 394 } 395 396 int genphy_startup(struct phy_device *phydev) 397 { 398 genphy_update_link(phydev); 399 genphy_parse_link(phydev); 400 401 return 0; 402 } 403 404 int genphy_shutdown(struct phy_device *phydev) 405 { 406 return 0; 407 } 408 409 static struct phy_driver genphy_driver = { 410 .uid = 0xffffffff, 411 .mask = 0xffffffff, 412 .name = "Generic PHY", 413 .features = 0, 414 .config = genphy_config, 415 .startup = genphy_startup, 416 .shutdown = genphy_shutdown, 417 }; 418 419 static LIST_HEAD(phy_drivers); 420 421 int phy_init(void) 422 { 423 #ifdef CONFIG_PHY_ATHEROS 424 phy_atheros_init(); 425 #endif 426 #ifdef CONFIG_PHY_BROADCOM 427 phy_broadcom_init(); 428 #endif 429 #ifdef CONFIG_PHY_DAVICOM 430 phy_davicom_init(); 431 #endif 432 #ifdef CONFIG_PHY_LXT 433 phy_lxt_init(); 434 #endif 435 #ifdef CONFIG_PHY_MARVELL 436 phy_marvell_init(); 437 #endif 438 #ifdef CONFIG_PHY_MICREL 439 phy_micrel_init(); 440 #endif 441 #ifdef CONFIG_PHY_NATSEMI 442 phy_natsemi_init(); 443 #endif 444 #ifdef CONFIG_PHY_REALTEK 445 phy_realtek_init(); 446 #endif 447 #ifdef CONFIG_PHY_SMSC 448 phy_smsc_init(); 449 #endif 450 #ifdef CONFIG_PHY_TERANETICS 451 phy_teranetics_init(); 452 #endif 453 #ifdef CONFIG_PHY_VITESSE 454 phy_vitesse_init(); 455 #endif 456 457 return 0; 458 } 459 460 int phy_register(struct phy_driver *drv) 461 { 462 INIT_LIST_HEAD(&drv->list); 463 list_add_tail(&drv->list, &phy_drivers); 464 465 return 0; 466 } 467 468 static int phy_probe(struct phy_device *phydev) 469 { 470 int err = 0; 471 472 phydev->advertising = phydev->supported = phydev->drv->features; 473 phydev->mmds = phydev->drv->mmds; 474 475 if (phydev->drv->probe) 476 err = phydev->drv->probe(phydev); 477 478 return err; 479 } 480 481 static struct phy_driver *generic_for_interface(phy_interface_t interface) 482 { 483 #ifdef CONFIG_PHYLIB_10G 484 if (is_10g_interface(interface)) 485 return &gen10g_driver; 486 #endif 487 488 return &genphy_driver; 489 } 490 491 static struct phy_driver *get_phy_driver(struct phy_device *phydev, 492 phy_interface_t interface) 493 { 494 struct list_head *entry; 495 int phy_id = phydev->phy_id; 496 struct phy_driver *drv = NULL; 497 498 list_for_each(entry, &phy_drivers) { 499 drv = list_entry(entry, struct phy_driver, list); 500 if ((drv->uid & drv->mask) == (phy_id & drv->mask)) 501 return drv; 502 } 503 504 /* If we made it here, there's no driver for this PHY */ 505 return generic_for_interface(interface); 506 } 507 508 static struct phy_device *phy_device_create(struct mii_dev *bus, int addr, 509 int phy_id, 510 phy_interface_t interface) 511 { 512 struct phy_device *dev; 513 514 /* We allocate the device, and initialize the 515 * default values */ 516 dev = malloc(sizeof(*dev)); 517 if (!dev) { 518 printf("Failed to allocate PHY device for %s:%d\n", 519 bus->name, addr); 520 return NULL; 521 } 522 523 memset(dev, 0, sizeof(*dev)); 524 525 dev->duplex = -1; 526 dev->link = 1; 527 dev->interface = interface; 528 529 dev->autoneg = AUTONEG_ENABLE; 530 531 dev->addr = addr; 532 dev->phy_id = phy_id; 533 dev->bus = bus; 534 535 dev->drv = get_phy_driver(dev, interface); 536 537 phy_probe(dev); 538 539 bus->phymap[addr] = dev; 540 541 return dev; 542 } 543 544 /** 545 * get_phy_id - reads the specified addr for its ID. 546 * @bus: the target MII bus 547 * @addr: PHY address on the MII bus 548 * @phy_id: where to store the ID retrieved. 549 * 550 * Description: Reads the ID registers of the PHY at @addr on the 551 * @bus, stores it in @phy_id and returns zero on success. 552 */ 553 static int get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id) 554 { 555 int phy_reg; 556 557 /* Grab the bits from PHYIR1, and put them 558 * in the upper half */ 559 phy_reg = bus->read(bus, addr, devad, MII_PHYSID1); 560 561 if (phy_reg < 0) 562 return -EIO; 563 564 *phy_id = (phy_reg & 0xffff) << 16; 565 566 /* Grab the bits from PHYIR2, and put them in the lower half */ 567 phy_reg = bus->read(bus, addr, devad, MII_PHYSID2); 568 569 if (phy_reg < 0) 570 return -EIO; 571 572 *phy_id |= (phy_reg & 0xffff); 573 574 return 0; 575 } 576 577 /** 578 * get_phy_device - reads the specified PHY device and returns its @phy_device struct 579 * @bus: the target MII bus 580 * @addr: PHY address on the MII bus 581 * 582 * Description: Reads the ID registers of the PHY at @addr on the 583 * @bus, then allocates and returns the phy_device to represent it. 584 */ 585 static struct phy_device *get_phy_device(struct mii_dev *bus, int addr, 586 phy_interface_t interface) 587 { 588 u32 phy_id = 0x1fffffff; 589 int i; 590 int r; 591 592 /* If we have one, return the existing device, with new interface */ 593 if (bus->phymap[addr]) { 594 bus->phymap[addr]->interface = interface; 595 596 return bus->phymap[addr]; 597 } 598 599 /* Try Standard (ie Clause 22) access */ 600 r = get_phy_id(bus, addr, MDIO_DEVAD_NONE, &phy_id); 601 if (r) 602 return NULL; 603 604 /* If the PHY ID is mostly f's, we didn't find anything */ 605 if ((phy_id & 0x1fffffff) != 0x1fffffff) 606 return phy_device_create(bus, addr, phy_id, interface); 607 608 /* Otherwise we have to try Clause 45 */ 609 for (i = 1; i < 5; i++) { 610 r = get_phy_id(bus, addr, i, &phy_id); 611 if (r) 612 return NULL; 613 614 /* If the phy_id is mostly Fs, there is no device there */ 615 if ((phy_id & 0x1fffffff) != 0x1fffffff) 616 break; 617 } 618 619 return phy_device_create(bus, addr, phy_id, interface); 620 } 621 622 int phy_reset(struct phy_device *phydev) 623 { 624 int reg; 625 int timeout = 500; 626 int devad = MDIO_DEVAD_NONE; 627 628 #ifdef CONFIG_PHYLIB_10G 629 /* If it's 10G, we need to issue reset through one of the MMDs */ 630 if (is_10g_interface(phydev->interface)) { 631 if (!phydev->mmds) 632 gen10g_discover_mmds(phydev); 633 634 devad = ffs(phydev->mmds) - 1; 635 } 636 #endif 637 638 reg = phy_read(phydev, devad, MII_BMCR); 639 if (reg < 0) { 640 debug("PHY status read failed\n"); 641 return -1; 642 } 643 644 reg |= BMCR_RESET; 645 646 if (phy_write(phydev, devad, MII_BMCR, reg) < 0) { 647 debug("PHY reset failed\n"); 648 return -1; 649 } 650 651 #ifdef CONFIG_PHY_RESET_DELAY 652 udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */ 653 #endif 654 /* 655 * Poll the control register for the reset bit to go to 0 (it is 656 * auto-clearing). This should happen within 0.5 seconds per the 657 * IEEE spec. 658 */ 659 while ((reg & BMCR_RESET) && timeout--) { 660 reg = phy_read(phydev, devad, MII_BMCR); 661 662 if (reg < 0) { 663 debug("PHY status read failed\n"); 664 return -1; 665 } 666 udelay(1000); 667 } 668 669 if (reg & BMCR_RESET) { 670 puts("PHY reset timed out\n"); 671 return -1; 672 } 673 674 return 0; 675 } 676 677 int miiphy_reset(const char *devname, unsigned char addr) 678 { 679 struct mii_dev *bus = miiphy_get_dev_by_name(devname); 680 struct phy_device *phydev; 681 682 /* 683 * miiphy_reset was only used on standard PHYs, so we'll fake it here. 684 * If later code tries to connect with the right interface, this will 685 * be corrected by get_phy_device in phy_connect() 686 */ 687 phydev = get_phy_device(bus, addr, PHY_INTERFACE_MODE_MII); 688 689 return phy_reset(phydev); 690 } 691 692 struct phy_device *phy_connect(struct mii_dev *bus, int addr, 693 struct eth_device *dev, 694 phy_interface_t interface) 695 { 696 struct phy_device *phydev; 697 698 /* Reset the bus */ 699 if (bus->reset) 700 bus->reset(bus); 701 702 /* Wait 15ms to make sure the PHY has come out of hard reset */ 703 udelay(15000); 704 705 phydev = get_phy_device(bus, addr, interface); 706 707 if (!phydev) { 708 printf("Could not get PHY for %s:%d\n", bus->name, addr); 709 710 return NULL; 711 } 712 713 /* Soft Reset the PHY */ 714 phy_reset(phydev); 715 716 if (phydev->dev) 717 printf("%s:%d is connected to %s. Reconnecting to %s\n", 718 bus->name, addr, phydev->dev->name, dev->name); 719 720 phydev->dev = dev; 721 722 debug("%s connected to %s\n", dev->name, phydev->drv->name); 723 724 return phydev; 725 } 726 727 /* 728 * Start the PHY. Returns 0 on success, or a negative error code. 729 */ 730 int phy_startup(struct phy_device *phydev) 731 { 732 if (phydev->drv->startup) 733 return phydev->drv->startup(phydev); 734 735 return 0; 736 } 737 738 static int __board_phy_config(struct phy_device *phydev) 739 { 740 if (phydev->drv->config) 741 return phydev->drv->config(phydev); 742 return 0; 743 } 744 745 int board_phy_config(struct phy_device *phydev) 746 __attribute__((weak, alias("__board_phy_config"))); 747 748 int phy_config(struct phy_device *phydev) 749 { 750 /* Invoke an optional board-specific helper */ 751 board_phy_config(phydev); 752 753 return 0; 754 } 755 756 int phy_shutdown(struct phy_device *phydev) 757 { 758 if (phydev->drv->shutdown) 759 phydev->drv->shutdown(phydev); 760 761 return 0; 762 } 763