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