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