1 /* 2 * drivers/net/phy/phy.c 3 * 4 * Framework for configuring and reading PHY devices 5 * Based on code in sungem_phy.c and gianfar_phy.c 6 * 7 * Author: Andy Fleming 8 * 9 * Copyright (c) 2004 Freescale Semiconductor, Inc. 10 * Copyright (c) 2006 Maciej W. Rozycki 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the 14 * Free Software Foundation; either version 2 of the License, or (at your 15 * option) any later version. 16 * 17 */ 18 #include <linux/kernel.h> 19 #include <linux/string.h> 20 #include <linux/errno.h> 21 #include <linux/unistd.h> 22 #include <linux/slab.h> 23 #include <linux/interrupt.h> 24 #include <linux/init.h> 25 #include <linux/delay.h> 26 #include <linux/netdevice.h> 27 #include <linux/etherdevice.h> 28 #include <linux/skbuff.h> 29 #include <linux/spinlock.h> 30 #include <linux/mm.h> 31 #include <linux/module.h> 32 #include <linux/mii.h> 33 #include <linux/ethtool.h> 34 #include <linux/phy.h> 35 #include <linux/timer.h> 36 #include <linux/workqueue.h> 37 38 #include <asm/io.h> 39 #include <asm/irq.h> 40 #include <asm/uaccess.h> 41 42 /* Convenience function to print out the current phy status 43 */ 44 void phy_print_status(struct phy_device *phydev) 45 { 46 pr_info("PHY: %s - Link is %s", phydev->dev.bus_id, 47 phydev->link ? "Up" : "Down"); 48 if (phydev->link) 49 printk(" - %d/%s", phydev->speed, 50 DUPLEX_FULL == phydev->duplex ? 51 "Full" : "Half"); 52 53 printk("\n"); 54 } 55 EXPORT_SYMBOL(phy_print_status); 56 57 58 /* Convenience functions for reading/writing a given PHY 59 * register. They MUST NOT be called from interrupt context, 60 * because the bus read/write functions may wait for an interrupt 61 * to conclude the operation. */ 62 int phy_read(struct phy_device *phydev, u16 regnum) 63 { 64 int retval; 65 struct mii_bus *bus = phydev->bus; 66 67 spin_lock_bh(&bus->mdio_lock); 68 retval = bus->read(bus, phydev->addr, regnum); 69 spin_unlock_bh(&bus->mdio_lock); 70 71 return retval; 72 } 73 EXPORT_SYMBOL(phy_read); 74 75 int phy_write(struct phy_device *phydev, u16 regnum, u16 val) 76 { 77 int err; 78 struct mii_bus *bus = phydev->bus; 79 80 spin_lock_bh(&bus->mdio_lock); 81 err = bus->write(bus, phydev->addr, regnum, val); 82 spin_unlock_bh(&bus->mdio_lock); 83 84 return err; 85 } 86 EXPORT_SYMBOL(phy_write); 87 88 89 int phy_clear_interrupt(struct phy_device *phydev) 90 { 91 int err = 0; 92 93 if (phydev->drv->ack_interrupt) 94 err = phydev->drv->ack_interrupt(phydev); 95 96 return err; 97 } 98 99 100 int phy_config_interrupt(struct phy_device *phydev, u32 interrupts) 101 { 102 int err = 0; 103 104 phydev->interrupts = interrupts; 105 if (phydev->drv->config_intr) 106 err = phydev->drv->config_intr(phydev); 107 108 return err; 109 } 110 111 112 /* phy_aneg_done 113 * 114 * description: Reads the status register and returns 0 either if 115 * auto-negotiation is incomplete, or if there was an error. 116 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 117 */ 118 static inline int phy_aneg_done(struct phy_device *phydev) 119 { 120 int retval; 121 122 retval = phy_read(phydev, MII_BMSR); 123 124 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 125 } 126 127 /* A structure for mapping a particular speed and duplex 128 * combination to a particular SUPPORTED and ADVERTISED value */ 129 struct phy_setting { 130 int speed; 131 int duplex; 132 u32 setting; 133 }; 134 135 /* A mapping of all SUPPORTED settings to speed/duplex */ 136 static const struct phy_setting settings[] = { 137 { 138 .speed = 10000, 139 .duplex = DUPLEX_FULL, 140 .setting = SUPPORTED_10000baseT_Full, 141 }, 142 { 143 .speed = SPEED_1000, 144 .duplex = DUPLEX_FULL, 145 .setting = SUPPORTED_1000baseT_Full, 146 }, 147 { 148 .speed = SPEED_1000, 149 .duplex = DUPLEX_HALF, 150 .setting = SUPPORTED_1000baseT_Half, 151 }, 152 { 153 .speed = SPEED_100, 154 .duplex = DUPLEX_FULL, 155 .setting = SUPPORTED_100baseT_Full, 156 }, 157 { 158 .speed = SPEED_100, 159 .duplex = DUPLEX_HALF, 160 .setting = SUPPORTED_100baseT_Half, 161 }, 162 { 163 .speed = SPEED_10, 164 .duplex = DUPLEX_FULL, 165 .setting = SUPPORTED_10baseT_Full, 166 }, 167 { 168 .speed = SPEED_10, 169 .duplex = DUPLEX_HALF, 170 .setting = SUPPORTED_10baseT_Half, 171 }, 172 }; 173 174 #define MAX_NUM_SETTINGS (sizeof(settings)/sizeof(struct phy_setting)) 175 176 /* phy_find_setting 177 * 178 * description: Searches the settings array for the setting which 179 * matches the desired speed and duplex, and returns the index 180 * of that setting. Returns the index of the last setting if 181 * none of the others match. 182 */ 183 static inline int phy_find_setting(int speed, int duplex) 184 { 185 int idx = 0; 186 187 while (idx < ARRAY_SIZE(settings) && 188 (settings[idx].speed != speed || 189 settings[idx].duplex != duplex)) 190 idx++; 191 192 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 193 } 194 195 /* phy_find_valid 196 * idx: The first index in settings[] to search 197 * features: A mask of the valid settings 198 * 199 * description: Returns the index of the first valid setting less 200 * than or equal to the one pointed to by idx, as determined by 201 * the mask in features. Returns the index of the last setting 202 * if nothing else matches. 203 */ 204 static inline int phy_find_valid(int idx, u32 features) 205 { 206 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features)) 207 idx++; 208 209 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 210 } 211 212 /* phy_sanitize_settings 213 * 214 * description: Make sure the PHY is set to supported speeds and 215 * duplexes. Drop down by one in this order: 1000/FULL, 216 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF 217 */ 218 void phy_sanitize_settings(struct phy_device *phydev) 219 { 220 u32 features = phydev->supported; 221 int idx; 222 223 /* Sanitize settings based on PHY capabilities */ 224 if ((features & SUPPORTED_Autoneg) == 0) 225 phydev->autoneg = 0; 226 227 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex), 228 features); 229 230 phydev->speed = settings[idx].speed; 231 phydev->duplex = settings[idx].duplex; 232 } 233 EXPORT_SYMBOL(phy_sanitize_settings); 234 235 /* phy_ethtool_sset: 236 * A generic ethtool sset function. Handles all the details 237 * 238 * A few notes about parameter checking: 239 * - We don't set port or transceiver, so we don't care what they 240 * were set to. 241 * - phy_start_aneg() will make sure forced settings are sane, and 242 * choose the next best ones from the ones selected, so we don't 243 * care if ethtool tries to give us bad values 244 * 245 */ 246 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd) 247 { 248 if (cmd->phy_address != phydev->addr) 249 return -EINVAL; 250 251 /* We make sure that we don't pass unsupported 252 * values in to the PHY */ 253 cmd->advertising &= phydev->supported; 254 255 /* Verify the settings we care about. */ 256 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) 257 return -EINVAL; 258 259 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) 260 return -EINVAL; 261 262 if (cmd->autoneg == AUTONEG_DISABLE 263 && ((cmd->speed != SPEED_1000 264 && cmd->speed != SPEED_100 265 && cmd->speed != SPEED_10) 266 || (cmd->duplex != DUPLEX_HALF 267 && cmd->duplex != DUPLEX_FULL))) 268 return -EINVAL; 269 270 phydev->autoneg = cmd->autoneg; 271 272 phydev->speed = cmd->speed; 273 274 phydev->advertising = cmd->advertising; 275 276 if (AUTONEG_ENABLE == cmd->autoneg) 277 phydev->advertising |= ADVERTISED_Autoneg; 278 else 279 phydev->advertising &= ~ADVERTISED_Autoneg; 280 281 phydev->duplex = cmd->duplex; 282 283 /* Restart the PHY */ 284 phy_start_aneg(phydev); 285 286 return 0; 287 } 288 EXPORT_SYMBOL(phy_ethtool_sset); 289 290 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd) 291 { 292 cmd->supported = phydev->supported; 293 294 cmd->advertising = phydev->advertising; 295 296 cmd->speed = phydev->speed; 297 cmd->duplex = phydev->duplex; 298 cmd->port = PORT_MII; 299 cmd->phy_address = phydev->addr; 300 cmd->transceiver = XCVR_EXTERNAL; 301 cmd->autoneg = phydev->autoneg; 302 303 return 0; 304 } 305 EXPORT_SYMBOL(phy_ethtool_gset); 306 307 /* Note that this function is currently incompatible with the 308 * PHYCONTROL layer. It changes registers without regard to 309 * current state. Use at own risk 310 */ 311 int phy_mii_ioctl(struct phy_device *phydev, 312 struct mii_ioctl_data *mii_data, int cmd) 313 { 314 u16 val = mii_data->val_in; 315 316 switch (cmd) { 317 case SIOCGMIIPHY: 318 mii_data->phy_id = phydev->addr; 319 break; 320 case SIOCGMIIREG: 321 mii_data->val_out = phy_read(phydev, mii_data->reg_num); 322 break; 323 324 case SIOCSMIIREG: 325 if (!capable(CAP_NET_ADMIN)) 326 return -EPERM; 327 328 if (mii_data->phy_id == phydev->addr) { 329 switch(mii_data->reg_num) { 330 case MII_BMCR: 331 if (val & (BMCR_RESET|BMCR_ANENABLE)) 332 phydev->autoneg = AUTONEG_DISABLE; 333 else 334 phydev->autoneg = AUTONEG_ENABLE; 335 if ((!phydev->autoneg) && (val & BMCR_FULLDPLX)) 336 phydev->duplex = DUPLEX_FULL; 337 else 338 phydev->duplex = DUPLEX_HALF; 339 break; 340 case MII_ADVERTISE: 341 phydev->advertising = val; 342 break; 343 default: 344 /* do nothing */ 345 break; 346 } 347 } 348 349 phy_write(phydev, mii_data->reg_num, val); 350 351 if (mii_data->reg_num == MII_BMCR 352 && val & BMCR_RESET 353 && phydev->drv->config_init) 354 phydev->drv->config_init(phydev); 355 break; 356 } 357 358 return 0; 359 } 360 361 /* phy_start_aneg 362 * 363 * description: Sanitizes the settings (if we're not 364 * autonegotiating them), and then calls the driver's 365 * config_aneg function. If the PHYCONTROL Layer is operating, 366 * we change the state to reflect the beginning of 367 * Auto-negotiation or forcing. 368 */ 369 int phy_start_aneg(struct phy_device *phydev) 370 { 371 int err; 372 373 spin_lock(&phydev->lock); 374 375 if (AUTONEG_DISABLE == phydev->autoneg) 376 phy_sanitize_settings(phydev); 377 378 err = phydev->drv->config_aneg(phydev); 379 380 if (err < 0) 381 goto out_unlock; 382 383 if (phydev->state != PHY_HALTED) { 384 if (AUTONEG_ENABLE == phydev->autoneg) { 385 phydev->state = PHY_AN; 386 phydev->link_timeout = PHY_AN_TIMEOUT; 387 } else { 388 phydev->state = PHY_FORCING; 389 phydev->link_timeout = PHY_FORCE_TIMEOUT; 390 } 391 } 392 393 out_unlock: 394 spin_unlock(&phydev->lock); 395 return err; 396 } 397 EXPORT_SYMBOL(phy_start_aneg); 398 399 400 static void phy_change(struct work_struct *work); 401 static void phy_timer(unsigned long data); 402 403 /* phy_start_machine: 404 * 405 * description: The PHY infrastructure can run a state machine 406 * which tracks whether the PHY is starting up, negotiating, 407 * etc. This function starts the timer which tracks the state 408 * of the PHY. If you want to be notified when the state 409 * changes, pass in the callback, otherwise, pass NULL. If you 410 * want to maintain your own state machine, do not call this 411 * function. */ 412 void phy_start_machine(struct phy_device *phydev, 413 void (*handler)(struct net_device *)) 414 { 415 phydev->adjust_state = handler; 416 417 init_timer(&phydev->phy_timer); 418 phydev->phy_timer.function = &phy_timer; 419 phydev->phy_timer.data = (unsigned long) phydev; 420 mod_timer(&phydev->phy_timer, jiffies + HZ); 421 } 422 423 /* phy_stop_machine 424 * 425 * description: Stops the state machine timer, sets the state to UP 426 * (unless it wasn't up yet). This function must be called BEFORE 427 * phy_detach. 428 */ 429 void phy_stop_machine(struct phy_device *phydev) 430 { 431 del_timer_sync(&phydev->phy_timer); 432 433 spin_lock(&phydev->lock); 434 if (phydev->state > PHY_UP) 435 phydev->state = PHY_UP; 436 spin_unlock(&phydev->lock); 437 438 phydev->adjust_state = NULL; 439 } 440 441 /* phy_force_reduction 442 * 443 * description: Reduces the speed/duplex settings by 444 * one notch. The order is so: 445 * 1000/FULL, 1000/HALF, 100/FULL, 100/HALF, 446 * 10/FULL, 10/HALF. The function bottoms out at 10/HALF. 447 */ 448 static void phy_force_reduction(struct phy_device *phydev) 449 { 450 int idx; 451 452 idx = phy_find_setting(phydev->speed, phydev->duplex); 453 454 idx++; 455 456 idx = phy_find_valid(idx, phydev->supported); 457 458 phydev->speed = settings[idx].speed; 459 phydev->duplex = settings[idx].duplex; 460 461 pr_info("Trying %d/%s\n", phydev->speed, 462 DUPLEX_FULL == phydev->duplex ? 463 "FULL" : "HALF"); 464 } 465 466 467 /* phy_error: 468 * 469 * Moves the PHY to the HALTED state in response to a read 470 * or write error, and tells the controller the link is down. 471 * Must not be called from interrupt context, or while the 472 * phydev->lock is held. 473 */ 474 void phy_error(struct phy_device *phydev) 475 { 476 spin_lock(&phydev->lock); 477 phydev->state = PHY_HALTED; 478 spin_unlock(&phydev->lock); 479 } 480 481 /* phy_interrupt 482 * 483 * description: When a PHY interrupt occurs, the handler disables 484 * interrupts, and schedules a work task to clear the interrupt. 485 */ 486 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 487 { 488 struct phy_device *phydev = phy_dat; 489 490 if (PHY_HALTED == phydev->state) 491 return IRQ_NONE; /* It can't be ours. */ 492 493 /* The MDIO bus is not allowed to be written in interrupt 494 * context, so we need to disable the irq here. A work 495 * queue will write the PHY to disable and clear the 496 * interrupt, and then reenable the irq line. */ 497 disable_irq_nosync(irq); 498 499 schedule_work(&phydev->phy_queue); 500 501 return IRQ_HANDLED; 502 } 503 504 /* Enable the interrupts from the PHY side */ 505 int phy_enable_interrupts(struct phy_device *phydev) 506 { 507 int err; 508 509 err = phy_clear_interrupt(phydev); 510 511 if (err < 0) 512 return err; 513 514 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 515 516 return err; 517 } 518 EXPORT_SYMBOL(phy_enable_interrupts); 519 520 /* Disable the PHY interrupts from the PHY side */ 521 int phy_disable_interrupts(struct phy_device *phydev) 522 { 523 int err; 524 525 /* Disable PHY interrupts */ 526 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 527 528 if (err) 529 goto phy_err; 530 531 /* Clear the interrupt */ 532 err = phy_clear_interrupt(phydev); 533 534 if (err) 535 goto phy_err; 536 537 return 0; 538 539 phy_err: 540 phy_error(phydev); 541 542 return err; 543 } 544 EXPORT_SYMBOL(phy_disable_interrupts); 545 546 /* phy_start_interrupts 547 * 548 * description: Request the interrupt for the given PHY. If 549 * this fails, then we set irq to PHY_POLL. 550 * Otherwise, we enable the interrupts in the PHY. 551 * Returns 0 on success. 552 * This should only be called with a valid IRQ number. 553 */ 554 int phy_start_interrupts(struct phy_device *phydev) 555 { 556 int err = 0; 557 558 INIT_WORK(&phydev->phy_queue, phy_change); 559 560 if (request_irq(phydev->irq, phy_interrupt, 561 IRQF_SHARED, 562 "phy_interrupt", 563 phydev) < 0) { 564 printk(KERN_WARNING "%s: Can't get IRQ %d (PHY)\n", 565 phydev->bus->name, 566 phydev->irq); 567 phydev->irq = PHY_POLL; 568 return 0; 569 } 570 571 err = phy_enable_interrupts(phydev); 572 573 return err; 574 } 575 EXPORT_SYMBOL(phy_start_interrupts); 576 577 int phy_stop_interrupts(struct phy_device *phydev) 578 { 579 int err; 580 581 err = phy_disable_interrupts(phydev); 582 583 if (err) 584 phy_error(phydev); 585 586 /* 587 * Finish any pending work; we might have been scheduled 588 * to be called from keventd ourselves, though. 589 */ 590 run_scheduled_work(&phydev->phy_queue); 591 592 free_irq(phydev->irq, phydev); 593 594 return err; 595 } 596 EXPORT_SYMBOL(phy_stop_interrupts); 597 598 599 /* Scheduled by the phy_interrupt/timer to handle PHY changes */ 600 static void phy_change(struct work_struct *work) 601 { 602 int err; 603 struct phy_device *phydev = 604 container_of(work, struct phy_device, phy_queue); 605 606 err = phy_disable_interrupts(phydev); 607 608 if (err) 609 goto phy_err; 610 611 spin_lock(&phydev->lock); 612 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state)) 613 phydev->state = PHY_CHANGELINK; 614 spin_unlock(&phydev->lock); 615 616 enable_irq(phydev->irq); 617 618 /* Reenable interrupts */ 619 if (PHY_HALTED != phydev->state) 620 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 621 622 if (err) 623 goto irq_enable_err; 624 625 return; 626 627 irq_enable_err: 628 disable_irq(phydev->irq); 629 phy_err: 630 phy_error(phydev); 631 } 632 633 /* Bring down the PHY link, and stop checking the status. */ 634 void phy_stop(struct phy_device *phydev) 635 { 636 spin_lock(&phydev->lock); 637 638 if (PHY_HALTED == phydev->state) 639 goto out_unlock; 640 641 phydev->state = PHY_HALTED; 642 643 if (phydev->irq != PHY_POLL) { 644 /* Disable PHY Interrupts */ 645 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 646 647 /* Clear any pending interrupts */ 648 phy_clear_interrupt(phydev); 649 } 650 651 out_unlock: 652 spin_unlock(&phydev->lock); 653 654 /* 655 * Cannot call flush_scheduled_work() here as desired because 656 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change() 657 * will not reenable interrupts. 658 */ 659 } 660 661 662 /* phy_start 663 * 664 * description: Indicates the attached device's readiness to 665 * handle PHY-related work. Used during startup to start the 666 * PHY, and after a call to phy_stop() to resume operation. 667 * Also used to indicate the MDIO bus has cleared an error 668 * condition. 669 */ 670 void phy_start(struct phy_device *phydev) 671 { 672 spin_lock(&phydev->lock); 673 674 switch (phydev->state) { 675 case PHY_STARTING: 676 phydev->state = PHY_PENDING; 677 break; 678 case PHY_READY: 679 phydev->state = PHY_UP; 680 break; 681 case PHY_HALTED: 682 phydev->state = PHY_RESUMING; 683 default: 684 break; 685 } 686 spin_unlock(&phydev->lock); 687 } 688 EXPORT_SYMBOL(phy_stop); 689 EXPORT_SYMBOL(phy_start); 690 691 /* PHY timer which handles the state machine */ 692 static void phy_timer(unsigned long data) 693 { 694 struct phy_device *phydev = (struct phy_device *)data; 695 int needs_aneg = 0; 696 int err = 0; 697 698 spin_lock(&phydev->lock); 699 700 if (phydev->adjust_state) 701 phydev->adjust_state(phydev->attached_dev); 702 703 switch(phydev->state) { 704 case PHY_DOWN: 705 case PHY_STARTING: 706 case PHY_READY: 707 case PHY_PENDING: 708 break; 709 case PHY_UP: 710 needs_aneg = 1; 711 712 phydev->link_timeout = PHY_AN_TIMEOUT; 713 714 break; 715 case PHY_AN: 716 err = phy_read_status(phydev); 717 718 if (err < 0) 719 break; 720 721 /* If the link is down, give up on 722 * negotiation for now */ 723 if (!phydev->link) { 724 phydev->state = PHY_NOLINK; 725 netif_carrier_off(phydev->attached_dev); 726 phydev->adjust_link(phydev->attached_dev); 727 break; 728 } 729 730 /* Check if negotiation is done. Break 731 * if there's an error */ 732 err = phy_aneg_done(phydev); 733 if (err < 0) 734 break; 735 736 /* If AN is done, we're running */ 737 if (err > 0) { 738 phydev->state = PHY_RUNNING; 739 netif_carrier_on(phydev->attached_dev); 740 phydev->adjust_link(phydev->attached_dev); 741 742 } else if (0 == phydev->link_timeout--) { 743 int idx; 744 745 needs_aneg = 1; 746 /* If we have the magic_aneg bit, 747 * we try again */ 748 if (phydev->drv->flags & PHY_HAS_MAGICANEG) 749 break; 750 751 /* The timer expired, and we still 752 * don't have a setting, so we try 753 * forcing it until we find one that 754 * works, starting from the fastest speed, 755 * and working our way down */ 756 idx = phy_find_valid(0, phydev->supported); 757 758 phydev->speed = settings[idx].speed; 759 phydev->duplex = settings[idx].duplex; 760 761 phydev->autoneg = AUTONEG_DISABLE; 762 763 pr_info("Trying %d/%s\n", phydev->speed, 764 DUPLEX_FULL == 765 phydev->duplex ? 766 "FULL" : "HALF"); 767 } 768 break; 769 case PHY_NOLINK: 770 err = phy_read_status(phydev); 771 772 if (err) 773 break; 774 775 if (phydev->link) { 776 phydev->state = PHY_RUNNING; 777 netif_carrier_on(phydev->attached_dev); 778 phydev->adjust_link(phydev->attached_dev); 779 } 780 break; 781 case PHY_FORCING: 782 err = genphy_update_link(phydev); 783 784 if (err) 785 break; 786 787 if (phydev->link) { 788 phydev->state = PHY_RUNNING; 789 netif_carrier_on(phydev->attached_dev); 790 } else { 791 if (0 == phydev->link_timeout--) { 792 phy_force_reduction(phydev); 793 needs_aneg = 1; 794 } 795 } 796 797 phydev->adjust_link(phydev->attached_dev); 798 break; 799 case PHY_RUNNING: 800 /* Only register a CHANGE if we are 801 * polling */ 802 if (PHY_POLL == phydev->irq) 803 phydev->state = PHY_CHANGELINK; 804 break; 805 case PHY_CHANGELINK: 806 err = phy_read_status(phydev); 807 808 if (err) 809 break; 810 811 if (phydev->link) { 812 phydev->state = PHY_RUNNING; 813 netif_carrier_on(phydev->attached_dev); 814 } else { 815 phydev->state = PHY_NOLINK; 816 netif_carrier_off(phydev->attached_dev); 817 } 818 819 phydev->adjust_link(phydev->attached_dev); 820 821 if (PHY_POLL != phydev->irq) 822 err = phy_config_interrupt(phydev, 823 PHY_INTERRUPT_ENABLED); 824 break; 825 case PHY_HALTED: 826 if (phydev->link) { 827 phydev->link = 0; 828 netif_carrier_off(phydev->attached_dev); 829 phydev->adjust_link(phydev->attached_dev); 830 } 831 break; 832 case PHY_RESUMING: 833 834 err = phy_clear_interrupt(phydev); 835 836 if (err) 837 break; 838 839 err = phy_config_interrupt(phydev, 840 PHY_INTERRUPT_ENABLED); 841 842 if (err) 843 break; 844 845 if (AUTONEG_ENABLE == phydev->autoneg) { 846 err = phy_aneg_done(phydev); 847 if (err < 0) 848 break; 849 850 /* err > 0 if AN is done. 851 * Otherwise, it's 0, and we're 852 * still waiting for AN */ 853 if (err > 0) { 854 phydev->state = PHY_RUNNING; 855 } else { 856 phydev->state = PHY_AN; 857 phydev->link_timeout = PHY_AN_TIMEOUT; 858 } 859 } else 860 phydev->state = PHY_RUNNING; 861 break; 862 } 863 864 spin_unlock(&phydev->lock); 865 866 if (needs_aneg) 867 err = phy_start_aneg(phydev); 868 869 if (err < 0) 870 phy_error(phydev); 871 872 mod_timer(&phydev->phy_timer, jiffies + PHY_STATE_TIME * HZ); 873 } 874 875