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 = SPEED_10000, 142 .duplex = DUPLEX_FULL, 143 .setting = SUPPORTED_10000baseKR_Full, 144 }, 145 { 146 .speed = SPEED_10000, 147 .duplex = DUPLEX_FULL, 148 .setting = SUPPORTED_10000baseKX4_Full, 149 }, 150 { 151 .speed = SPEED_10000, 152 .duplex = DUPLEX_FULL, 153 .setting = SUPPORTED_10000baseT_Full, 154 }, 155 { 156 .speed = SPEED_2500, 157 .duplex = DUPLEX_FULL, 158 .setting = SUPPORTED_2500baseX_Full, 159 }, 160 { 161 .speed = SPEED_1000, 162 .duplex = DUPLEX_FULL, 163 .setting = SUPPORTED_1000baseKX_Full, 164 }, 165 { 166 .speed = SPEED_1000, 167 .duplex = DUPLEX_FULL, 168 .setting = SUPPORTED_1000baseT_Full, 169 }, 170 { 171 .speed = SPEED_1000, 172 .duplex = DUPLEX_HALF, 173 .setting = SUPPORTED_1000baseT_Half, 174 }, 175 { 176 .speed = SPEED_100, 177 .duplex = DUPLEX_FULL, 178 .setting = SUPPORTED_100baseT_Full, 179 }, 180 { 181 .speed = SPEED_100, 182 .duplex = DUPLEX_HALF, 183 .setting = SUPPORTED_100baseT_Half, 184 }, 185 { 186 .speed = SPEED_10, 187 .duplex = DUPLEX_FULL, 188 .setting = SUPPORTED_10baseT_Full, 189 }, 190 { 191 .speed = SPEED_10, 192 .duplex = DUPLEX_HALF, 193 .setting = SUPPORTED_10baseT_Half, 194 }, 195 }; 196 197 #define MAX_NUM_SETTINGS ARRAY_SIZE(settings) 198 199 /** 200 * phy_find_setting - find a PHY settings array entry that matches speed & duplex 201 * @speed: speed to match 202 * @duplex: duplex to match 203 * 204 * Description: Searches the settings array for the setting which 205 * matches the desired speed and duplex, and returns the index 206 * of that setting. Returns the index of the last setting if 207 * none of the others match. 208 */ 209 static inline unsigned int phy_find_setting(int speed, int duplex) 210 { 211 unsigned int idx = 0; 212 213 while (idx < ARRAY_SIZE(settings) && 214 (settings[idx].speed != speed || settings[idx].duplex != duplex)) 215 idx++; 216 217 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 218 } 219 220 /** 221 * phy_find_valid - find a PHY setting that matches the requested features mask 222 * @idx: The first index in settings[] to search 223 * @features: A mask of the valid settings 224 * 225 * Description: Returns the index of the first valid setting less 226 * than or equal to the one pointed to by idx, as determined by 227 * the mask in features. Returns the index of the last setting 228 * if nothing else matches. 229 */ 230 static inline unsigned int phy_find_valid(unsigned int idx, u32 features) 231 { 232 while (idx < MAX_NUM_SETTINGS && !(settings[idx].setting & features)) 233 idx++; 234 235 return idx < MAX_NUM_SETTINGS ? idx : MAX_NUM_SETTINGS - 1; 236 } 237 238 /** 239 * phy_check_valid - check if there is a valid PHY setting which matches 240 * speed, duplex, and feature mask 241 * @speed: speed to match 242 * @duplex: duplex to match 243 * @features: A mask of the valid settings 244 * 245 * Description: Returns true if there is a valid setting, false otherwise. 246 */ 247 static inline bool phy_check_valid(int speed, int duplex, u32 features) 248 { 249 unsigned int idx; 250 251 idx = phy_find_valid(phy_find_setting(speed, duplex), features); 252 253 return settings[idx].speed == speed && settings[idx].duplex == duplex && 254 (settings[idx].setting & features); 255 } 256 257 /** 258 * phy_sanitize_settings - make sure the PHY is set to supported speed and duplex 259 * @phydev: the target phy_device struct 260 * 261 * Description: Make sure the PHY is set to supported speeds and 262 * duplexes. Drop down by one in this order: 1000/FULL, 263 * 1000/HALF, 100/FULL, 100/HALF, 10/FULL, 10/HALF. 264 */ 265 static void phy_sanitize_settings(struct phy_device *phydev) 266 { 267 u32 features = phydev->supported; 268 unsigned int idx; 269 270 /* Sanitize settings based on PHY capabilities */ 271 if ((features & SUPPORTED_Autoneg) == 0) 272 phydev->autoneg = AUTONEG_DISABLE; 273 274 idx = phy_find_valid(phy_find_setting(phydev->speed, phydev->duplex), 275 features); 276 277 phydev->speed = settings[idx].speed; 278 phydev->duplex = settings[idx].duplex; 279 } 280 281 /** 282 * phy_ethtool_sset - generic ethtool sset function, handles all the details 283 * @phydev: target phy_device struct 284 * @cmd: ethtool_cmd 285 * 286 * A few notes about parameter checking: 287 * - We don't set port or transceiver, so we don't care what they 288 * were set to. 289 * - phy_start_aneg() will make sure forced settings are sane, and 290 * choose the next best ones from the ones selected, so we don't 291 * care if ethtool tries to give us bad values. 292 */ 293 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd) 294 { 295 u32 speed = ethtool_cmd_speed(cmd); 296 297 if (cmd->phy_address != phydev->addr) 298 return -EINVAL; 299 300 /* We make sure that we don't pass unsupported values in to the PHY */ 301 cmd->advertising &= phydev->supported; 302 303 /* Verify the settings we care about. */ 304 if (cmd->autoneg != AUTONEG_ENABLE && cmd->autoneg != AUTONEG_DISABLE) 305 return -EINVAL; 306 307 if (cmd->autoneg == AUTONEG_ENABLE && cmd->advertising == 0) 308 return -EINVAL; 309 310 if (cmd->autoneg == AUTONEG_DISABLE && 311 ((speed != SPEED_1000 && 312 speed != SPEED_100 && 313 speed != SPEED_10) || 314 (cmd->duplex != DUPLEX_HALF && 315 cmd->duplex != DUPLEX_FULL))) 316 return -EINVAL; 317 318 phydev->autoneg = cmd->autoneg; 319 320 phydev->speed = speed; 321 322 phydev->advertising = cmd->advertising; 323 324 if (AUTONEG_ENABLE == cmd->autoneg) 325 phydev->advertising |= ADVERTISED_Autoneg; 326 else 327 phydev->advertising &= ~ADVERTISED_Autoneg; 328 329 phydev->duplex = cmd->duplex; 330 331 /* Restart the PHY */ 332 phy_start_aneg(phydev); 333 334 return 0; 335 } 336 EXPORT_SYMBOL(phy_ethtool_sset); 337 338 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd) 339 { 340 cmd->supported = phydev->supported; 341 342 cmd->advertising = phydev->advertising; 343 cmd->lp_advertising = phydev->lp_advertising; 344 345 ethtool_cmd_speed_set(cmd, phydev->speed); 346 cmd->duplex = phydev->duplex; 347 if (phydev->interface == PHY_INTERFACE_MODE_MOCA) 348 cmd->port = PORT_BNC; 349 else 350 cmd->port = PORT_MII; 351 cmd->phy_address = phydev->addr; 352 cmd->transceiver = phy_is_internal(phydev) ? 353 XCVR_INTERNAL : XCVR_EXTERNAL; 354 cmd->autoneg = phydev->autoneg; 355 356 return 0; 357 } 358 EXPORT_SYMBOL(phy_ethtool_gset); 359 360 /** 361 * phy_mii_ioctl - generic PHY MII ioctl interface 362 * @phydev: the phy_device struct 363 * @ifr: &struct ifreq for socket ioctl's 364 * @cmd: ioctl cmd to execute 365 * 366 * Note that this function is currently incompatible with the 367 * PHYCONTROL layer. It changes registers without regard to 368 * current state. Use at own risk. 369 */ 370 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd) 371 { 372 struct mii_ioctl_data *mii_data = if_mii(ifr); 373 u16 val = mii_data->val_in; 374 bool change_autoneg = false; 375 376 switch (cmd) { 377 case SIOCGMIIPHY: 378 mii_data->phy_id = phydev->addr; 379 /* fall through */ 380 381 case SIOCGMIIREG: 382 mii_data->val_out = mdiobus_read(phydev->bus, mii_data->phy_id, 383 mii_data->reg_num); 384 return 0; 385 386 case SIOCSMIIREG: 387 if (mii_data->phy_id == phydev->addr) { 388 switch (mii_data->reg_num) { 389 case MII_BMCR: 390 if ((val & (BMCR_RESET | BMCR_ANENABLE)) == 0) { 391 if (phydev->autoneg == AUTONEG_ENABLE) 392 change_autoneg = true; 393 phydev->autoneg = AUTONEG_DISABLE; 394 if (val & BMCR_FULLDPLX) 395 phydev->duplex = DUPLEX_FULL; 396 else 397 phydev->duplex = DUPLEX_HALF; 398 if (val & BMCR_SPEED1000) 399 phydev->speed = SPEED_1000; 400 else if (val & BMCR_SPEED100) 401 phydev->speed = SPEED_100; 402 else phydev->speed = SPEED_10; 403 } 404 else { 405 if (phydev->autoneg == AUTONEG_DISABLE) 406 change_autoneg = true; 407 phydev->autoneg = AUTONEG_ENABLE; 408 } 409 break; 410 case MII_ADVERTISE: 411 phydev->advertising = mii_adv_to_ethtool_adv_t(val); 412 change_autoneg = true; 413 break; 414 default: 415 /* do nothing */ 416 break; 417 } 418 } 419 420 mdiobus_write(phydev->bus, mii_data->phy_id, 421 mii_data->reg_num, val); 422 423 if (mii_data->reg_num == MII_BMCR && 424 val & BMCR_RESET) 425 return phy_init_hw(phydev); 426 427 if (change_autoneg) 428 return phy_start_aneg(phydev); 429 430 return 0; 431 432 case SIOCSHWTSTAMP: 433 if (phydev->drv->hwtstamp) 434 return phydev->drv->hwtstamp(phydev, ifr); 435 /* fall through */ 436 437 default: 438 return -EOPNOTSUPP; 439 } 440 } 441 EXPORT_SYMBOL(phy_mii_ioctl); 442 443 /** 444 * phy_start_aneg - start auto-negotiation for this PHY device 445 * @phydev: the phy_device struct 446 * 447 * Description: Sanitizes the settings (if we're not autonegotiating 448 * them), and then calls the driver's config_aneg function. 449 * If the PHYCONTROL Layer is operating, we change the state to 450 * reflect the beginning of Auto-negotiation or forcing. 451 */ 452 int phy_start_aneg(struct phy_device *phydev) 453 { 454 int err; 455 456 mutex_lock(&phydev->lock); 457 458 if (AUTONEG_DISABLE == phydev->autoneg) 459 phy_sanitize_settings(phydev); 460 461 /* Invalidate LP advertising flags */ 462 phydev->lp_advertising = 0; 463 464 err = phydev->drv->config_aneg(phydev); 465 if (err < 0) 466 goto out_unlock; 467 468 if (phydev->state != PHY_HALTED) { 469 if (AUTONEG_ENABLE == phydev->autoneg) { 470 phydev->state = PHY_AN; 471 phydev->link_timeout = PHY_AN_TIMEOUT; 472 } else { 473 phydev->state = PHY_FORCING; 474 phydev->link_timeout = PHY_FORCE_TIMEOUT; 475 } 476 } 477 478 out_unlock: 479 mutex_unlock(&phydev->lock); 480 return err; 481 } 482 EXPORT_SYMBOL(phy_start_aneg); 483 484 /** 485 * phy_start_machine - start PHY state machine tracking 486 * @phydev: the phy_device struct 487 * 488 * Description: The PHY infrastructure can run a state machine 489 * which tracks whether the PHY is starting up, negotiating, 490 * etc. This function starts the timer which tracks the state 491 * of the PHY. If you want to maintain your own state machine, 492 * do not call this function. 493 */ 494 void phy_start_machine(struct phy_device *phydev) 495 { 496 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, HZ); 497 } 498 499 /** 500 * phy_stop_machine - stop the PHY state machine tracking 501 * @phydev: target phy_device struct 502 * 503 * Description: Stops the state machine timer, sets the state to UP 504 * (unless it wasn't up yet). This function must be called BEFORE 505 * phy_detach. 506 */ 507 void phy_stop_machine(struct phy_device *phydev) 508 { 509 cancel_delayed_work_sync(&phydev->state_queue); 510 511 mutex_lock(&phydev->lock); 512 if (phydev->state > PHY_UP) 513 phydev->state = PHY_UP; 514 mutex_unlock(&phydev->lock); 515 } 516 517 /** 518 * phy_error - enter HALTED state for this PHY device 519 * @phydev: target phy_device struct 520 * 521 * Moves the PHY to the HALTED state in response to a read 522 * or write error, and tells the controller the link is down. 523 * Must not be called from interrupt context, or while the 524 * phydev->lock is held. 525 */ 526 static void phy_error(struct phy_device *phydev) 527 { 528 mutex_lock(&phydev->lock); 529 phydev->state = PHY_HALTED; 530 mutex_unlock(&phydev->lock); 531 } 532 533 /** 534 * phy_interrupt - PHY interrupt handler 535 * @irq: interrupt line 536 * @phy_dat: phy_device pointer 537 * 538 * Description: When a PHY interrupt occurs, the handler disables 539 * interrupts, and schedules a work task to clear the interrupt. 540 */ 541 static irqreturn_t phy_interrupt(int irq, void *phy_dat) 542 { 543 struct phy_device *phydev = phy_dat; 544 545 if (PHY_HALTED == phydev->state) 546 return IRQ_NONE; /* It can't be ours. */ 547 548 /* The MDIO bus is not allowed to be written in interrupt 549 * context, so we need to disable the irq here. A work 550 * queue will write the PHY to disable and clear the 551 * interrupt, and then reenable the irq line. 552 */ 553 disable_irq_nosync(irq); 554 atomic_inc(&phydev->irq_disable); 555 556 queue_work(system_power_efficient_wq, &phydev->phy_queue); 557 558 return IRQ_HANDLED; 559 } 560 561 /** 562 * phy_enable_interrupts - Enable the interrupts from the PHY side 563 * @phydev: target phy_device struct 564 */ 565 static int phy_enable_interrupts(struct phy_device *phydev) 566 { 567 int err = phy_clear_interrupt(phydev); 568 569 if (err < 0) 570 return err; 571 572 return phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 573 } 574 575 /** 576 * phy_disable_interrupts - Disable the PHY interrupts from the PHY side 577 * @phydev: target phy_device struct 578 */ 579 static int phy_disable_interrupts(struct phy_device *phydev) 580 { 581 int err; 582 583 /* Disable PHY interrupts */ 584 err = phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 585 if (err) 586 goto phy_err; 587 588 /* Clear the interrupt */ 589 err = phy_clear_interrupt(phydev); 590 if (err) 591 goto phy_err; 592 593 return 0; 594 595 phy_err: 596 phy_error(phydev); 597 598 return err; 599 } 600 601 /** 602 * phy_start_interrupts - request and enable interrupts for a PHY device 603 * @phydev: target phy_device struct 604 * 605 * Description: Request the interrupt for the given PHY. 606 * If this fails, then we set irq to PHY_POLL. 607 * Otherwise, we enable the interrupts in the PHY. 608 * This should only be called with a valid IRQ number. 609 * Returns 0 on success or < 0 on error. 610 */ 611 int phy_start_interrupts(struct phy_device *phydev) 612 { 613 atomic_set(&phydev->irq_disable, 0); 614 if (request_irq(phydev->irq, phy_interrupt, 0, "phy_interrupt", 615 phydev) < 0) { 616 pr_warn("%s: Can't get IRQ %d (PHY)\n", 617 phydev->bus->name, phydev->irq); 618 phydev->irq = PHY_POLL; 619 return 0; 620 } 621 622 return phy_enable_interrupts(phydev); 623 } 624 EXPORT_SYMBOL(phy_start_interrupts); 625 626 /** 627 * phy_stop_interrupts - disable interrupts from a PHY device 628 * @phydev: target phy_device struct 629 */ 630 int phy_stop_interrupts(struct phy_device *phydev) 631 { 632 int err = phy_disable_interrupts(phydev); 633 634 if (err) 635 phy_error(phydev); 636 637 free_irq(phydev->irq, phydev); 638 639 /* Cannot call flush_scheduled_work() here as desired because 640 * of rtnl_lock(), but we do not really care about what would 641 * be done, except from enable_irq(), so cancel any work 642 * possibly pending and take care of the matter below. 643 */ 644 cancel_work_sync(&phydev->phy_queue); 645 /* If work indeed has been cancelled, disable_irq() will have 646 * been left unbalanced from phy_interrupt() and enable_irq() 647 * has to be called so that other devices on the line work. 648 */ 649 while (atomic_dec_return(&phydev->irq_disable) >= 0) 650 enable_irq(phydev->irq); 651 652 return err; 653 } 654 EXPORT_SYMBOL(phy_stop_interrupts); 655 656 /** 657 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes 658 * @work: work_struct that describes the work to be done 659 */ 660 void phy_change(struct work_struct *work) 661 { 662 struct phy_device *phydev = 663 container_of(work, struct phy_device, phy_queue); 664 665 if (phydev->drv->did_interrupt && 666 !phydev->drv->did_interrupt(phydev)) 667 goto ignore; 668 669 if (phy_disable_interrupts(phydev)) 670 goto phy_err; 671 672 mutex_lock(&phydev->lock); 673 if ((PHY_RUNNING == phydev->state) || (PHY_NOLINK == phydev->state)) 674 phydev->state = PHY_CHANGELINK; 675 mutex_unlock(&phydev->lock); 676 677 atomic_dec(&phydev->irq_disable); 678 enable_irq(phydev->irq); 679 680 /* Reenable interrupts */ 681 if (PHY_HALTED != phydev->state && 682 phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED)) 683 goto irq_enable_err; 684 685 /* reschedule state queue work to run as soon as possible */ 686 cancel_delayed_work_sync(&phydev->state_queue); 687 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 0); 688 return; 689 690 ignore: 691 atomic_dec(&phydev->irq_disable); 692 enable_irq(phydev->irq); 693 return; 694 695 irq_enable_err: 696 disable_irq(phydev->irq); 697 atomic_inc(&phydev->irq_disable); 698 phy_err: 699 phy_error(phydev); 700 } 701 702 /** 703 * phy_stop - Bring down the PHY link, and stop checking the status 704 * @phydev: target phy_device struct 705 */ 706 void phy_stop(struct phy_device *phydev) 707 { 708 mutex_lock(&phydev->lock); 709 710 if (PHY_HALTED == phydev->state) 711 goto out_unlock; 712 713 if (phy_interrupt_is_valid(phydev)) { 714 /* Disable PHY Interrupts */ 715 phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED); 716 717 /* Clear any pending interrupts */ 718 phy_clear_interrupt(phydev); 719 } 720 721 phydev->state = PHY_HALTED; 722 723 out_unlock: 724 mutex_unlock(&phydev->lock); 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 EXPORT_SYMBOL(phy_stop); 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_start); 762 763 /** 764 * phy_state_machine - Handle the state machine 765 * @work: work_struct that describes the work to be done 766 */ 767 void phy_state_machine(struct work_struct *work) 768 { 769 struct delayed_work *dwork = to_delayed_work(work); 770 struct phy_device *phydev = 771 container_of(dwork, struct phy_device, state_queue); 772 bool needs_aneg = false, do_suspend = false, do_resume = false; 773 int err = 0; 774 775 mutex_lock(&phydev->lock); 776 777 if (phydev->drv->link_change_notify) 778 phydev->drv->link_change_notify(phydev); 779 780 switch (phydev->state) { 781 case PHY_DOWN: 782 case PHY_STARTING: 783 case PHY_READY: 784 case PHY_PENDING: 785 break; 786 case PHY_UP: 787 needs_aneg = true; 788 789 phydev->link_timeout = PHY_AN_TIMEOUT; 790 791 break; 792 case PHY_AN: 793 err = phy_read_status(phydev); 794 if (err < 0) 795 break; 796 797 /* If the link is down, give up on negotiation for now */ 798 if (!phydev->link) { 799 phydev->state = PHY_NOLINK; 800 netif_carrier_off(phydev->attached_dev); 801 phydev->adjust_link(phydev->attached_dev); 802 break; 803 } 804 805 /* Check if negotiation is done. Break 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 needs_aneg = true; 818 break; 819 case PHY_NOLINK: 820 err = phy_read_status(phydev); 821 if (err) 822 break; 823 824 if (phydev->link) { 825 if (AUTONEG_ENABLE == phydev->autoneg) { 826 err = phy_aneg_done(phydev); 827 if (err < 0) 828 break; 829 830 if (!err) { 831 phydev->state = PHY_AN; 832 phydev->link_timeout = PHY_AN_TIMEOUT; 833 break; 834 } 835 } 836 phydev->state = PHY_RUNNING; 837 netif_carrier_on(phydev->attached_dev); 838 phydev->adjust_link(phydev->attached_dev); 839 } 840 break; 841 case PHY_FORCING: 842 err = genphy_update_link(phydev); 843 if (err) 844 break; 845 846 if (phydev->link) { 847 phydev->state = PHY_RUNNING; 848 netif_carrier_on(phydev->attached_dev); 849 } else { 850 if (0 == phydev->link_timeout--) 851 needs_aneg = true; 852 } 853 854 phydev->adjust_link(phydev->attached_dev); 855 break; 856 case PHY_RUNNING: 857 /* Only register a CHANGE if we are 858 * polling or ignoring interrupts 859 */ 860 if (!phy_interrupt_is_valid(phydev)) 861 phydev->state = PHY_CHANGELINK; 862 break; 863 case PHY_CHANGELINK: 864 err = phy_read_status(phydev); 865 if (err) 866 break; 867 868 if (phydev->link) { 869 phydev->state = PHY_RUNNING; 870 netif_carrier_on(phydev->attached_dev); 871 } else { 872 phydev->state = PHY_NOLINK; 873 netif_carrier_off(phydev->attached_dev); 874 } 875 876 phydev->adjust_link(phydev->attached_dev); 877 878 if (phy_interrupt_is_valid(phydev)) 879 err = phy_config_interrupt(phydev, 880 PHY_INTERRUPT_ENABLED); 881 break; 882 case PHY_HALTED: 883 if (phydev->link) { 884 phydev->link = 0; 885 netif_carrier_off(phydev->attached_dev); 886 phydev->adjust_link(phydev->attached_dev); 887 do_suspend = true; 888 } 889 break; 890 case PHY_RESUMING: 891 err = phy_clear_interrupt(phydev); 892 if (err) 893 break; 894 895 err = phy_config_interrupt(phydev, PHY_INTERRUPT_ENABLED); 896 if (err) 897 break; 898 899 if (AUTONEG_ENABLE == phydev->autoneg) { 900 err = phy_aneg_done(phydev); 901 if (err < 0) 902 break; 903 904 /* err > 0 if AN is done. 905 * Otherwise, it's 0, and we're still waiting for AN 906 */ 907 if (err > 0) { 908 err = phy_read_status(phydev); 909 if (err) 910 break; 911 912 if (phydev->link) { 913 phydev->state = PHY_RUNNING; 914 netif_carrier_on(phydev->attached_dev); 915 } else { 916 phydev->state = PHY_NOLINK; 917 } 918 phydev->adjust_link(phydev->attached_dev); 919 } else { 920 phydev->state = PHY_AN; 921 phydev->link_timeout = PHY_AN_TIMEOUT; 922 } 923 } else { 924 err = phy_read_status(phydev); 925 if (err) 926 break; 927 928 if (phydev->link) { 929 phydev->state = PHY_RUNNING; 930 netif_carrier_on(phydev->attached_dev); 931 } else { 932 phydev->state = PHY_NOLINK; 933 } 934 phydev->adjust_link(phydev->attached_dev); 935 } 936 do_resume = true; 937 break; 938 } 939 940 mutex_unlock(&phydev->lock); 941 942 if (needs_aneg) 943 err = phy_start_aneg(phydev); 944 else if (do_suspend) 945 phy_suspend(phydev); 946 else if (do_resume) 947 phy_resume(phydev); 948 949 if (err < 0) 950 phy_error(phydev); 951 952 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 953 PHY_STATE_TIME * HZ); 954 } 955 956 void phy_mac_interrupt(struct phy_device *phydev, int new_link) 957 { 958 cancel_work_sync(&phydev->phy_queue); 959 phydev->link = new_link; 960 schedule_work(&phydev->phy_queue); 961 } 962 EXPORT_SYMBOL(phy_mac_interrupt); 963 964 static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad, 965 int addr) 966 { 967 /* Write the desired MMD Devad */ 968 bus->write(bus, addr, MII_MMD_CTRL, devad); 969 970 /* Write the desired MMD register address */ 971 bus->write(bus, addr, MII_MMD_DATA, prtad); 972 973 /* Select the Function : DATA with no post increment */ 974 bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR)); 975 } 976 977 /** 978 * phy_read_mmd_indirect - reads data from the MMD registers 979 * @phydev: The PHY device bus 980 * @prtad: MMD Address 981 * @devad: MMD DEVAD 982 * @addr: PHY address on the MII bus 983 * 984 * Description: it reads data from the MMD registers (clause 22 to access to 985 * clause 45) of the specified phy address. 986 * To read these register we have: 987 * 1) Write reg 13 // DEVAD 988 * 2) Write reg 14 // MMD Address 989 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 990 * 3) Read reg 14 // Read MMD data 991 */ 992 int phy_read_mmd_indirect(struct phy_device *phydev, int prtad, 993 int devad, int addr) 994 { 995 struct phy_driver *phydrv = phydev->drv; 996 int value = -1; 997 998 if (phydrv->read_mmd_indirect == NULL) { 999 mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1000 1001 /* Read the content of the MMD's selected register */ 1002 value = phydev->bus->read(phydev->bus, addr, MII_MMD_DATA); 1003 } else { 1004 value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr); 1005 } 1006 return value; 1007 } 1008 EXPORT_SYMBOL(phy_read_mmd_indirect); 1009 1010 /** 1011 * phy_write_mmd_indirect - writes data to the MMD registers 1012 * @phydev: The PHY device 1013 * @prtad: MMD Address 1014 * @devad: MMD DEVAD 1015 * @addr: PHY address on the MII bus 1016 * @data: data to write in the MMD register 1017 * 1018 * Description: Write data from the MMD registers of the specified 1019 * phy address. 1020 * To write these register we have: 1021 * 1) Write reg 13 // DEVAD 1022 * 2) Write reg 14 // MMD Address 1023 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 1024 * 3) Write reg 14 // Write MMD data 1025 */ 1026 void phy_write_mmd_indirect(struct phy_device *phydev, int prtad, 1027 int devad, int addr, u32 data) 1028 { 1029 struct phy_driver *phydrv = phydev->drv; 1030 1031 if (phydrv->write_mmd_indirect == NULL) { 1032 mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1033 1034 /* Write the data into MMD's selected register */ 1035 phydev->bus->write(phydev->bus, addr, MII_MMD_DATA, data); 1036 } else { 1037 phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data); 1038 } 1039 } 1040 EXPORT_SYMBOL(phy_write_mmd_indirect); 1041 1042 /** 1043 * phy_init_eee - init and check the EEE feature 1044 * @phydev: target phy_device struct 1045 * @clk_stop_enable: PHY may stop the clock during LPI 1046 * 1047 * Description: it checks if the Energy-Efficient Ethernet (EEE) 1048 * is supported by looking at the MMD registers 3.20 and 7.60/61 1049 * and it programs the MMD register 3.0 setting the "Clock stop enable" 1050 * bit if required. 1051 */ 1052 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 1053 { 1054 /* According to 802.3az,the EEE is supported only in full duplex-mode. 1055 * Also EEE feature is active when core is operating with MII, GMII 1056 * or RGMII. Internal PHYs are also allowed to proceed and should 1057 * return an error if they do not support EEE. 1058 */ 1059 if ((phydev->duplex == DUPLEX_FULL) && 1060 ((phydev->interface == PHY_INTERFACE_MODE_MII) || 1061 (phydev->interface == PHY_INTERFACE_MODE_GMII) || 1062 (phydev->interface == PHY_INTERFACE_MODE_RGMII) || 1063 phy_is_internal(phydev))) { 1064 int eee_lp, eee_cap, eee_adv; 1065 u32 lp, cap, adv; 1066 int status; 1067 1068 /* Read phy status to properly get the right settings */ 1069 status = phy_read_status(phydev); 1070 if (status) 1071 return status; 1072 1073 /* First check if the EEE ability is supported */ 1074 eee_cap = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE, 1075 MDIO_MMD_PCS, phydev->addr); 1076 if (eee_cap <= 0) 1077 goto eee_exit_err; 1078 1079 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap); 1080 if (!cap) 1081 goto eee_exit_err; 1082 1083 /* Check which link settings negotiated and verify it in 1084 * the EEE advertising registers. 1085 */ 1086 eee_lp = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE, 1087 MDIO_MMD_AN, phydev->addr); 1088 if (eee_lp <= 0) 1089 goto eee_exit_err; 1090 1091 eee_adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, 1092 MDIO_MMD_AN, phydev->addr); 1093 if (eee_adv <= 0) 1094 goto eee_exit_err; 1095 1096 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv); 1097 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp); 1098 if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv)) 1099 goto eee_exit_err; 1100 1101 if (clk_stop_enable) { 1102 /* Configure the PHY to stop receiving xMII 1103 * clock while it is signaling LPI. 1104 */ 1105 int val = phy_read_mmd_indirect(phydev, MDIO_CTRL1, 1106 MDIO_MMD_PCS, 1107 phydev->addr); 1108 if (val < 0) 1109 return val; 1110 1111 val |= MDIO_PCS_CTRL1_CLKSTOP_EN; 1112 phy_write_mmd_indirect(phydev, MDIO_CTRL1, 1113 MDIO_MMD_PCS, phydev->addr, 1114 val); 1115 } 1116 1117 return 0; /* EEE supported */ 1118 } 1119 eee_exit_err: 1120 return -EPROTONOSUPPORT; 1121 } 1122 EXPORT_SYMBOL(phy_init_eee); 1123 1124 /** 1125 * phy_get_eee_err - report the EEE wake error count 1126 * @phydev: target phy_device struct 1127 * 1128 * Description: it is to report the number of time where the PHY 1129 * failed to complete its normal wake sequence. 1130 */ 1131 int phy_get_eee_err(struct phy_device *phydev) 1132 { 1133 return phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_WK_ERR, 1134 MDIO_MMD_PCS, phydev->addr); 1135 } 1136 EXPORT_SYMBOL(phy_get_eee_err); 1137 1138 /** 1139 * phy_ethtool_get_eee - get EEE supported and status 1140 * @phydev: target phy_device struct 1141 * @data: ethtool_eee data 1142 * 1143 * Description: it reportes the Supported/Advertisement/LP Advertisement 1144 * capabilities. 1145 */ 1146 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data) 1147 { 1148 int val; 1149 1150 /* Get Supported EEE */ 1151 val = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE, 1152 MDIO_MMD_PCS, phydev->addr); 1153 if (val < 0) 1154 return val; 1155 data->supported = mmd_eee_cap_to_ethtool_sup_t(val); 1156 1157 /* Get advertisement EEE */ 1158 val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, 1159 MDIO_MMD_AN, phydev->addr); 1160 if (val < 0) 1161 return val; 1162 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1163 1164 /* Get LP advertisement EEE */ 1165 val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE, 1166 MDIO_MMD_AN, phydev->addr); 1167 if (val < 0) 1168 return val; 1169 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1170 1171 return 0; 1172 } 1173 EXPORT_SYMBOL(phy_ethtool_get_eee); 1174 1175 /** 1176 * phy_ethtool_set_eee - set EEE supported and status 1177 * @phydev: target phy_device struct 1178 * @data: ethtool_eee data 1179 * 1180 * Description: it is to program the Advertisement EEE register. 1181 */ 1182 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data) 1183 { 1184 int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised); 1185 1186 phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN, 1187 phydev->addr, val); 1188 1189 return 0; 1190 } 1191 EXPORT_SYMBOL(phy_ethtool_set_eee); 1192 1193 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1194 { 1195 if (phydev->drv->set_wol) 1196 return phydev->drv->set_wol(phydev, wol); 1197 1198 return -EOPNOTSUPP; 1199 } 1200 EXPORT_SYMBOL(phy_ethtool_set_wol); 1201 1202 void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1203 { 1204 if (phydev->drv->get_wol) 1205 phydev->drv->get_wol(phydev, wol); 1206 } 1207 EXPORT_SYMBOL(phy_ethtool_get_wol); 1208