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 41static 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 */ 65void 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} 77EXPORT_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 */ 88static 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 */ 103static 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 */ 121static 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 */ 132struct phy_setting { 133 int speed; 134 int duplex; 135 u32 setting; 136}; 137 138/* A mapping of all SUPPORTED settings to speed/duplex */ 139static 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 */ 209static 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 */ 230static 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 */ 247static 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 */ 265static 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 */ 293int 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} 336EXPORT_SYMBOL(phy_ethtool_sset); 337 338int 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} 358EXPORT_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 */ 370int 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} 441EXPORT_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 */ 452int 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 478out_unlock: 479 mutex_unlock(&phydev->lock); 480 return err; 481} 482EXPORT_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 */ 494void 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 */ 507void 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 */ 526static 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 */ 541static 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 */ 565static 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 */ 579static 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 595phy_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 */ 611int 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} 624EXPORT_SYMBOL(phy_start_interrupts); 625 626/** 627 * phy_stop_interrupts - disable interrupts from a PHY device 628 * @phydev: target phy_device struct 629 */ 630int 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} 654EXPORT_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 */ 660void 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 690ignore: 691 atomic_dec(&phydev->irq_disable); 692 enable_irq(phydev->irq); 693 return; 694 695irq_enable_err: 696 disable_irq(phydev->irq); 697 atomic_inc(&phydev->irq_disable); 698phy_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 */ 706void 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 723out_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} 731EXPORT_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 */ 743void phy_start(struct phy_device *phydev) 744{ 745 bool do_resume = false; 746 int err = 0; 747 748 mutex_lock(&phydev->lock); 749 750 switch (phydev->state) { 751 case PHY_STARTING: 752 phydev->state = PHY_PENDING; 753 break; 754 case PHY_READY: 755 phydev->state = PHY_UP; 756 break; 757 case PHY_HALTED: 758 /* make sure interrupts are re-enabled for the PHY */ 759 err = phy_enable_interrupts(phydev); 760 if (err < 0) 761 break; 762 763 phydev->state = PHY_RESUMING; 764 do_resume = true; 765 break; 766 default: 767 break; 768 } 769 mutex_unlock(&phydev->lock); 770 771 /* if phy was suspended, bring the physical link up again */ 772 if (do_resume) 773 phy_resume(phydev); 774} 775EXPORT_SYMBOL(phy_start); 776 777/** 778 * phy_state_machine - Handle the state machine 779 * @work: work_struct that describes the work to be done 780 */ 781void phy_state_machine(struct work_struct *work) 782{ 783 struct delayed_work *dwork = to_delayed_work(work); 784 struct phy_device *phydev = 785 container_of(dwork, struct phy_device, state_queue); 786 bool needs_aneg = false, do_suspend = false; 787 int err = 0; 788 789 mutex_lock(&phydev->lock); 790 791 if (phydev->drv->link_change_notify) 792 phydev->drv->link_change_notify(phydev); 793 794 switch (phydev->state) { 795 case PHY_DOWN: 796 case PHY_STARTING: 797 case PHY_READY: 798 case PHY_PENDING: 799 break; 800 case PHY_UP: 801 needs_aneg = true; 802 803 phydev->link_timeout = PHY_AN_TIMEOUT; 804 805 break; 806 case PHY_AN: 807 err = phy_read_status(phydev); 808 if (err < 0) 809 break; 810 811 /* If the link is down, give up on negotiation for now */ 812 if (!phydev->link) { 813 phydev->state = PHY_NOLINK; 814 netif_carrier_off(phydev->attached_dev); 815 phydev->adjust_link(phydev->attached_dev); 816 break; 817 } 818 819 /* Check if negotiation is done. Break if there's an error */ 820 err = phy_aneg_done(phydev); 821 if (err < 0) 822 break; 823 824 /* If AN is done, we're running */ 825 if (err > 0) { 826 phydev->state = PHY_RUNNING; 827 netif_carrier_on(phydev->attached_dev); 828 phydev->adjust_link(phydev->attached_dev); 829 830 } else if (0 == phydev->link_timeout--) 831 needs_aneg = true; 832 break; 833 case PHY_NOLINK: 834 err = phy_read_status(phydev); 835 if (err) 836 break; 837 838 if (phydev->link) { 839 if (AUTONEG_ENABLE == phydev->autoneg) { 840 err = phy_aneg_done(phydev); 841 if (err < 0) 842 break; 843 844 if (!err) { 845 phydev->state = PHY_AN; 846 phydev->link_timeout = PHY_AN_TIMEOUT; 847 break; 848 } 849 } 850 phydev->state = PHY_RUNNING; 851 netif_carrier_on(phydev->attached_dev); 852 phydev->adjust_link(phydev->attached_dev); 853 } 854 break; 855 case PHY_FORCING: 856 err = genphy_update_link(phydev); 857 if (err) 858 break; 859 860 if (phydev->link) { 861 phydev->state = PHY_RUNNING; 862 netif_carrier_on(phydev->attached_dev); 863 } else { 864 if (0 == phydev->link_timeout--) 865 needs_aneg = true; 866 } 867 868 phydev->adjust_link(phydev->attached_dev); 869 break; 870 case PHY_RUNNING: 871 /* Only register a CHANGE if we are 872 * polling or ignoring interrupts 873 */ 874 if (!phy_interrupt_is_valid(phydev)) 875 phydev->state = PHY_CHANGELINK; 876 break; 877 case PHY_CHANGELINK: 878 err = phy_read_status(phydev); 879 if (err) 880 break; 881 882 if (phydev->link) { 883 phydev->state = PHY_RUNNING; 884 netif_carrier_on(phydev->attached_dev); 885 } else { 886 phydev->state = PHY_NOLINK; 887 netif_carrier_off(phydev->attached_dev); 888 } 889 890 phydev->adjust_link(phydev->attached_dev); 891 892 if (phy_interrupt_is_valid(phydev)) 893 err = phy_config_interrupt(phydev, 894 PHY_INTERRUPT_ENABLED); 895 break; 896 case PHY_HALTED: 897 if (phydev->link) { 898 phydev->link = 0; 899 netif_carrier_off(phydev->attached_dev); 900 phydev->adjust_link(phydev->attached_dev); 901 do_suspend = true; 902 } 903 break; 904 case PHY_RESUMING: 905 if (AUTONEG_ENABLE == phydev->autoneg) { 906 err = phy_aneg_done(phydev); 907 if (err < 0) 908 break; 909 910 /* err > 0 if AN is done. 911 * Otherwise, it's 0, and we're still waiting for AN 912 */ 913 if (err > 0) { 914 err = phy_read_status(phydev); 915 if (err) 916 break; 917 918 if (phydev->link) { 919 phydev->state = PHY_RUNNING; 920 netif_carrier_on(phydev->attached_dev); 921 } else { 922 phydev->state = PHY_NOLINK; 923 } 924 phydev->adjust_link(phydev->attached_dev); 925 } else { 926 phydev->state = PHY_AN; 927 phydev->link_timeout = PHY_AN_TIMEOUT; 928 } 929 } else { 930 err = phy_read_status(phydev); 931 if (err) 932 break; 933 934 if (phydev->link) { 935 phydev->state = PHY_RUNNING; 936 netif_carrier_on(phydev->attached_dev); 937 } else { 938 phydev->state = PHY_NOLINK; 939 } 940 phydev->adjust_link(phydev->attached_dev); 941 } 942 break; 943 } 944 945 mutex_unlock(&phydev->lock); 946 947 if (needs_aneg) 948 err = phy_start_aneg(phydev); 949 else if (do_suspend) 950 phy_suspend(phydev); 951 952 if (err < 0) 953 phy_error(phydev); 954 955 queue_delayed_work(system_power_efficient_wq, &phydev->state_queue, 956 PHY_STATE_TIME * HZ); 957} 958 959void phy_mac_interrupt(struct phy_device *phydev, int new_link) 960{ 961 cancel_work_sync(&phydev->phy_queue); 962 phydev->link = new_link; 963 schedule_work(&phydev->phy_queue); 964} 965EXPORT_SYMBOL(phy_mac_interrupt); 966 967static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad, 968 int addr) 969{ 970 /* Write the desired MMD Devad */ 971 bus->write(bus, addr, MII_MMD_CTRL, devad); 972 973 /* Write the desired MMD register address */ 974 bus->write(bus, addr, MII_MMD_DATA, prtad); 975 976 /* Select the Function : DATA with no post increment */ 977 bus->write(bus, addr, MII_MMD_CTRL, (devad | MII_MMD_CTRL_NOINCR)); 978} 979 980/** 981 * phy_read_mmd_indirect - reads data from the MMD registers 982 * @phydev: The PHY device bus 983 * @prtad: MMD Address 984 * @devad: MMD DEVAD 985 * @addr: PHY address on the MII bus 986 * 987 * Description: it reads data from the MMD registers (clause 22 to access to 988 * clause 45) of the specified phy address. 989 * To read these register we have: 990 * 1) Write reg 13 // DEVAD 991 * 2) Write reg 14 // MMD Address 992 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 993 * 3) Read reg 14 // Read MMD data 994 */ 995int phy_read_mmd_indirect(struct phy_device *phydev, int prtad, 996 int devad, int addr) 997{ 998 struct phy_driver *phydrv = phydev->drv; 999 int value = -1; 1000 1001 if (phydrv->read_mmd_indirect == NULL) { 1002 mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1003 1004 /* Read the content of the MMD's selected register */ 1005 value = phydev->bus->read(phydev->bus, addr, MII_MMD_DATA); 1006 } else { 1007 value = phydrv->read_mmd_indirect(phydev, prtad, devad, addr); 1008 } 1009 return value; 1010} 1011EXPORT_SYMBOL(phy_read_mmd_indirect); 1012 1013/** 1014 * phy_write_mmd_indirect - writes data to the MMD registers 1015 * @phydev: The PHY device 1016 * @prtad: MMD Address 1017 * @devad: MMD DEVAD 1018 * @addr: PHY address on the MII bus 1019 * @data: data to write in the MMD register 1020 * 1021 * Description: Write data from the MMD registers of the specified 1022 * phy address. 1023 * To write these register we have: 1024 * 1) Write reg 13 // DEVAD 1025 * 2) Write reg 14 // MMD Address 1026 * 3) Write reg 13 // MMD Data Command for MMD DEVAD 1027 * 3) Write reg 14 // Write MMD data 1028 */ 1029void phy_write_mmd_indirect(struct phy_device *phydev, int prtad, 1030 int devad, int addr, u32 data) 1031{ 1032 struct phy_driver *phydrv = phydev->drv; 1033 1034 if (phydrv->write_mmd_indirect == NULL) { 1035 mmd_phy_indirect(phydev->bus, prtad, devad, addr); 1036 1037 /* Write the data into MMD's selected register */ 1038 phydev->bus->write(phydev->bus, addr, MII_MMD_DATA, data); 1039 } else { 1040 phydrv->write_mmd_indirect(phydev, prtad, devad, addr, data); 1041 } 1042} 1043EXPORT_SYMBOL(phy_write_mmd_indirect); 1044 1045/** 1046 * phy_init_eee - init and check the EEE feature 1047 * @phydev: target phy_device struct 1048 * @clk_stop_enable: PHY may stop the clock during LPI 1049 * 1050 * Description: it checks if the Energy-Efficient Ethernet (EEE) 1051 * is supported by looking at the MMD registers 3.20 and 7.60/61 1052 * and it programs the MMD register 3.0 setting the "Clock stop enable" 1053 * bit if required. 1054 */ 1055int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable) 1056{ 1057 /* According to 802.3az,the EEE is supported only in full duplex-mode. 1058 * Also EEE feature is active when core is operating with MII, GMII 1059 * or RGMII (all kinds). Internal PHYs are also allowed to proceed and 1060 * should return an error if they do not support EEE. 1061 */ 1062 if ((phydev->duplex == DUPLEX_FULL) && 1063 ((phydev->interface == PHY_INTERFACE_MODE_MII) || 1064 (phydev->interface == PHY_INTERFACE_MODE_GMII) || 1065 (phydev->interface >= PHY_INTERFACE_MODE_RGMII && 1066 phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID) || 1067 phy_is_internal(phydev))) { 1068 int eee_lp, eee_cap, eee_adv; 1069 u32 lp, cap, adv; 1070 int status; 1071 1072 /* Read phy status to properly get the right settings */ 1073 status = phy_read_status(phydev); 1074 if (status) 1075 return status; 1076 1077 /* First check if the EEE ability is supported */ 1078 eee_cap = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE, 1079 MDIO_MMD_PCS, phydev->addr); 1080 if (eee_cap <= 0) 1081 goto eee_exit_err; 1082 1083 cap = mmd_eee_cap_to_ethtool_sup_t(eee_cap); 1084 if (!cap) 1085 goto eee_exit_err; 1086 1087 /* Check which link settings negotiated and verify it in 1088 * the EEE advertising registers. 1089 */ 1090 eee_lp = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE, 1091 MDIO_MMD_AN, phydev->addr); 1092 if (eee_lp <= 0) 1093 goto eee_exit_err; 1094 1095 eee_adv = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, 1096 MDIO_MMD_AN, phydev->addr); 1097 if (eee_adv <= 0) 1098 goto eee_exit_err; 1099 1100 adv = mmd_eee_adv_to_ethtool_adv_t(eee_adv); 1101 lp = mmd_eee_adv_to_ethtool_adv_t(eee_lp); 1102 if (!phy_check_valid(phydev->speed, phydev->duplex, lp & adv)) 1103 goto eee_exit_err; 1104 1105 if (clk_stop_enable) { 1106 /* Configure the PHY to stop receiving xMII 1107 * clock while it is signaling LPI. 1108 */ 1109 int val = phy_read_mmd_indirect(phydev, MDIO_CTRL1, 1110 MDIO_MMD_PCS, 1111 phydev->addr); 1112 if (val < 0) 1113 return val; 1114 1115 val |= MDIO_PCS_CTRL1_CLKSTOP_EN; 1116 phy_write_mmd_indirect(phydev, MDIO_CTRL1, 1117 MDIO_MMD_PCS, phydev->addr, 1118 val); 1119 } 1120 1121 return 0; /* EEE supported */ 1122 } 1123eee_exit_err: 1124 return -EPROTONOSUPPORT; 1125} 1126EXPORT_SYMBOL(phy_init_eee); 1127 1128/** 1129 * phy_get_eee_err - report the EEE wake error count 1130 * @phydev: target phy_device struct 1131 * 1132 * Description: it is to report the number of time where the PHY 1133 * failed to complete its normal wake sequence. 1134 */ 1135int phy_get_eee_err(struct phy_device *phydev) 1136{ 1137 return phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_WK_ERR, 1138 MDIO_MMD_PCS, phydev->addr); 1139} 1140EXPORT_SYMBOL(phy_get_eee_err); 1141 1142/** 1143 * phy_ethtool_get_eee - get EEE supported and status 1144 * @phydev: target phy_device struct 1145 * @data: ethtool_eee data 1146 * 1147 * Description: it reportes the Supported/Advertisement/LP Advertisement 1148 * capabilities. 1149 */ 1150int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data) 1151{ 1152 int val; 1153 1154 /* Get Supported EEE */ 1155 val = phy_read_mmd_indirect(phydev, MDIO_PCS_EEE_ABLE, 1156 MDIO_MMD_PCS, phydev->addr); 1157 if (val < 0) 1158 return val; 1159 data->supported = mmd_eee_cap_to_ethtool_sup_t(val); 1160 1161 /* Get advertisement EEE */ 1162 val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_ADV, 1163 MDIO_MMD_AN, phydev->addr); 1164 if (val < 0) 1165 return val; 1166 data->advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1167 1168 /* Get LP advertisement EEE */ 1169 val = phy_read_mmd_indirect(phydev, MDIO_AN_EEE_LPABLE, 1170 MDIO_MMD_AN, phydev->addr); 1171 if (val < 0) 1172 return val; 1173 data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val); 1174 1175 return 0; 1176} 1177EXPORT_SYMBOL(phy_ethtool_get_eee); 1178 1179/** 1180 * phy_ethtool_set_eee - set EEE supported and status 1181 * @phydev: target phy_device struct 1182 * @data: ethtool_eee data 1183 * 1184 * Description: it is to program the Advertisement EEE register. 1185 */ 1186int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data) 1187{ 1188 int val = ethtool_adv_to_mmd_eee_adv_t(data->advertised); 1189 1190 phy_write_mmd_indirect(phydev, MDIO_AN_EEE_ADV, MDIO_MMD_AN, 1191 phydev->addr, val); 1192 1193 return 0; 1194} 1195EXPORT_SYMBOL(phy_ethtool_set_eee); 1196 1197int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1198{ 1199 if (phydev->drv->set_wol) 1200 return phydev->drv->set_wol(phydev, wol); 1201 1202 return -EOPNOTSUPP; 1203} 1204EXPORT_SYMBOL(phy_ethtool_set_wol); 1205 1206void phy_ethtool_get_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol) 1207{ 1208 if (phydev->drv->get_wol) 1209 phydev->drv->get_wol(phydev, wol); 1210} 1211EXPORT_SYMBOL(phy_ethtool_get_wol); 1212