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 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 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 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 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 struct phy_device *phy_device_create(struct mii_dev *bus, int addr, int phy_id, 509 phy_interface_t interface) 510 { 511 struct phy_device *dev; 512 513 /* We allocate the device, and initialize the 514 * default values */ 515 dev = malloc(sizeof(*dev)); 516 if (!dev) { 517 printf("Failed to allocate PHY device for %s:%d\n", 518 bus->name, addr); 519 return NULL; 520 } 521 522 memset(dev, 0, sizeof(*dev)); 523 524 dev->duplex = -1; 525 dev->link = 1; 526 dev->interface = interface; 527 528 dev->autoneg = AUTONEG_ENABLE; 529 530 dev->addr = addr; 531 dev->phy_id = phy_id; 532 dev->bus = bus; 533 534 dev->drv = get_phy_driver(dev, interface); 535 536 phy_probe(dev); 537 538 bus->phymap[addr] = dev; 539 540 return dev; 541 } 542 543 /** 544 * get_phy_id - reads the specified addr for its ID. 545 * @bus: the target MII bus 546 * @addr: PHY address on the MII bus 547 * @phy_id: where to store the ID retrieved. 548 * 549 * Description: Reads the ID registers of the PHY at @addr on the 550 * @bus, stores it in @phy_id and returns zero on success. 551 */ 552 int get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id) 553 { 554 int phy_reg; 555 556 /* Grab the bits from PHYIR1, and put them 557 * in the upper half */ 558 phy_reg = bus->read(bus, addr, devad, MII_PHYSID1); 559 560 if (phy_reg < 0) 561 return -EIO; 562 563 *phy_id = (phy_reg & 0xffff) << 16; 564 565 /* Grab the bits from PHYIR2, and put them in the lower half */ 566 phy_reg = bus->read(bus, addr, devad, MII_PHYSID2); 567 568 if (phy_reg < 0) 569 return -EIO; 570 571 *phy_id |= (phy_reg & 0xffff); 572 573 return 0; 574 } 575 576 /** 577 * get_phy_device - reads the specified PHY device and returns its @phy_device struct 578 * @bus: the target MII bus 579 * @addr: PHY address on the MII bus 580 * 581 * Description: Reads the ID registers of the PHY at @addr on the 582 * @bus, then allocates and returns the phy_device to represent it. 583 */ 584 struct phy_device *get_phy_device(struct mii_dev *bus, int addr, 585 phy_interface_t interface) 586 { 587 u32 phy_id = 0x1fffffff; 588 int i; 589 int r; 590 591 /* If we have one, return the existing device, with new interface */ 592 if (bus->phymap[addr]) { 593 bus->phymap[addr]->interface = interface; 594 595 return bus->phymap[addr]; 596 } 597 598 /* Try Standard (ie Clause 22) access */ 599 r = get_phy_id(bus, addr, MDIO_DEVAD_NONE, &phy_id); 600 if (r) 601 return NULL; 602 603 /* If the PHY ID is mostly f's, we didn't find anything */ 604 if ((phy_id & 0x1fffffff) != 0x1fffffff) 605 return phy_device_create(bus, addr, phy_id, interface); 606 607 /* Otherwise we have to try Clause 45 */ 608 for (i = 1; i < 5; i++) { 609 r = get_phy_id(bus, addr, i, &phy_id); 610 if (r) 611 return NULL; 612 613 /* If the phy_id is mostly Fs, there is no device there */ 614 if ((phy_id & 0x1fffffff) != 0x1fffffff) 615 break; 616 } 617 618 return phy_device_create(bus, addr, phy_id, interface); 619 } 620 621 int phy_reset(struct phy_device *phydev) 622 { 623 int reg; 624 int timeout = 500; 625 int devad = MDIO_DEVAD_NONE; 626 627 #ifdef CONFIG_PHYLIB_10G 628 /* If it's 10G, we need to issue reset through one of the MMDs */ 629 if (is_10g_interface(phydev->interface)) { 630 if (!phydev->mmds) 631 gen10g_discover_mmds(phydev); 632 633 devad = ffs(phydev->mmds) - 1; 634 } 635 #endif 636 637 reg = phy_read(phydev, devad, MII_BMCR); 638 if (reg < 0) { 639 debug("PHY status read failed\n"); 640 return -1; 641 } 642 643 reg |= BMCR_RESET; 644 645 if (phy_write(phydev, devad, MII_BMCR, reg) < 0) { 646 debug("PHY reset failed\n"); 647 return -1; 648 } 649 650 #ifdef CONFIG_PHY_RESET_DELAY 651 udelay(CONFIG_PHY_RESET_DELAY); /* Intel LXT971A needs this */ 652 #endif 653 /* 654 * Poll the control register for the reset bit to go to 0 (it is 655 * auto-clearing). This should happen within 0.5 seconds per the 656 * IEEE spec. 657 */ 658 while ((reg & BMCR_RESET) && timeout--) { 659 reg = phy_read(phydev, devad, MII_BMCR); 660 661 if (reg < 0) { 662 debug("PHY status read failed\n"); 663 return -1; 664 } 665 udelay(1000); 666 } 667 668 if (reg & BMCR_RESET) { 669 puts("PHY reset timed out\n"); 670 return -1; 671 } 672 673 return 0; 674 } 675 676 int miiphy_reset(const char *devname, unsigned char addr) 677 { 678 struct mii_dev *bus = miiphy_get_dev_by_name(devname); 679 struct phy_device *phydev; 680 681 /* 682 * miiphy_reset was only used on standard PHYs, so we'll fake it here. 683 * If later code tries to connect with the right interface, this will 684 * be corrected by get_phy_device in phy_connect() 685 */ 686 phydev = get_phy_device(bus, addr, PHY_INTERFACE_MODE_MII); 687 688 return phy_reset(phydev); 689 } 690 691 struct phy_device *phy_connect(struct mii_dev *bus, int addr, 692 struct eth_device *dev, 693 phy_interface_t interface) 694 { 695 struct phy_device *phydev; 696 697 /* Reset the bus */ 698 if (bus->reset) 699 bus->reset(bus); 700 701 /* Wait 15ms to make sure the PHY has come out of hard reset */ 702 udelay(15000); 703 704 phydev = get_phy_device(bus, addr, interface); 705 706 if (!phydev) { 707 printf("Could not get PHY for %s:%d\n", bus->name, addr); 708 709 return NULL; 710 } 711 712 /* Soft Reset the PHY */ 713 phy_reset(phydev); 714 715 if (phydev->dev) 716 printf("%s:%d is connected to %s. Reconnecting to %s\n", 717 bus->name, addr, phydev->dev->name, dev->name); 718 719 phydev->dev = dev; 720 721 debug("%s connected to %s\n", dev->name, phydev->drv->name); 722 723 return phydev; 724 } 725 726 /* 727 * Start the PHY. Returns 0 on success, or a negative error code. 728 */ 729 int phy_startup(struct phy_device *phydev) 730 { 731 if (phydev->drv->startup) 732 return phydev->drv->startup(phydev); 733 734 return 0; 735 } 736 737 static int __board_phy_config(struct phy_device *phydev) 738 { 739 if (phydev->drv->config) 740 return phydev->drv->config(phydev); 741 return 0; 742 } 743 744 int board_phy_config(struct phy_device *phydev) 745 __attribute__((weak, alias("__board_phy_config"))); 746 747 int phy_config(struct phy_device *phydev) 748 { 749 /* Invoke an optional board-specific helper */ 750 board_phy_config(phydev); 751 752 return 0; 753 } 754 755 int phy_shutdown(struct phy_device *phydev) 756 { 757 if (phydev->drv->shutdown) 758 phydev->drv->shutdown(phydev); 759 760 return 0; 761 } 762