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