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 19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21 #include <linux/kernel.h> 22 #include <linux/string.h> 23 #include <linux/errno.h> 24 #include <linux/unistd.h> 25 #include <linux/interrupt.h> 26 #include <linux/init.h> 27 #include <linux/delay.h> 28 #include <linux/netdevice.h> 29 #include <linux/etherdevice.h> 30 #include <linux/skbuff.h> 31 #include <linux/mm.h> 32 #include <linux/module.h> 33 #include <linux/mii.h> 34 #include <linux/ethtool.h> 35 #include <linux/phy.h> 36 #include <linux/timer.h> 37 #include <linux/workqueue.h> 38 #include <linux/mdio.h> 39 40 #include <linux/atomic.h> 41 #include <asm/io.h> 42 #include <asm/irq.h> 43 #include <asm/uaccess.h> 44 45 /** 46 * phy_print_status - Convenience function to print out the current phy status 47 * @phydev: the phy_device struct 48 */ 49 void phy_print_status(struct phy_device *phydev) 50 { 51 if (phydev->link) 52 pr_info("%s - Link is Up - %d/%s\n", 53 dev_name(&phydev->dev), 54 phydev->speed, 55 DUPLEX_FULL == phydev->duplex ? "Full" : "Half"); 56 else 57 pr_info("%s - Link is Down\n", dev_name(&phydev->dev)); 58 } 59 EXPORT_SYMBOL(phy_print_status); 60 61 /** 62 * phy_clear_interrupt - Ack the phy device's interrupt 63 * @phydev: the phy_device struct 64 * 65 * If the @phydev driver has an ack_interrupt function, call it to 66 * ack and clear the phy device's interrupt. 67 * 68 * Returns 0 on success on < 0 on error. 69 */ 70 static int phy_clear_interrupt(struct phy_device *phydev) 71 { 72 int err = 0; 73 74 if (phydev->drv->ack_interrupt) 75 err = phydev->drv->ack_interrupt(phydev); 76 77 return err; 78 } 79 80 /** 81 * phy_config_interrupt - configure the PHY device for the requested interrupts 82 * @phydev: the phy_device struct 83 * @interrupts: interrupt flags to configure for this @phydev 84 * 85 * Returns 0 on success on < 0 on error. 86 */ 87 static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts) 88 { 89 int err = 0; 90 91 phydev->interrupts = interrupts; 92 if (phydev->drv->config_intr) 93 err = phydev->drv->config_intr(phydev); 94 95 return err; 96 } 97 98 99 /** 100 * phy_aneg_done - return auto-negotiation status 101 * @phydev: target phy_device struct 102 * 103 * Description: Reads the status register and returns 0 either if 104 * auto-negotiation is incomplete, or if there was an error. 105 * Returns BMSR_ANEGCOMPLETE if auto-negotiation is done. 106 */ 107 static inline int phy_aneg_done(struct phy_device *phydev) 108 { 109 int retval; 110 111 retval = phy_read(phydev, MII_BMSR); 112 113 return (retval < 0) ? retval : (retval & BMSR_ANEGCOMPLETE); 114 } 115 116 /* A structure for mapping a particular speed and duplex 117 * combination to a particular SUPPORTED and ADVERTISED value */ 118 struct phy_setting { 119 int speed; 120 int duplex; 121 u32 setting; 122 }; 123 124 /* A mapping of all SUPPORTED settings to speed/duplex */ 125 static const struct phy_setting settings[] = { 126 { 127 .speed = 10000, 128 .duplex = DUPLEX_FULL, 129 .setting = SUPPORTED_10000baseT_Full, 130 }, 131 { 132 .speed = SPEED_1000, 133 .duplex = DUPLEX_FULL, 134 .setting = SUPPORTED_1000baseT_Full, 135 }, 136 { 137 .speed = SPEED_1000, 138 .duplex = DUPLEX_HALF, 139 .setting = SUPPORTED_1000baseT_Half, 140 }, 141 { 142 .speed = SPEED_100, 143 .duplex = DUPLEX_FULL, 144 .setting = SUPPORTED_100baseT_Full, 145 }, 146 { 147 .speed = SPEED_100, 148 .duplex = DUPLEX_HALF, 149 .setting = SUPPORTED_100baseT_Half, 150 }, 151 { 152 .speed = SPEED_10, 153 .duplex = DUPLEX_FULL, 154 .setting = SUPPORTED_10baseT_Full, 155 }, 156 { 157 .speed = SPEED_10, 158 .duplex = DUPLEX_HALF, 159 .setting = SUPPORTED_10baseT_Half, 160 }, 161 }; 162 163 #define MAX_NUM_SETTINGS ARRAY_SIZE(settings) 164 165 /** 166 * phy_find_setting - find a PHY settings array entry that matches speed & duplex 167 * @speed: speed to match 168 * @duplex: duplex to match 169 * 170 * Description: Searches the settings array for the setting which 171 * matches the desired speed and duplex, and returns the index 172 * of that setting. Returns the index of the last setting if 173 * none of the others match. 174 */ 175 static inline int phy_find_setting(int speed, int duplex) 176 { 177 int idx = 0; 178 179 while (idx < ARRAY_SIZE(settings) && 180 (settings[idx].speed != speed || 181 settings[idx].duplex != duplex)) 182 idx++; 183 184 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 185 } 186 187 /** 188 * phy_find_valid - find a PHY setting that matches the requested features mask 189 * @idx: The first index in settings[] to search 190 * @features: A mask of the valid settings 191 * 192 * Description: Returns the index of the first valid setting less 193 * than or equal to the one pointed to by idx, as determined by 194 * the mask in features. Returns the index of the last setting 195 * if nothing else matches. 196 */ 197 static inline int phy_find_valid(int idx, u32 features) 198 { 199 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features)) 200 idx++; 201 202 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 203 } 204 205 /** 206 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex 207 * @phydev: the target phy_device struct 208 * 209 * Description: Make sure the PHY is set to supported speeds and 210 * duplexes. Drop down by one in this order: 1000/FULL, 211 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 212 */ 213 static void phy_sanitize_settings(struct phy_device *phydev) 214 { 215 u32 features = phydev->supported; 216 int idx; 217 218 /* Sanitize settings based on PHY capabilities */ 219 if ((features & SUPPORTED_Autoneg) == 0) 220 phydev->autoneg = AUTONEG_DISABLE; 221 222 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex), 223 features); 224 225 phydev->speed = settings[idx].speed; 226 phydev->duplex = settings[idx].duplex; 227 } 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 u32 speed = ethtool_cmd_speed(cmd); 244 245 if (cmd->phy_address != phydev->addr) 246 return -EINVAL; 247 248 /* We make sure that we don't pass unsupported 249 * values in to the PHY */ 250 cmd->advertising &= phydev->supported; 251 252 /* Verify the settings we care about. */ 253 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) 254 return -EINVAL; 255 256 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) 257 return -EINVAL; 258 259 if (cmd->autoneg == AUTONEG_DISABLE && 260 ((speed != SPEED_1000 && 261 speed != SPEED_100 && 262 speed != SPEED_10) || 263 (cmd->duplex != DUPLEX_HALF && 264 cmd->duplex != DUPLEX_FULL))) 265 return -EINVAL; 266 267 phydev->autoneg = cmd->autoneg; 268 269 phydev->speed = speed; 270 271 phydev->advertising = cmd->advertising; 272 273 if (AUTONEG_ENABLE == cmd->autoneg) 274 phydev->advertising |= ADVERTISED_Autoneg; 275 else 276 phydev->advertising &= ~ADVERTISED_Autoneg; 277 278 phydev->duplex = cmd->duplex; 279 280 /* Restart the PHY */ 281 phy_start_aneg(phydev); 282 283 return 0; 284 } 285 EXPORT_SYMBOL(phy_ethtool_sset); 286 287 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd) 288 { 289 cmd->supported = phydev->supported; 290 291 cmd->advertising = phydev->advertising; 292 293 ethtool_cmd_speed_set(cmd, phydev->speed); 294 cmd->duplex = phydev->duplex; 295 cmd->port = PORT_MII; 296 cmd->phy_address = phydev->addr; 297 cmd->transceiver = XCVR_EXTERNAL; 298 cmd->autoneg = phydev->autoneg; 299 300 return 0; 301 } 302 EXPORT_SYMBOL(phy_ethtool_gset); 303 304 /** 305 * phy_mii_ioctl - generic PHY MII ioctl interface 306 * @phydev: the phy_device struct 307 * @ifr: &struct ifreq for socket ioctl's 308 * @cmd: ioctl cmd to execute 309 * 310 * Note that this function is currently incompatible with the 311 * PHYCONTROL layer. It changes registers without regard to 312 * current state. Use at own risk. 313 */ 314 int phy_mii_ioctl(struct phy_device *phydev, 315 struct ifreq *ifr, int cmd) 316 { 317 struct mii_ioctl_data *mii_data = if_mii(ifr); 318 u16 val = mii_data->val_in; 319 320 switch (cmd) { 321 case SIOCGMIIPHY: 322 mii_data->phy_id = phydev->addr; 323 /* fall through */ 324 325 case SIOCGMIIREG: 326 mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id, 327 mii_data->reg_num); 328 break; 329 330 case SIOCSMIIREG: 331 if (mii_data->phy_id == phydev->addr) { 332 switch(mii_data->reg_num) { 333 case MII_BMCR: 334 if ((val & (BMCR_RESET|BMCR_ANENABLE)) == 0) 335 phydev->autoneg = AUTONEG_DISABLE; 336 else 337 phydev->autoneg = AUTONEG_ENABLE; 338 if ((!phydev->autoneg) && (val & BMCR_FULLDPLX)) 339 phydev->duplex = DUPLEX_FULL; 340 else 341 phydev->duplex = DUPLEX_HALF; 342 if ((!phydev->autoneg) && 343 (val & BMCR_SPEED1000)) 344 phydev->speed = SPEED_1000; 345 else if ((!phydev->autoneg) && 346 (val & BMCR_SPEED100)) 347 phydev->speed = SPEED_100; 348 break; 349 case MII_ADVERTISE: 350 phydev->advertising = val; 351 break; 352 default: 353 /* do nothing */ 354 break; 355 } 356 } 357 358 mdiobus_write(phydev->bus, mii_data->phy_id, 359 mii_data->reg_num, val); 360 361 if (mii_data->reg_num == MII_BMCR && 362 val & BMCR_RESET && 363 phydev->drv->config_init) { 364 phy_scan_fixups(phydev); 365 phydev->drv->config_init(phydev); 366 } 367 break; 368 369 case SIOCSHWTSTAMP: 370 if (phydev->drv->hwtstamp) 371 return phydev->drv->hwtstamp(phydev, ifr); 372 /* fall through */ 373 374 default: 375 return -EOPNOTSUPP; 376 } 377 378 return 0; 379 } 380 EXPORT_SYMBOL(phy_mii_ioctl); 381 382 /** 383 * phy_start_aneg - start auto-negotiation for this PHY device 384 * @phydev: the phy_device struct 385 * 386 * Description: Sanitizes the settings (if we're not autonegotiating 387 * them), and then calls the driver's config_aneg function. 388 * If the PHYCONTROL Layer is operating, we change the state to 389 * reflect the beginning of Auto-negotiation or forcing. 390 */ 391 int phy_start_aneg(struct phy_device *phydev) 392 { 393 int err; 394 395 mutex_lock(&phydev->lock); 396 397 if (AUTONEG_DISABLE == phydev->autoneg) 398 phy_sanitize_settings(phydev); 399 400 err = phydev->drv->config_aneg(phydev); 401 402 if (err < 0) 403 goto out_unlock; 404 405 if (phydev->state != PHY_HALTED) { 406 if (AUTONEG_ENABLE == phydev->autoneg) { 407 phydev->state = PHY_AN; 408 phydev->link_timeout = PHY_AN_TIMEOUT; 409 } else { 410 phydev->state = PHY_FORCING; 411 phydev->link_timeout = PHY_FORCE_TIMEOUT; 412 } 413 } 414 415 out_unlock: 416 mutex_unlock(&phydev->lock); 417 return err; 418 } 419 EXPORT_SYMBOL(phy_start_aneg); 420 421 422 static void phy_change(struct work_struct *work); 423 424 /** 425 * phy_start_machine - start PHY state machine tracking 426 * @phydev: the phy_device struct 427 * @handler: callback function for state change notifications 428 * 429 * Description: The PHY infrastructure can run a state machine 430 * which tracks whether the PHY is starting up, negotiating, 431 * etc. This function starts the timer which tracks the state 432 * of the PHY. If you want to be notified when the state changes, 433 * pass in the callback @handler, otherwise, pass NULL. If you 434 * want to maintain your own state machine, do not call this 435 * function. 436 */ 437 void phy_start_machine(struct phy_device *phydev, 438 void (*handler)(struct net_device *)) 439 { 440 phydev->adjust_state = handler; 441 442 schedule_delayed_work(&phydev->state_queue, HZ); 443 } 444 445 /** 446 * phy_stop_machine - stop the PHY state machine tracking 447 * @phydev: target phy_device struct 448 * 449 * Description: Stops the state machine timer, sets the state to UP 450 * (unless it wasn't up yet). This function must be called BEFORE 451 * phy_detach. 452 */ 453 void phy_stop_machine(struct phy_device *phydev) 454 { 455 cancel_delayed_work_sync(&phydev->state_queue); 456 457 mutex_lock(&phydev->lock); 458 if (phydev->state > PHY_UP) 459 phydev->state = PHY_UP; 460 mutex_unlock(&phydev->lock); 461 462 phydev->adjust_state = NULL; 463 } 464 465 /** 466 * phy_force_reduction - reduce PHY speed/duplex settings by one step 467 * @phydev: target phy_device struct 468 * 469 * Description: Reduces the speed/duplex settings by one notch, 470 * in this order-- 471 * 1000/FULL, 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 472 * The function bottoms out at 10/HALF. 473 */ 474 static void phy_force_reduction(struct phy_device *phydev) 475 { 476 int idx; 477 478 idx = phy_find_setting(phydev->speed, phydev->duplex); 479 480 idx++; 481 482 idx = phy_find_valid(idx, phydev->supported); 483 484 phydev->speed = settings[idx].speed; 485 phydev->duplex = settings[idx].duplex; 486 487 pr_info("Trying %d/%s\n", 488 phydev->speed, DUPLEX_FULL == phydev->duplex ? "FULL" : "HALF"); 489 } 490 491 492 /** 493 * phy_error - enter HALTED state for this PHY device 494 * @phydev: target phy_device struct 495 * 496 * Moves the PHY to the HALTED state in response to a read 497 * or write error, and tells the controller the link is down. 498 * Must not be called from interrupt context, or while the 499 * phydev->lock is held. 500 */ 501 static void phy_error(struct phy_device *phydev) 502 { 503 mutex_lock(&phydev->lock); 504 phydev->state = PHY_HALTED; 505 mutex_unlock(&phydev->lock); 506 } 507 508 /** 509 * phy_interrupt - PHY interrupt handler 510 * @irq: interrupt line 511 * @phy_dat: phy_device pointer 512 * 513 * Description: When a PHY interrupt occurs, the handler disables 514 * interrupts, and schedules a work task to clear the interrupt. 515 */ 516 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 517 { 518 struct phy_device *phydev = phy_dat; 519 520 if (PHY_HALTED == phydev->state) 521 return IRQ_NONE; /* It can't be ours. */ 522 523 /* The MDIO bus is not allowed to be written in interrupt 524 * context, so we need to disable the irq here. A work 525 * queue will write the PHY to disable and clear the 526 * interrupt, and then reenable the irq line. */ 527 disable_irq_nosync(irq); 528 atomic_inc(&phydev->irq_disable); 529 530 schedule_work(&phydev->phy_queue); 531 532 return IRQ_HANDLED; 533 } 534 535 /** 536 * phy_enable_interrupts - Enable the interrupts from the PHY side 537 * @phydev: target phy_device struct 538 */ 539 static int phy_enable_interrupts(struct phy_device *phydev) 540 { 541 int err; 542 543 err = phy_clear_interrupt(phydev); 544 545 if (err < 0) 546 return err; 547 548 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 549 550 return err; 551 } 552 553 /** 554 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side 555 * @phydev: target phy_device struct 556 */ 557 static int phy_disable_interrupts(struct phy_device *phydev) 558 { 559 int err; 560 561 /* Disable PHY interrupts */ 562 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 563 564 if (err) 565 goto phy_err; 566 567 /* Clear the interrupt */ 568 err = phy_clear_interrupt(phydev); 569 570 if (err) 571 goto phy_err; 572 573 return 0; 574 575 phy_err: 576 phy_error(phydev); 577 578 return err; 579 } 580 581 /** 582 * phy_start_interrupts - request and enable interrupts for a PHY device 583 * @phydev: target phy_device struct 584 * 585 * Description: Request the interrupt for the given PHY. 586 * If this fails, then we set irq to PHY_POLL. 587 * Otherwise, we enable the interrupts in the PHY. 588 * This should only be called with a valid IRQ number. 589 * Returns 0 on success or < 0 on error. 590 */ 591 int phy_start_interrupts(struct phy_device *phydev) 592 { 593 int err = 0; 594 595 INIT_WORK(&phydev->phy_queue, phy_change); 596 597 atomic_set(&phydev->irq_disable, 0); 598 if (request_irq(phydev->irq, phy_interrupt, 599 IRQF_SHARED, 600 "phy_interrupt", 601 phydev) < 0) { 602 pr_warn("%s: Can't get IRQ %d (PHY)\n", 603 phydev->bus->name, phydev->irq); 604 phydev->irq = PHY_POLL; 605 return 0; 606 } 607 608 err = phy_enable_interrupts(phydev); 609 610 return err; 611 } 612 EXPORT_SYMBOL(phy_start_interrupts); 613 614 /** 615 * phy_stop_interrupts - disable interrupts from a PHY device 616 * @phydev: target phy_device struct 617 */ 618 int 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 } 646 EXPORT_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 */ 653 static 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 689 ignore: 690 atomic_dec(&phydev->irq_disable); 691 enable_irq(phydev->irq); 692 return; 693 694 irq_enable_err: 695 disable_irq(phydev->irq); 696 atomic_inc(&phydev->irq_disable); 697 phy_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 */ 705 void 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 722 out_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 */ 743 void 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 } 761 EXPORT_SYMBOL(phy_stop); 762 EXPORT_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 */ 768 void 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", 842 phydev->speed, 843 DUPLEX_FULL == 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 972 static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad, 973 int addr) 974 { 975 /* Write the desired MMD Devad */ 976 bus->write(bus, addr, MII_MMD_CTRL, devad); 977 978 /* Write the desired MMD register address */ 979 bus->write(bus, addr, MII_MMD_DATA, prtad); 980 981 /* Select the Function : DATA with no post increment */ 982 bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR)); 983 } 984 985 /** 986 * phy_read_mmd_indirect - reads data from the MMD registers 987 * @bus: the target MII bus 988 * @prtad: MMD Address 989 * @devad: MMD DEVAD 990 * @addr: PHY address on the MII bus 991 * 992 * Description: it reads data from the MMD registers (clause 22 to access to 993 * clause 45) of the specified phy address. 994 * To read these register we have: 995 * 1) Write reg 13 // DEVAD 996 * 2) Write reg 14 // MMD Address 997 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 998 * 3) Read reg 14 // Read MMD data 999 */ 1000 static int phy_read_mmd_indirect(struct mii_bus *bus, int prtad, int devad, 1001 int addr) 1002 { 1003 u32 ret; 1004 1005 mmd_phy_indirect(bus, prtad, devad, addr); 1006 1007 /* Read the content of the MMD's selected register */ 1008 ret = bus->read(bus, addr, MII_MMD_DATA); 1009 1010 return ret; 1011 } 1012 1013 /** 1014 * phy_write_mmd_indirect - writes data to the MMD registers 1015 * @bus: the target MII bus 1016 * @prtad: MMD Address 1017 * @devad: MMD DEVAD 1018 * @addr: PHY address on the MII bus 1019 * @data: data to write in the MMD register 1020 * 1021 * Description: Write data from the MMD registers of the specified 1022 * phy address. 1023 * To write these register we have: 1024 * 1) Write reg 13 // DEVAD 1025 * 2) Write reg 14 // MMD Address 1026 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 1027 * 3) Write reg 14 // Write MMD data 1028 */ 1029 static void phy_write_mmd_indirect(struct mii_bus *bus, int prtad, int devad, 1030 int addr, u32 data) 1031 { 1032 mmd_phy_indirect(bus, prtad, devad, addr); 1033 1034 /* Write the data into MMD's selected register */ 1035 bus->write(bus, addr, MII_MMD_DATA, data); 1036 } 1037 1038 /** 1039 * phy_init_eee - init and check the EEE feature 1040 * @phydev: target phy_device struct 1041 * @clk_stop_enable: PHY may stop the clock during LPI 1042 * 1043 * Description: it checks if the Energy-Efficient Ethernet (EEE) 1044 * is supported by looking at the MMD registers 3.20 and 7.60/61 1045 * and it programs the MMD register 3.0 setting the "Clock stop enable" 1046 * bit if required. 1047 */ 1048 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 1049 { 1050 int ret = -EPROTONOSUPPORT; 1051 1052 /* According to 802.3az,the EEE is supported only in full duplex-mode. 1053 * Also EEE feature is active when core is operating with MII, GMII 1054 * or RGMII. 1055 */ 1056 if ((phydev->duplex == DUPLEX_FULL) && 1057 ((phydev->interface == PHY_INTERFACE_MODE_MII) || 1058 (phydev->interface == PHY_INTERFACE_MODE_GMII) || 1059 (phydev->interface == PHY_INTERFACE_MODE_RGMII))) { 1060 int eee_lp, eee_cap, eee_adv; 1061 u32 lp, cap, adv; 1062 int idx, status; 1063 1064 /* Read phy status to properly get the right settings */ 1065 status = phy_read_status(phydev); 1066 if (status) 1067 return status; 1068 1069 /* First check if the EEE ability is supported */ 1070 eee_cap = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE, 1071 MDIO_MMD_PCS, phydev->addr); 1072 if (eee_cap < 0) 1073 return eee_cap; 1074 1075 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap); 1076 if (!cap) 1077 goto eee_exit; 1078 1079 /* Check which link settings negotiated and verify it in 1080 * the EEE advertising registers. 1081 */ 1082 eee_lp = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE, 1083 MDIO_MMD_AN, phydev->addr); 1084 if (eee_lp < 0) 1085 return eee_lp; 1086 1087 eee_adv = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, 1088 MDIO_MMD_AN, phydev->addr); 1089 if (eee_adv < 0) 1090 return eee_adv; 1091 1092 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv); 1093 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp); 1094 idx = phy_find_setting(phydev->speed, phydev->duplex); 1095 if ((lp & adv & settings[idx].setting)) 1096 goto eee_exit; 1097 1098 if (clk_stop_enable) { 1099 /* Configure the PHY to stop receiving xMII 1100 * clock while it is signaling LPI. 1101 */ 1102 int val = phy_read_mmd_indirect(phydev->bus, MDIO_CTRL1, 1103 MDIO_MMD_PCS, 1104 phydev->addr); 1105 if (val < 0) 1106 return val; 1107 1108 val |= MDIO_PCS_CTRL1_CLKSTOP_EN; 1109 phy_write_mmd_indirect(phydev->bus, MDIO_CTRL1, 1110 MDIO_MMD_PCS, phydev->addr, val); 1111 } 1112 1113 ret = 0; /* EEE supported */ 1114 } 1115 1116 eee_exit: 1117 return ret; 1118 } 1119 EXPORT_SYMBOL(phy_init_eee); 1120 1121 /** 1122 * phy_get_eee_err - report the EEE wake error count 1123 * @phydev: target phy_device struct 1124 * 1125 * Description: it is to report the number of time where the PHY 1126 * failed to complete its normal wake sequence. 1127 */ 1128 int phy_get_eee_err(struct phy_device *phydev) 1129 { 1130 return phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_WK_ERR, 1131 MDIO_MMD_PCS, phydev->addr); 1132 1133 } 1134 EXPORT_SYMBOL(phy_get_eee_err); 1135 1136 /** 1137 * phy_ethtool_get_eee - get EEE supported and status 1138 * @phydev: target phy_device struct 1139 * @data: ethtool_eee data 1140 * 1141 * Description: it reportes the Supported/Advertisement/LP Advertisement 1142 * capabilities. 1143 */ 1144 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data) 1145 { 1146 int val; 1147 1148 /* Get Supported EEE */ 1149 val = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE, 1150 MDIO_MMD_PCS, phydev->addr); 1151 if (val < 0) 1152 return val; 1153 data->supported = mmd_eee_cap_to_ethtool_sup_t(val); 1154 1155 /* Get advertisement EEE */ 1156 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, 1157 MDIO_MMD_AN, phydev->addr); 1158 if (val < 0) 1159 return val; 1160 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1161 1162 /* Get LP advertisement EEE */ 1163 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE, 1164 MDIO_MMD_AN, phydev->addr); 1165 if (val < 0) 1166 return val; 1167 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1168 1169 return 0; 1170 } 1171 EXPORT_SYMBOL(phy_ethtool_get_eee); 1172 1173 /** 1174 * phy_ethtool_set_eee - set EEE supported and status 1175 * @phydev: target phy_device struct 1176 * @data: ethtool_eee data 1177 * 1178 * Description: it is to program the Advertisement EEE register. 1179 */ 1180 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data) 1181 { 1182 int val; 1183 1184 val = ethtool_adv_to_mmd_eee_adv_t(data->advertised); 1185 phy_write_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, MDIO_MMD_AN, 1186 phydev->addr, val); 1187 1188 return 0; 1189 } 1190 EXPORT_SYMBOL(phy_ethtool_set_eee); 1191