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