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