1 /* Framework for configuring and reading PHY devices 2 * Based on code in sungem_phy.c and gianfar_phy.c 3 * 4 * Author: Andy Fleming 5 * 6 * Copyright (c) 2004 Freescale Semiconductor, Inc. 7 * Copyright (c) 2006, 2007 Maciej W. Rozycki 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 * 14 */ 15 16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 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/delay.h> 24 #include <linux/netdevice.h> 25 #include <linux/etherdevice.h> 26 #include <linux/skbuff.h> 27 #include <linux/mm.h> 28 #include <linux/module.h> 29 #include <linux/mii.h> 30 #include <linux/ethtool.h> 31 #include <linux/phy.h> 32 #include <linux/timer.h> 33 #include <linux/workqueue.h> 34 #include <linux/mdio.h> 35 #include <linux/io.h> 36 #include <linux/uaccess.h> 37 #include <linux/atomic.h> 38 39 #include <asm/irq.h> 40 41 static const char *phy_speed_to_str(int speed) 42 { 43 switch (speed) { 44 case SPEED_10: 45 return "10Mbps"; 46 case SPEED_100: 47 return "100Mbps"; 48 case SPEED_1000: 49 return "1Gbps"; 50 case SPEED_2500: 51 return "2.5Gbps"; 52 case SPEED_10000: 53 return "10Gbps"; 54 case SPEED_UNKNOWN: 55 return "Unknown"; 56 default: 57 return "Unsupported (update phy.c)"; 58 } 59 } 60 61 /** 62 * phy_print_status - Convenience function to print out the current phy status 63 * @phydev: the phy_device struct 64 */ 65 void phy_print_status(struct phy_device *phydev) 66 { 67 if (phydev->link) { 68 netdev_info(phydev->attached_dev, 69 "Link is Up - %s/%s - flow control %s\n", 70 phy_speed_to_str(phydev->speed), 71 DUPLEX_FULL == phydev->duplex ? "Full" : "Half", 72 phydev->pause ? "rx/tx" : "off"); 73 } else { 74 netdev_info(phydev->attached_dev, "Link is Down\n"); 75 } 76 } 77 EXPORT_SYMBOL(phy_print_status); 78 79 /** 80 * phy_clear_interrupt - Ack the phy device's interrupt 81 * @phydev: the phy_device struct 82 * 83 * If the @phydev driver has an ack_interrupt function, call it to 84 * ack and clear the phy device's interrupt. 85 * 86 * Returns 0 on success or < 0 on error. 87 */ 88 static int phy_clear_interrupt(struct phy_device *phydev) 89 { 90 if (phydev->drv->ack_interrupt) 91 return phydev->drv->ack_interrupt(phydev); 92 93 return 0; 94 } 95 96 /** 97 * phy_config_interrupt - configure the PHY device for the requested interrupts 98 * @phydev: the phy_device struct 99 * @interrupts: interrupt flags to configure for this @phydev 100 * 101 * Returns 0 on success or < 0 on error. 102 */ 103 static int phy_config_interrupt(struct phy_device *phydev, u32 interrupts) 104 { 105 phydev->interrupts = interrupts; 106 if (phydev->drv->config_intr) 107 return phydev->drv->config_intr(phydev); 108 109 return 0; 110 } 111 112 113 /** 114 * phy_aneg_done - return auto-negotiation status 115 * @phydev: target phy_device struct 116 * 117 * Description: Return the auto-negotiation status from this @phydev 118 * Returns > 0 on success or < 0 on error. 0 means that auto-negotiation 119 * is still pending. 120 */ 121 static inline int phy_aneg_done(struct phy_device *phydev) 122 { 123 if (phydev->drv->aneg_done) 124 return phydev->drv->aneg_done(phydev); 125 126 return genphy_aneg_done(phydev); 127 } 128 129 /* A structure for mapping a particular speed and duplex 130 * combination to a particular SUPPORTED and ADVERTISED value 131 */ 132 struct phy_setting { 133 int speed; 134 int duplex; 135 u32 setting; 136 }; 137 138 /* A mapping of all SUPPORTED settings to speed/duplex */ 139 static const struct phy_setting settings[] = { 140 { 141 .speed = 10000, 142 .duplex = DUPLEX_FULL, 143 .setting = SUPPORTED_10000baseT_Full, 144 }, 145 { 146 .speed = SPEED_1000, 147 .duplex = DUPLEX_FULL, 148 .setting = SUPPORTED_1000baseT_Full, 149 }, 150 { 151 .speed = SPEED_1000, 152 .duplex = DUPLEX_HALF, 153 .setting = SUPPORTED_1000baseT_Half, 154 }, 155 { 156 .speed = SPEED_100, 157 .duplex = DUPLEX_FULL, 158 .setting = SUPPORTED_100baseT_Full, 159 }, 160 { 161 .speed = SPEED_100, 162 .duplex = DUPLEX_HALF, 163 .setting = SUPPORTED_100baseT_Half, 164 }, 165 { 166 .speed = SPEED_10, 167 .duplex = DUPLEX_FULL, 168 .setting = SUPPORTED_10baseT_Full, 169 }, 170 { 171 .speed = SPEED_10, 172 .duplex = DUPLEX_HALF, 173 .setting = SUPPORTED_10baseT_Half, 174 }, 175 }; 176 177 #define MAX_NUM_SETTINGS ARRAY_SIZE(settings) 178 179 /** 180 * phy_find_setting - find a PHY settings array entry that matches speed & duplex 181 * @speed: speed to match 182 * @duplex: duplex to match 183 * 184 * Description: Searches the settings array for the setting which 185 * matches the desired speed and duplex, and returns the index 186 * of that setting. Returns the index of the last setting if 187 * none of the others match. 188 */ 189 static inline unsigned int phy_find_setting(int speed, int duplex) 190 { 191 unsigned int idx = 0; 192 193 while (idx < ARRAY_SIZE(settings) && 194 (settings[idx].speed != speed || settings[idx].duplex != duplex)) 195 idx++; 196 197 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 198 } 199 200 /** 201 * phy_find_valid - find a PHY setting that matches the requested features mask 202 * @idx: The first index in settings[] to search 203 * @features: A mask of the valid settings 204 * 205 * Description: Returns the index of the first valid setting less 206 * than or equal to the one pointed to by idx, as determined by 207 * the mask in features. Returns the index of the last setting 208 * if nothing else matches. 209 */ 210 static inline unsigned int phy_find_valid(unsigned int idx, u32 features) 211 { 212 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features)) 213 idx++; 214 215 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 216 } 217 218 /** 219 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex 220 * @phydev: the target phy_device struct 221 * 222 * Description: Make sure the PHY is set to supported speeds and 223 * duplexes. Drop down by one in this order: 1000/FULL, 224 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 225 */ 226 static void phy_sanitize_settings(struct phy_device *phydev) 227 { 228 u32 features = phydev->supported; 229 unsigned int idx; 230 231 /* Sanitize settings based on PHY capabilities */ 232 if ((features & SUPPORTED_Autoneg) == 0) 233 phydev->autoneg = AUTONEG_DISABLE; 234 235 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex), 236 features); 237 238 phydev->speed = settings[idx].speed; 239 phydev->duplex = settings[idx].duplex; 240 } 241 242 /** 243 * phy_ethtool_sset - generic ethtool sset function, handles all the details 244 * @phydev: target phy_device struct 245 * @cmd: ethtool_cmd 246 * 247 * A few notes about parameter checking: 248 * - We don't set port or transceiver, so we don't care what they 249 * were set to. 250 * - phy_start_aneg() will make sure forced settings are sane, and 251 * choose the next best ones from the ones selected, so we don't 252 * care if ethtool tries to give us bad values. 253 */ 254 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd) 255 { 256 u32 speed = ethtool_cmd_speed(cmd); 257 258 if (cmd->phy_address != phydev->addr) 259 return -EINVAL; 260 261 /* We make sure that we don't pass unsupported values in to the PHY */ 262 cmd->advertising &= phydev->supported; 263 264 /* Verify the settings we care about. */ 265 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) 266 return -EINVAL; 267 268 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) 269 return -EINVAL; 270 271 if (cmd->autoneg == AUTONEG_DISABLE && 272 ((speed != SPEED_1000 && 273 speed != SPEED_100 && 274 speed != SPEED_10) || 275 (cmd->duplex != DUPLEX_HALF && 276 cmd->duplex != DUPLEX_FULL))) 277 return -EINVAL; 278 279 phydev->autoneg = cmd->autoneg; 280 281 phydev->speed = speed; 282 283 phydev->advertising = cmd->advertising; 284 285 if (AUTONEG_ENABLE == cmd->autoneg) 286 phydev->advertising |= ADVERTISED_Autoneg; 287 else 288 phydev->advertising &= ~ADVERTISED_Autoneg; 289 290 phydev->duplex = cmd->duplex; 291 292 /* Restart the PHY */ 293 phy_start_aneg(phydev); 294 295 return 0; 296 } 297 EXPORT_SYMBOL(phy_ethtool_sset); 298 299 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd) 300 { 301 cmd->supported = phydev->supported; 302 303 cmd->advertising = phydev->advertising; 304 cmd->lp_advertising = phydev->lp_advertising; 305 306 ethtool_cmd_speed_set(cmd, phydev->speed); 307 cmd->duplex = phydev->duplex; 308 if (phydev->interface == PHY_INTERFACE_MODE_MOCA) 309 cmd->port = PORT_BNC; 310 else 311 cmd->port = PORT_MII; 312 cmd->phy_address = phydev->addr; 313 cmd->transceiver = phy_is_internal(phydev) ? 314 XCVR_INTERNAL : XCVR_EXTERNAL; 315 cmd->autoneg = phydev->autoneg; 316 317 return 0; 318 } 319 EXPORT_SYMBOL(phy_ethtool_gset); 320 321 /** 322 * phy_mii_ioctl - generic PHY MII ioctl interface 323 * @phydev: the phy_device struct 324 * @ifr: &struct ifreq for socket ioctl's 325 * @cmd: ioctl cmd to execute 326 * 327 * Note that this function is currently incompatible with the 328 * PHYCONTROL layer. It changes registers without regard to 329 * current state. Use at own risk. 330 */ 331 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd) 332 { 333 struct mii_ioctl_data *mii_data = if_mii(ifr); 334 u16 val = mii_data->val_in; 335 336 switch (cmd) { 337 case SIOCGMIIPHY: 338 mii_data->phy_id = phydev->addr; 339 /* fall through */ 340 341 case SIOCGMIIREG: 342 mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id, 343 mii_data->reg_num); 344 return 0; 345 346 case SIOCSMIIREG: 347 if (mii_data->phy_id == phydev->addr) { 348 switch (mii_data->reg_num) { 349 case MII_BMCR: 350 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) 351 phydev->autoneg = AUTONEG_DISABLE; 352 else 353 phydev->autoneg = AUTONEG_ENABLE; 354 if (!phydev->autoneg && (val & BMCR_FULLDPLX)) 355 phydev->duplex = DUPLEX_FULL; 356 else 357 phydev->duplex = DUPLEX_HALF; 358 if (!phydev->autoneg && (val & BMCR_SPEED1000)) 359 phydev->speed = SPEED_1000; 360 else if (!phydev->autoneg && 361 (val & BMCR_SPEED100)) 362 phydev->speed = SPEED_100; 363 break; 364 case MII_ADVERTISE: 365 phydev->advertising = val; 366 break; 367 default: 368 /* do nothing */ 369 break; 370 } 371 } 372 373 mdiobus_write(phydev->bus, mii_data->phy_id, 374 mii_data->reg_num, val); 375 376 if (mii_data->reg_num == MII_BMCR && 377 val & BMCR_RESET) 378 return phy_init_hw(phydev); 379 return 0; 380 381 case SIOCSHWTSTAMP: 382 if (phydev->drv->hwtstamp) 383 return phydev->drv->hwtstamp(phydev, ifr); 384 /* fall through */ 385 386 default: 387 return -EOPNOTSUPP; 388 } 389 } 390 EXPORT_SYMBOL(phy_mii_ioctl); 391 392 /** 393 * phy_start_aneg - start auto-negotiation for this PHY device 394 * @phydev: the phy_device struct 395 * 396 * Description: Sanitizes the settings (if we're not autonegotiating 397 * them), and then calls the driver's config_aneg function. 398 * If the PHYCONTROL Layer is operating, we change the state to 399 * reflect the beginning of Auto-negotiation or forcing. 400 */ 401 int phy_start_aneg(struct phy_device *phydev) 402 { 403 int err; 404 405 mutex_lock(&phydev->lock); 406 407 if (AUTONEG_DISABLE == phydev->autoneg) 408 phy_sanitize_settings(phydev); 409 410 err = phydev->drv->config_aneg(phydev); 411 if (err < 0) 412 goto out_unlock; 413 414 if (phydev->state != PHY_HALTED) { 415 if (AUTONEG_ENABLE == phydev->autoneg) { 416 phydev->state = PHY_AN; 417 phydev->link_timeout = PHY_AN_TIMEOUT; 418 } else { 419 phydev->state = PHY_FORCING; 420 phydev->link_timeout = PHY_FORCE_TIMEOUT; 421 } 422 } 423 424 out_unlock: 425 mutex_unlock(&phydev->lock); 426 return err; 427 } 428 EXPORT_SYMBOL(phy_start_aneg); 429 430 /** 431 * phy_start_machine - start PHY state machine tracking 432 * @phydev: the phy_device struct 433 * 434 * Description: The PHY infrastructure can run a state machine 435 * which tracks whether the PHY is starting up, negotiating, 436 * etc. This function starts the timer which tracks the state 437 * of the PHY. If you want to maintain your own state machine, 438 * do not call this function. 439 */ 440 void phy_start_machine(struct phy_device *phydev) 441 { 442 queue_delayed_work(system_power_efficient_wq, &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 463 /** 464 * phy_error - enter HALTED state for this PHY device 465 * @phydev: target phy_device struct 466 * 467 * Moves the PHY to the HALTED state in response to a read 468 * or write error, and tells the controller the link is down. 469 * Must not be called from interrupt context, or while the 470 * phydev->lock is held. 471 */ 472 static void phy_error(struct phy_device *phydev) 473 { 474 mutex_lock(&phydev->lock); 475 phydev->state = PHY_HALTED; 476 mutex_unlock(&phydev->lock); 477 } 478 479 /** 480 * phy_interrupt - PHY interrupt handler 481 * @irq: interrupt line 482 * @phy_dat: phy_device pointer 483 * 484 * Description: When a PHY interrupt occurs, the handler disables 485 * interrupts, and schedules a work task to clear the interrupt. 486 */ 487 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 488 { 489 struct phy_device *phydev = phy_dat; 490 491 if (PHY_HALTED == phydev->state) 492 return IRQ_NONE; /* It can't be ours. */ 493 494 /* The MDIO bus is not allowed to be written in interrupt 495 * context, so we need to disable the irq here. A work 496 * queue will write the PHY to disable and clear the 497 * interrupt, and then reenable the irq line. 498 */ 499 disable_irq_nosync(irq); 500 atomic_inc(&phydev->irq_disable); 501 502 queue_work(system_power_efficient_wq, &phydev->phy_queue); 503 504 return IRQ_HANDLED; 505 } 506 507 /** 508 * phy_enable_interrupts - Enable the interrupts from the PHY side 509 * @phydev: target phy_device struct 510 */ 511 static int phy_enable_interrupts(struct phy_device *phydev) 512 { 513 int err = phy_clear_interrupt(phydev); 514 515 if (err < 0) 516 return err; 517 518 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 519 } 520 521 /** 522 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side 523 * @phydev: target phy_device struct 524 */ 525 static int phy_disable_interrupts(struct phy_device *phydev) 526 { 527 int err; 528 529 /* Disable PHY interrupts */ 530 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 531 if (err) 532 goto phy_err; 533 534 /* Clear the interrupt */ 535 err = phy_clear_interrupt(phydev); 536 if (err) 537 goto phy_err; 538 539 return 0; 540 541 phy_err: 542 phy_error(phydev); 543 544 return err; 545 } 546 547 /** 548 * phy_start_interrupts - request and enable interrupts for a PHY device 549 * @phydev: target phy_device struct 550 * 551 * Description: Request the interrupt for the given PHY. 552 * If this fails, then we set irq to PHY_POLL. 553 * Otherwise, we enable the interrupts in the PHY. 554 * This should only be called with a valid IRQ number. 555 * Returns 0 on success or < 0 on error. 556 */ 557 int phy_start_interrupts(struct phy_device *phydev) 558 { 559 atomic_set(&phydev->irq_disable, 0); 560 if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt", 561 phydev) < 0) { 562 pr_warn("%s: Can't get IRQ %d (PHY)\n", 563 phydev->bus->name, phydev->irq); 564 phydev->irq = PHY_POLL; 565 return 0; 566 } 567 568 return phy_enable_interrupts(phydev); 569 } 570 EXPORT_SYMBOL(phy_start_interrupts); 571 572 /** 573 * phy_stop_interrupts - disable interrupts from a PHY device 574 * @phydev: target phy_device struct 575 */ 576 int phy_stop_interrupts(struct phy_device *phydev) 577 { 578 int err = phy_disable_interrupts(phydev); 579 580 if (err) 581 phy_error(phydev); 582 583 free_irq(phydev->irq, phydev); 584 585 /* Cannot call flush_scheduled_work() here as desired because 586 * of rtnl_lock(), but we do not really care about what would 587 * be done, except from enable_irq(), so cancel any work 588 * possibly pending and take care of the matter below. 589 */ 590 cancel_work_sync(&phydev->phy_queue); 591 /* If work indeed has been cancelled, disable_irq() will have 592 * been left unbalanced from phy_interrupt() and enable_irq() 593 * has to be called so that other devices on the line work. 594 */ 595 while (atomic_dec_return(&phydev->irq_disable) >= 0) 596 enable_irq(phydev->irq); 597 598 return err; 599 } 600 EXPORT_SYMBOL(phy_stop_interrupts); 601 602 /** 603 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes 604 * @work: work_struct that describes the work to be done 605 */ 606 void phy_change(struct work_struct *work) 607 { 608 struct phy_device *phydev = 609 container_of(work, struct phy_device, phy_queue); 610 611 if (phydev->drv->did_interrupt && 612 !phydev->drv->did_interrupt(phydev)) 613 goto ignore; 614 615 if (phy_disable_interrupts(phydev)) 616 goto phy_err; 617 618 mutex_lock(&phydev->lock); 619 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state)) 620 phydev->state = PHY_CHANGELINK; 621 mutex_unlock(&phydev->lock); 622 623 atomic_dec(&phydev->irq_disable); 624 enable_irq(phydev->irq); 625 626 /* Reenable interrupts */ 627 if (PHY_HALTED != phydev->state && 628 phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED)) 629 goto irq_enable_err; 630 631 /* reschedule state queue work to run as soon as possible */ 632 cancel_delayed_work_sync(&phydev->state_queue); 633 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0); 634 return; 635 636 ignore: 637 atomic_dec(&phydev->irq_disable); 638 enable_irq(phydev->irq); 639 return; 640 641 irq_enable_err: 642 disable_irq(phydev->irq); 643 atomic_inc(&phydev->irq_disable); 644 phy_err: 645 phy_error(phydev); 646 } 647 648 /** 649 * phy_stop - Bring down the PHY link, and stop checking the status 650 * @phydev: target phy_device struct 651 */ 652 void phy_stop(struct phy_device *phydev) 653 { 654 mutex_lock(&phydev->lock); 655 656 if (PHY_HALTED == phydev->state) 657 goto out_unlock; 658 659 if (phy_interrupt_is_valid(phydev)) { 660 /* Disable PHY Interrupts */ 661 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 662 663 /* Clear any pending interrupts */ 664 phy_clear_interrupt(phydev); 665 } 666 667 phydev->state = PHY_HALTED; 668 669 out_unlock: 670 mutex_unlock(&phydev->lock); 671 672 /* Cannot call flush_scheduled_work() here as desired because 673 * of rtnl_lock(), but PHY_HALTED shall guarantee phy_change() 674 * will not reenable interrupts. 675 */ 676 } 677 EXPORT_SYMBOL(phy_stop); 678 679 /** 680 * phy_start - start or restart a PHY device 681 * @phydev: target phy_device struct 682 * 683 * Description: Indicates the attached device's readiness to 684 * handle PHY-related work. Used during startup to start the 685 * PHY, and after a call to phy_stop() to resume operation. 686 * Also used to indicate the MDIO bus has cleared an error 687 * condition. 688 */ 689 void phy_start(struct phy_device *phydev) 690 { 691 mutex_lock(&phydev->lock); 692 693 switch (phydev->state) { 694 case PHY_STARTING: 695 phydev->state = PHY_PENDING; 696 break; 697 case PHY_READY: 698 phydev->state = PHY_UP; 699 break; 700 case PHY_HALTED: 701 phydev->state = PHY_RESUMING; 702 default: 703 break; 704 } 705 mutex_unlock(&phydev->lock); 706 } 707 EXPORT_SYMBOL(phy_start); 708 709 /** 710 * phy_state_machine - Handle the state machine 711 * @work: work_struct that describes the work to be done 712 */ 713 void phy_state_machine(struct work_struct *work) 714 { 715 struct delayed_work *dwork = to_delayed_work(work); 716 struct phy_device *phydev = 717 container_of(dwork, struct phy_device, state_queue); 718 int needs_aneg = 0, do_suspend = 0; 719 int err = 0; 720 721 mutex_lock(&phydev->lock); 722 723 switch (phydev->state) { 724 case PHY_DOWN: 725 case PHY_STARTING: 726 case PHY_READY: 727 case PHY_PENDING: 728 break; 729 case PHY_UP: 730 needs_aneg = 1; 731 732 phydev->link_timeout = PHY_AN_TIMEOUT; 733 734 break; 735 case PHY_AN: 736 err = phy_read_status(phydev); 737 if (err < 0) 738 break; 739 740 /* If the link is down, give up on negotiation for now */ 741 if (!phydev->link) { 742 phydev->state = PHY_NOLINK; 743 netif_carrier_off(phydev->attached_dev); 744 phydev->adjust_link(phydev->attached_dev); 745 break; 746 } 747 748 /* Check if negotiation is done. Break if there's an error */ 749 err = phy_aneg_done(phydev); 750 if (err < 0) 751 break; 752 753 /* If AN is done, we're running */ 754 if (err > 0) { 755 phydev->state = PHY_RUNNING; 756 netif_carrier_on(phydev->attached_dev); 757 phydev->adjust_link(phydev->attached_dev); 758 759 } else if (0 == phydev->link_timeout--) 760 needs_aneg = 1; 761 break; 762 case PHY_NOLINK: 763 err = phy_read_status(phydev); 764 if (err) 765 break; 766 767 if (phydev->link) { 768 if (AUTONEG_ENABLE == phydev->autoneg) { 769 err = phy_aneg_done(phydev); 770 if (err < 0) 771 break; 772 773 if (!err) { 774 phydev->state = PHY_AN; 775 phydev->link_timeout = PHY_AN_TIMEOUT; 776 break; 777 } 778 } 779 phydev->state = PHY_RUNNING; 780 netif_carrier_on(phydev->attached_dev); 781 phydev->adjust_link(phydev->attached_dev); 782 } 783 break; 784 case PHY_FORCING: 785 err = genphy_update_link(phydev); 786 if (err) 787 break; 788 789 if (phydev->link) { 790 phydev->state = PHY_RUNNING; 791 netif_carrier_on(phydev->attached_dev); 792 } else { 793 if (0 == phydev->link_timeout--) 794 needs_aneg = 1; 795 } 796 797 phydev->adjust_link(phydev->attached_dev); 798 break; 799 case PHY_RUNNING: 800 /* Only register a CHANGE if we are 801 * polling or ignoring interrupts 802 */ 803 if (!phy_interrupt_is_valid(phydev)) 804 phydev->state = PHY_CHANGELINK; 805 break; 806 case PHY_CHANGELINK: 807 err = phy_read_status(phydev); 808 if (err) 809 break; 810 811 if (phydev->link) { 812 phydev->state = PHY_RUNNING; 813 netif_carrier_on(phydev->attached_dev); 814 } else { 815 phydev->state = PHY_NOLINK; 816 netif_carrier_off(phydev->attached_dev); 817 } 818 819 phydev->adjust_link(phydev->attached_dev); 820 821 if (phy_interrupt_is_valid(phydev)) 822 err = phy_config_interrupt(phydev, 823 PHY_INTERRUPT_ENABLED); 824 break; 825 case PHY_HALTED: 826 if (phydev->link) { 827 phydev->link = 0; 828 netif_carrier_off(phydev->attached_dev); 829 phydev->adjust_link(phydev->attached_dev); 830 do_suspend = 1; 831 } 832 break; 833 case PHY_RESUMING: 834 err = phy_clear_interrupt(phydev); 835 if (err) 836 break; 837 838 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 839 if (err) 840 break; 841 842 if (AUTONEG_ENABLE == phydev->autoneg) { 843 err = phy_aneg_done(phydev); 844 if (err < 0) 845 break; 846 847 /* err > 0 if AN is done. 848 * Otherwise, it's 0, and we're still waiting for AN 849 */ 850 if (err > 0) { 851 err = phy_read_status(phydev); 852 if (err) 853 break; 854 855 if (phydev->link) { 856 phydev->state = PHY_RUNNING; 857 netif_carrier_on(phydev->attached_dev); 858 } else { 859 phydev->state = PHY_NOLINK; 860 } 861 phydev->adjust_link(phydev->attached_dev); 862 } else { 863 phydev->state = PHY_AN; 864 phydev->link_timeout = PHY_AN_TIMEOUT; 865 } 866 } else { 867 err = phy_read_status(phydev); 868 if (err) 869 break; 870 871 if (phydev->link) { 872 phydev->state = PHY_RUNNING; 873 netif_carrier_on(phydev->attached_dev); 874 } else { 875 phydev->state = PHY_NOLINK; 876 } 877 phydev->adjust_link(phydev->attached_dev); 878 } 879 break; 880 } 881 882 mutex_unlock(&phydev->lock); 883 884 if (needs_aneg) 885 err = phy_start_aneg(phydev); 886 887 if (do_suspend) 888 phy_suspend(phydev); 889 890 if (err < 0) 891 phy_error(phydev); 892 893 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 894 PHY_STATE_TIME * HZ); 895 } 896 897 void phy_mac_interrupt(struct phy_device *phydev, int new_link) 898 { 899 cancel_work_sync(&phydev->phy_queue); 900 phydev->link = new_link; 901 schedule_work(&phydev->phy_queue); 902 } 903 EXPORT_SYMBOL(phy_mac_interrupt); 904 905 static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad, 906 int addr) 907 { 908 /* Write the desired MMD Devad */ 909 bus->write(bus, addr, MII_MMD_CTRL, devad); 910 911 /* Write the desired MMD register address */ 912 bus->write(bus, addr, MII_MMD_DATA, prtad); 913 914 /* Select the Function : DATA with no post increment */ 915 bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR)); 916 } 917 918 /** 919 * phy_read_mmd_indirect - reads data from the MMD registers 920 * @bus: the target MII bus 921 * @prtad: MMD Address 922 * @devad: MMD DEVAD 923 * @addr: PHY address on the MII bus 924 * 925 * Description: it reads data from the MMD registers (clause 22 to access to 926 * clause 45) of the specified phy address. 927 * To read these register we have: 928 * 1) Write reg 13 // DEVAD 929 * 2) Write reg 14 // MMD Address 930 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 931 * 3) Read reg 14 // Read MMD data 932 */ 933 static int phy_read_mmd_indirect(struct mii_bus *bus, int prtad, int devad, 934 int addr) 935 { 936 mmd_phy_indirect(bus, prtad, devad, addr); 937 938 /* Read the content of the MMD's selected register */ 939 return bus->read(bus, addr, MII_MMD_DATA); 940 } 941 942 /** 943 * phy_write_mmd_indirect - writes data to the MMD registers 944 * @bus: the target MII bus 945 * @prtad: MMD Address 946 * @devad: MMD DEVAD 947 * @addr: PHY address on the MII bus 948 * @data: data to write in the MMD register 949 * 950 * Description: Write data from the MMD registers of the specified 951 * phy address. 952 * To write these register we have: 953 * 1) Write reg 13 // DEVAD 954 * 2) Write reg 14 // MMD Address 955 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 956 * 3) Write reg 14 // Write MMD data 957 */ 958 static void phy_write_mmd_indirect(struct mii_bus *bus, int prtad, int devad, 959 int addr, u32 data) 960 { 961 mmd_phy_indirect(bus, prtad, devad, addr); 962 963 /* Write the data into MMD's selected register */ 964 bus->write(bus, addr, MII_MMD_DATA, data); 965 } 966 967 /** 968 * phy_init_eee - init and check the EEE feature 969 * @phydev: target phy_device struct 970 * @clk_stop_enable: PHY may stop the clock during LPI 971 * 972 * Description: it checks if the Energy-Efficient Ethernet (EEE) 973 * is supported by looking at the MMD registers 3.20 and 7.60/61 974 * and it programs the MMD register 3.0 setting the "Clock stop enable" 975 * bit if required. 976 */ 977 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 978 { 979 /* According to 802.3az,the EEE is supported only in full duplex-mode. 980 * Also EEE feature is active when core is operating with MII, GMII 981 * or RGMII. 982 */ 983 if ((phydev->duplex == DUPLEX_FULL) && 984 ((phydev->interface == PHY_INTERFACE_MODE_MII) || 985 (phydev->interface == PHY_INTERFACE_MODE_GMII) || 986 (phydev->interface == PHY_INTERFACE_MODE_RGMII))) { 987 int eee_lp, eee_cap, eee_adv; 988 u32 lp, cap, adv; 989 int status; 990 unsigned int idx; 991 992 /* Read phy status to properly get the right settings */ 993 status = phy_read_status(phydev); 994 if (status) 995 return status; 996 997 /* First check if the EEE ability is supported */ 998 eee_cap = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE, 999 MDIO_MMD_PCS, phydev->addr); 1000 if (eee_cap < 0) 1001 return eee_cap; 1002 1003 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap); 1004 if (!cap) 1005 return -EPROTONOSUPPORT; 1006 1007 /* Check which link settings negotiated and verify it in 1008 * the EEE advertising registers. 1009 */ 1010 eee_lp = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE, 1011 MDIO_MMD_AN, phydev->addr); 1012 if (eee_lp < 0) 1013 return eee_lp; 1014 1015 eee_adv = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, 1016 MDIO_MMD_AN, phydev->addr); 1017 if (eee_adv < 0) 1018 return eee_adv; 1019 1020 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv); 1021 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp); 1022 idx = phy_find_setting(phydev->speed, phydev->duplex); 1023 if (!(lp & adv & settings[idx].setting)) 1024 return -EPROTONOSUPPORT; 1025 1026 if (clk_stop_enable) { 1027 /* Configure the PHY to stop receiving xMII 1028 * clock while it is signaling LPI. 1029 */ 1030 int val = phy_read_mmd_indirect(phydev->bus, MDIO_CTRL1, 1031 MDIO_MMD_PCS, 1032 phydev->addr); 1033 if (val < 0) 1034 return val; 1035 1036 val |= MDIO_PCS_CTRL1_CLKSTOP_EN; 1037 phy_write_mmd_indirect(phydev->bus, MDIO_CTRL1, 1038 MDIO_MMD_PCS, phydev->addr, val); 1039 } 1040 1041 return 0; /* EEE supported */ 1042 } 1043 1044 return -EPROTONOSUPPORT; 1045 } 1046 EXPORT_SYMBOL(phy_init_eee); 1047 1048 /** 1049 * phy_get_eee_err - report the EEE wake error count 1050 * @phydev: target phy_device struct 1051 * 1052 * Description: it is to report the number of time where the PHY 1053 * failed to complete its normal wake sequence. 1054 */ 1055 int phy_get_eee_err(struct phy_device *phydev) 1056 { 1057 return phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_WK_ERR, 1058 MDIO_MMD_PCS, phydev->addr); 1059 } 1060 EXPORT_SYMBOL(phy_get_eee_err); 1061 1062 /** 1063 * phy_ethtool_get_eee - get EEE supported and status 1064 * @phydev: target phy_device struct 1065 * @data: ethtool_eee data 1066 * 1067 * Description: it reportes the Supported/Advertisement/LP Advertisement 1068 * capabilities. 1069 */ 1070 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data) 1071 { 1072 int val; 1073 1074 /* Get Supported EEE */ 1075 val = phy_read_mmd_indirect(phydev->bus, MDIO_PCS_EEE_ABLE, 1076 MDIO_MMD_PCS, phydev->addr); 1077 if (val < 0) 1078 return val; 1079 data->supported = mmd_eee_cap_to_ethtool_sup_t(val); 1080 1081 /* Get advertisement EEE */ 1082 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, 1083 MDIO_MMD_AN, phydev->addr); 1084 if (val < 0) 1085 return val; 1086 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1087 1088 /* Get LP advertisement EEE */ 1089 val = phy_read_mmd_indirect(phydev->bus, MDIO_AN_EEE_LPABLE, 1090 MDIO_MMD_AN, phydev->addr); 1091 if (val < 0) 1092 return val; 1093 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1094 1095 return 0; 1096 } 1097 EXPORT_SYMBOL(phy_ethtool_get_eee); 1098 1099 /** 1100 * phy_ethtool_set_eee - set EEE supported and status 1101 * @phydev: target phy_device struct 1102 * @data: ethtool_eee data 1103 * 1104 * Description: it is to program the Advertisement EEE register. 1105 */ 1106 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data) 1107 { 1108 int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised); 1109 1110 phy_write_mmd_indirect(phydev->bus, MDIO_AN_EEE_ADV, MDIO_MMD_AN, 1111 phydev->addr, val); 1112 1113 return 0; 1114 } 1115 EXPORT_SYMBOL(phy_ethtool_set_eee); 1116 1117 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1118 { 1119 if (phydev->drv->set_wol) 1120 return phydev->drv->set_wol(phydev, wol); 1121 1122 return -EOPNOTSUPP; 1123 } 1124 EXPORT_SYMBOL(phy_ethtool_set_wol); 1125 1126 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1127 { 1128 if (phydev->drv->get_wol) 1129 phydev->drv->get_wol(phydev, wol); 1130 } 1131 EXPORT_SYMBOL(phy_ethtool_get_wol); 1132