1 /* 2 * Framework and drivers for configuring and reading different PHYs 3 * Based on code in sungem_phy.c and gianfar_phy.c 4 * 5 * Author: Andy Fleming 6 * 7 * Copyright (c) 2004 Freescale Semiconductor, Inc. 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 #ifndef __PHY_H 17 #define __PHY_H 18 19 #include <linux/compiler.h> 20 #include <linux/spinlock.h> 21 #include <linux/ethtool.h> 22 #include <linux/mdio.h> 23 #include <linux/mii.h> 24 #include <linux/module.h> 25 #include <linux/timer.h> 26 #include <linux/workqueue.h> 27 #include <linux/mod_devicetable.h> 28 29 #include <linux/atomic.h> 30 31 #define PHY_DEFAULT_FEATURES (SUPPORTED_Autoneg | \ 32 SUPPORTED_TP | \ 33 SUPPORTED_MII) 34 35 #define PHY_10BT_FEATURES (SUPPORTED_10baseT_Half | \ 36 SUPPORTED_10baseT_Full) 37 38 #define PHY_100BT_FEATURES (SUPPORTED_100baseT_Half | \ 39 SUPPORTED_100baseT_Full) 40 41 #define PHY_1000BT_FEATURES (SUPPORTED_1000baseT_Half | \ 42 SUPPORTED_1000baseT_Full) 43 44 #define PHY_BASIC_FEATURES (PHY_10BT_FEATURES | \ 45 PHY_100BT_FEATURES | \ 46 PHY_DEFAULT_FEATURES) 47 48 #define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES | \ 49 PHY_1000BT_FEATURES) 50 51 52 /* 53 * Set phydev->irq to PHY_POLL if interrupts are not supported, 54 * or not desired for this PHY. Set to PHY_IGNORE_INTERRUPT if 55 * the attached driver handles the interrupt 56 */ 57 #define PHY_POLL -1 58 #define PHY_IGNORE_INTERRUPT -2 59 60 #define PHY_HAS_INTERRUPT 0x00000001 61 #define PHY_IS_INTERNAL 0x00000002 62 #define MDIO_DEVICE_IS_PHY 0x80000000 63 64 /* Interface Mode definitions */ 65 typedef enum { 66 PHY_INTERFACE_MODE_NA, 67 PHY_INTERFACE_MODE_INTERNAL, 68 PHY_INTERFACE_MODE_MII, 69 PHY_INTERFACE_MODE_GMII, 70 PHY_INTERFACE_MODE_SGMII, 71 PHY_INTERFACE_MODE_TBI, 72 PHY_INTERFACE_MODE_REVMII, 73 PHY_INTERFACE_MODE_RMII, 74 PHY_INTERFACE_MODE_RGMII, 75 PHY_INTERFACE_MODE_RGMII_ID, 76 PHY_INTERFACE_MODE_RGMII_RXID, 77 PHY_INTERFACE_MODE_RGMII_TXID, 78 PHY_INTERFACE_MODE_RTBI, 79 PHY_INTERFACE_MODE_SMII, 80 PHY_INTERFACE_MODE_XGMII, 81 PHY_INTERFACE_MODE_MOCA, 82 PHY_INTERFACE_MODE_QSGMII, 83 PHY_INTERFACE_MODE_TRGMII, 84 PHY_INTERFACE_MODE_1000BASEX, 85 PHY_INTERFACE_MODE_2500BASEX, 86 PHY_INTERFACE_MODE_RXAUI, 87 PHY_INTERFACE_MODE_XAUI, 88 /* 10GBASE-KR, XFI, SFI - single lane 10G Serdes */ 89 PHY_INTERFACE_MODE_10GKR, 90 PHY_INTERFACE_MODE_MAX, 91 } phy_interface_t; 92 93 /** 94 * phy_supported_speeds - return all speeds currently supported by a phy device 95 * @phy: The phy device to return supported speeds of. 96 * @speeds: buffer to store supported speeds in. 97 * @size: size of speeds buffer. 98 * 99 * Description: Returns the number of supported speeds, and 100 * fills the speeds * buffer with the supported speeds. If speeds buffer is 101 * too small to contain * all currently supported speeds, will return as 102 * many speeds as can fit. 103 */ 104 unsigned int phy_supported_speeds(struct phy_device *phy, 105 unsigned int *speeds, 106 unsigned int size); 107 108 /** 109 * It maps 'enum phy_interface_t' found in include/linux/phy.h 110 * into the device tree binding of 'phy-mode', so that Ethernet 111 * device driver can get phy interface from device tree. 112 */ 113 static inline const char *phy_modes(phy_interface_t interface) 114 { 115 switch (interface) { 116 case PHY_INTERFACE_MODE_NA: 117 return ""; 118 case PHY_INTERFACE_MODE_INTERNAL: 119 return "internal"; 120 case PHY_INTERFACE_MODE_MII: 121 return "mii"; 122 case PHY_INTERFACE_MODE_GMII: 123 return "gmii"; 124 case PHY_INTERFACE_MODE_SGMII: 125 return "sgmii"; 126 case PHY_INTERFACE_MODE_TBI: 127 return "tbi"; 128 case PHY_INTERFACE_MODE_REVMII: 129 return "rev-mii"; 130 case PHY_INTERFACE_MODE_RMII: 131 return "rmii"; 132 case PHY_INTERFACE_MODE_RGMII: 133 return "rgmii"; 134 case PHY_INTERFACE_MODE_RGMII_ID: 135 return "rgmii-id"; 136 case PHY_INTERFACE_MODE_RGMII_RXID: 137 return "rgmii-rxid"; 138 case PHY_INTERFACE_MODE_RGMII_TXID: 139 return "rgmii-txid"; 140 case PHY_INTERFACE_MODE_RTBI: 141 return "rtbi"; 142 case PHY_INTERFACE_MODE_SMII: 143 return "smii"; 144 case PHY_INTERFACE_MODE_XGMII: 145 return "xgmii"; 146 case PHY_INTERFACE_MODE_MOCA: 147 return "moca"; 148 case PHY_INTERFACE_MODE_QSGMII: 149 return "qsgmii"; 150 case PHY_INTERFACE_MODE_TRGMII: 151 return "trgmii"; 152 case PHY_INTERFACE_MODE_1000BASEX: 153 return "1000base-x"; 154 case PHY_INTERFACE_MODE_2500BASEX: 155 return "2500base-x"; 156 case PHY_INTERFACE_MODE_RXAUI: 157 return "rxaui"; 158 case PHY_INTERFACE_MODE_XAUI: 159 return "xaui"; 160 case PHY_INTERFACE_MODE_10GKR: 161 return "10gbase-kr"; 162 default: 163 return "unknown"; 164 } 165 } 166 167 168 #define PHY_INIT_TIMEOUT 100000 169 #define PHY_STATE_TIME 1 170 #define PHY_FORCE_TIMEOUT 10 171 #define PHY_AN_TIMEOUT 10 172 173 #define PHY_MAX_ADDR 32 174 175 /* Used when trying to connect to a specific phy (mii bus id:phy device id) */ 176 #define PHY_ID_FMT "%s:%02x" 177 178 #define MII_BUS_ID_SIZE 61 179 180 /* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit 181 IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */ 182 #define MII_ADDR_C45 (1<<30) 183 184 struct device; 185 struct sk_buff; 186 187 /* 188 * The Bus class for PHYs. Devices which provide access to 189 * PHYs should register using this structure 190 */ 191 struct mii_bus { 192 struct module *owner; 193 const char *name; 194 char id[MII_BUS_ID_SIZE]; 195 void *priv; 196 int (*read)(struct mii_bus *bus, int addr, int regnum); 197 int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val); 198 int (*reset)(struct mii_bus *bus); 199 200 /* 201 * A lock to ensure that only one thing can read/write 202 * the MDIO bus at a time 203 */ 204 struct mutex mdio_lock; 205 206 struct device *parent; 207 enum { 208 MDIOBUS_ALLOCATED = 1, 209 MDIOBUS_REGISTERED, 210 MDIOBUS_UNREGISTERED, 211 MDIOBUS_RELEASED, 212 } state; 213 struct device dev; 214 215 /* list of all PHYs on bus */ 216 struct mdio_device *mdio_map[PHY_MAX_ADDR]; 217 218 /* PHY addresses to be ignored when probing */ 219 u32 phy_mask; 220 221 /* PHY addresses to ignore the TA/read failure */ 222 u32 phy_ignore_ta_mask; 223 224 /* 225 * An array of interrupts, each PHY's interrupt at the index 226 * matching its address 227 */ 228 int irq[PHY_MAX_ADDR]; 229 230 /* GPIO reset pulse width in microseconds */ 231 int reset_delay_us; 232 /* RESET GPIO descriptor pointer */ 233 struct gpio_desc *reset_gpiod; 234 }; 235 #define to_mii_bus(d) container_of(d, struct mii_bus, dev) 236 237 struct mii_bus *mdiobus_alloc_size(size_t); 238 static inline struct mii_bus *mdiobus_alloc(void) 239 { 240 return mdiobus_alloc_size(0); 241 } 242 243 int __mdiobus_register(struct mii_bus *bus, struct module *owner); 244 #define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE) 245 void mdiobus_unregister(struct mii_bus *bus); 246 void mdiobus_free(struct mii_bus *bus); 247 struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv); 248 static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev) 249 { 250 return devm_mdiobus_alloc_size(dev, 0); 251 } 252 253 void devm_mdiobus_free(struct device *dev, struct mii_bus *bus); 254 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr); 255 256 #define PHY_INTERRUPT_DISABLED 0x0 257 #define PHY_INTERRUPT_ENABLED 0x80000000 258 259 /* PHY state machine states: 260 * 261 * DOWN: PHY device and driver are not ready for anything. probe 262 * should be called if and only if the PHY is in this state, 263 * given that the PHY device exists. 264 * - PHY driver probe function will, depending on the PHY, set 265 * the state to STARTING or READY 266 * 267 * STARTING: PHY device is coming up, and the ethernet driver is 268 * not ready. PHY drivers may set this in the probe function. 269 * If they do, they are responsible for making sure the state is 270 * eventually set to indicate whether the PHY is UP or READY, 271 * depending on the state when the PHY is done starting up. 272 * - PHY driver will set the state to READY 273 * - start will set the state to PENDING 274 * 275 * READY: PHY is ready to send and receive packets, but the 276 * controller is not. By default, PHYs which do not implement 277 * probe will be set to this state by phy_probe(). If the PHY 278 * driver knows the PHY is ready, and the PHY state is STARTING, 279 * then it sets this STATE. 280 * - start will set the state to UP 281 * 282 * PENDING: PHY device is coming up, but the ethernet driver is 283 * ready. phy_start will set this state if the PHY state is 284 * STARTING. 285 * - PHY driver will set the state to UP when the PHY is ready 286 * 287 * UP: The PHY and attached device are ready to do work. 288 * Interrupts should be started here. 289 * - timer moves to AN 290 * 291 * AN: The PHY is currently negotiating the link state. Link is 292 * therefore down for now. phy_timer will set this state when it 293 * detects the state is UP. config_aneg will set this state 294 * whenever called with phydev->autoneg set to AUTONEG_ENABLE. 295 * - If autonegotiation finishes, but there's no link, it sets 296 * the state to NOLINK. 297 * - If aneg finishes with link, it sets the state to RUNNING, 298 * and calls adjust_link 299 * - If autonegotiation did not finish after an arbitrary amount 300 * of time, autonegotiation should be tried again if the PHY 301 * supports "magic" autonegotiation (back to AN) 302 * - If it didn't finish, and no magic_aneg, move to FORCING. 303 * 304 * NOLINK: PHY is up, but not currently plugged in. 305 * - If the timer notes that the link comes back, we move to RUNNING 306 * - config_aneg moves to AN 307 * - phy_stop moves to HALTED 308 * 309 * FORCING: PHY is being configured with forced settings 310 * - if link is up, move to RUNNING 311 * - If link is down, we drop to the next highest setting, and 312 * retry (FORCING) after a timeout 313 * - phy_stop moves to HALTED 314 * 315 * RUNNING: PHY is currently up, running, and possibly sending 316 * and/or receiving packets 317 * - timer will set CHANGELINK if we're polling (this ensures the 318 * link state is polled every other cycle of this state machine, 319 * which makes it every other second) 320 * - irq will set CHANGELINK 321 * - config_aneg will set AN 322 * - phy_stop moves to HALTED 323 * 324 * CHANGELINK: PHY experienced a change in link state 325 * - timer moves to RUNNING if link 326 * - timer moves to NOLINK if the link is down 327 * - phy_stop moves to HALTED 328 * 329 * HALTED: PHY is up, but no polling or interrupts are done. Or 330 * PHY is in an error state. 331 * 332 * - phy_start moves to RESUMING 333 * 334 * RESUMING: PHY was halted, but now wants to run again. 335 * - If we are forcing, or aneg is done, timer moves to RUNNING 336 * - If aneg is not done, timer moves to AN 337 * - phy_stop moves to HALTED 338 */ 339 enum phy_state { 340 PHY_DOWN = 0, 341 PHY_STARTING, 342 PHY_READY, 343 PHY_PENDING, 344 PHY_UP, 345 PHY_AN, 346 PHY_RUNNING, 347 PHY_NOLINK, 348 PHY_FORCING, 349 PHY_CHANGELINK, 350 PHY_HALTED, 351 PHY_RESUMING 352 }; 353 354 /** 355 * struct phy_c45_device_ids - 802.3-c45 Device Identifiers 356 * @devices_in_package: Bit vector of devices present. 357 * @device_ids: The device identifer for each present device. 358 */ 359 struct phy_c45_device_ids { 360 u32 devices_in_package; 361 u32 device_ids[8]; 362 }; 363 364 /* phy_device: An instance of a PHY 365 * 366 * drv: Pointer to the driver for this PHY instance 367 * phy_id: UID for this device found during discovery 368 * c45_ids: 802.3-c45 Device Identifers if is_c45. 369 * is_c45: Set to true if this phy uses clause 45 addressing. 370 * is_internal: Set to true if this phy is internal to a MAC. 371 * is_pseudo_fixed_link: Set to true if this phy is an Ethernet switch, etc. 372 * has_fixups: Set to true if this phy has fixups/quirks. 373 * suspended: Set to true if this phy has been suspended successfully. 374 * sysfs_links: Internal boolean tracking sysfs symbolic links setup/removal. 375 * loopback_enabled: Set true if this phy has been loopbacked successfully. 376 * state: state of the PHY for management purposes 377 * dev_flags: Device-specific flags used by the PHY driver. 378 * link_timeout: The number of timer firings to wait before the 379 * giving up on the current attempt at acquiring a link 380 * irq: IRQ number of the PHY's interrupt (-1 if none) 381 * phy_timer: The timer for handling the state machine 382 * phy_queue: A work_queue for the phy_mac_interrupt 383 * attached_dev: The attached enet driver's device instance ptr 384 * adjust_link: Callback for the enet controller to respond to 385 * changes in the link state. 386 * 387 * speed, duplex, pause, supported, advertising, lp_advertising, 388 * and autoneg are used like in mii_if_info 389 * 390 * interrupts currently only supports enabled or disabled, 391 * but could be changed in the future to support enabling 392 * and disabling specific interrupts 393 * 394 * Contains some infrastructure for polling and interrupt 395 * handling, as well as handling shifts in PHY hardware state 396 */ 397 struct phy_device { 398 struct mdio_device mdio; 399 400 /* Information about the PHY type */ 401 /* And management functions */ 402 struct phy_driver *drv; 403 404 u32 phy_id; 405 406 struct phy_c45_device_ids c45_ids; 407 bool is_c45; 408 bool is_internal; 409 bool is_pseudo_fixed_link; 410 bool has_fixups; 411 bool suspended; 412 bool sysfs_links; 413 bool loopback_enabled; 414 415 enum phy_state state; 416 417 u32 dev_flags; 418 419 phy_interface_t interface; 420 421 /* 422 * forced speed & duplex (no autoneg) 423 * partner speed & duplex & pause (autoneg) 424 */ 425 int speed; 426 int duplex; 427 int pause; 428 int asym_pause; 429 430 /* The most recently read link state */ 431 int link; 432 433 /* Enabled Interrupts */ 434 u32 interrupts; 435 436 /* Union of PHY and Attached devices' supported modes */ 437 /* See mii.h for more info */ 438 u32 supported; 439 u32 advertising; 440 u32 lp_advertising; 441 442 /* Energy efficient ethernet modes which should be prohibited */ 443 u32 eee_broken_modes; 444 445 int autoneg; 446 447 int link_timeout; 448 449 #ifdef CONFIG_LED_TRIGGER_PHY 450 struct phy_led_trigger *phy_led_triggers; 451 unsigned int phy_num_led_triggers; 452 struct phy_led_trigger *last_triggered; 453 #endif 454 455 /* 456 * Interrupt number for this PHY 457 * -1 means no interrupt 458 */ 459 int irq; 460 461 /* private data pointer */ 462 /* For use by PHYs to maintain extra state */ 463 void *priv; 464 465 /* Interrupt and Polling infrastructure */ 466 struct work_struct phy_queue; 467 struct delayed_work state_queue; 468 atomic_t irq_disable; 469 470 struct mutex lock; 471 472 struct net_device *attached_dev; 473 474 u8 mdix; 475 u8 mdix_ctrl; 476 477 void (*adjust_link)(struct net_device *dev); 478 }; 479 #define to_phy_device(d) container_of(to_mdio_device(d), \ 480 struct phy_device, mdio) 481 482 /* struct phy_driver: Driver structure for a particular PHY type 483 * 484 * driver_data: static driver data 485 * phy_id: The result of reading the UID registers of this PHY 486 * type, and ANDing them with the phy_id_mask. This driver 487 * only works for PHYs with IDs which match this field 488 * name: The friendly name of this PHY type 489 * phy_id_mask: Defines the important bits of the phy_id 490 * features: A list of features (speed, duplex, etc) supported 491 * by this PHY 492 * flags: A bitfield defining certain other features this PHY 493 * supports (like interrupts) 494 * 495 * The drivers must implement config_aneg and read_status. All 496 * other functions are optional. Note that none of these 497 * functions should be called from interrupt time. The goal is 498 * for the bus read/write functions to be able to block when the 499 * bus transaction is happening, and be freed up by an interrupt 500 * (The MPC85xx has this ability, though it is not currently 501 * supported in the driver). 502 */ 503 struct phy_driver { 504 struct mdio_driver_common mdiodrv; 505 u32 phy_id; 506 char *name; 507 unsigned int phy_id_mask; 508 u32 features; 509 u32 flags; 510 const void *driver_data; 511 512 /* 513 * Called to issue a PHY software reset 514 */ 515 int (*soft_reset)(struct phy_device *phydev); 516 517 /* 518 * Called to initialize the PHY, 519 * including after a reset 520 */ 521 int (*config_init)(struct phy_device *phydev); 522 523 /* 524 * Called during discovery. Used to set 525 * up device-specific structures, if any 526 */ 527 int (*probe)(struct phy_device *phydev); 528 529 /* PHY Power Management */ 530 int (*suspend)(struct phy_device *phydev); 531 int (*resume)(struct phy_device *phydev); 532 533 /* 534 * Configures the advertisement and resets 535 * autonegotiation if phydev->autoneg is on, 536 * forces the speed to the current settings in phydev 537 * if phydev->autoneg is off 538 */ 539 int (*config_aneg)(struct phy_device *phydev); 540 541 /* Determines the auto negotiation result */ 542 int (*aneg_done)(struct phy_device *phydev); 543 544 /* Determines the negotiated speed and duplex */ 545 int (*read_status)(struct phy_device *phydev); 546 547 /* Clears any pending interrupts */ 548 int (*ack_interrupt)(struct phy_device *phydev); 549 550 /* Enables or disables interrupts */ 551 int (*config_intr)(struct phy_device *phydev); 552 553 /* 554 * Checks if the PHY generated an interrupt. 555 * For multi-PHY devices with shared PHY interrupt pin 556 */ 557 int (*did_interrupt)(struct phy_device *phydev); 558 559 /* Clears up any memory if needed */ 560 void (*remove)(struct phy_device *phydev); 561 562 /* Returns true if this is a suitable driver for the given 563 * phydev. If NULL, matching is based on phy_id and 564 * phy_id_mask. 565 */ 566 int (*match_phy_device)(struct phy_device *phydev); 567 568 /* Handles ethtool queries for hardware time stamping. */ 569 int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti); 570 571 /* Handles SIOCSHWTSTAMP ioctl for hardware time stamping. */ 572 int (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr); 573 574 /* 575 * Requests a Rx timestamp for 'skb'. If the skb is accepted, 576 * the phy driver promises to deliver it using netif_rx() as 577 * soon as a timestamp becomes available. One of the 578 * PTP_CLASS_ values is passed in 'type'. The function must 579 * return true if the skb is accepted for delivery. 580 */ 581 bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type); 582 583 /* 584 * Requests a Tx timestamp for 'skb'. The phy driver promises 585 * to deliver it using skb_complete_tx_timestamp() as soon as a 586 * timestamp becomes available. One of the PTP_CLASS_ values 587 * is passed in 'type'. 588 */ 589 void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type); 590 591 /* Some devices (e.g. qnap TS-119P II) require PHY register changes to 592 * enable Wake on LAN, so set_wol is provided to be called in the 593 * ethernet driver's set_wol function. */ 594 int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol); 595 596 /* See set_wol, but for checking whether Wake on LAN is enabled. */ 597 void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol); 598 599 /* 600 * Called to inform a PHY device driver when the core is about to 601 * change the link state. This callback is supposed to be used as 602 * fixup hook for drivers that need to take action when the link 603 * state changes. Drivers are by no means allowed to mess with the 604 * PHY device structure in their implementations. 605 */ 606 void (*link_change_notify)(struct phy_device *dev); 607 608 /* 609 * Phy specific driver override for reading a MMD register. 610 * This function is optional for PHY specific drivers. When 611 * not provided, the default MMD read function will be used 612 * by phy_read_mmd(), which will use either a direct read for 613 * Clause 45 PHYs or an indirect read for Clause 22 PHYs. 614 * devnum is the MMD device number within the PHY device, 615 * regnum is the register within the selected MMD device. 616 */ 617 int (*read_mmd)(struct phy_device *dev, int devnum, u16 regnum); 618 619 /* 620 * Phy specific driver override for writing a MMD register. 621 * This function is optional for PHY specific drivers. When 622 * not provided, the default MMD write function will be used 623 * by phy_write_mmd(), which will use either a direct write for 624 * Clause 45 PHYs, or an indirect write for Clause 22 PHYs. 625 * devnum is the MMD device number within the PHY device, 626 * regnum is the register within the selected MMD device. 627 * val is the value to be written. 628 */ 629 int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum, 630 u16 val); 631 632 /* Get the size and type of the eeprom contained within a plug-in 633 * module */ 634 int (*module_info)(struct phy_device *dev, 635 struct ethtool_modinfo *modinfo); 636 637 /* Get the eeprom information from the plug-in module */ 638 int (*module_eeprom)(struct phy_device *dev, 639 struct ethtool_eeprom *ee, u8 *data); 640 641 /* Get statistics from the phy using ethtool */ 642 int (*get_sset_count)(struct phy_device *dev); 643 void (*get_strings)(struct phy_device *dev, u8 *data); 644 void (*get_stats)(struct phy_device *dev, 645 struct ethtool_stats *stats, u64 *data); 646 647 /* Get and Set PHY tunables */ 648 int (*get_tunable)(struct phy_device *dev, 649 struct ethtool_tunable *tuna, void *data); 650 int (*set_tunable)(struct phy_device *dev, 651 struct ethtool_tunable *tuna, 652 const void *data); 653 int (*set_loopback)(struct phy_device *dev, bool enable); 654 }; 655 #define to_phy_driver(d) container_of(to_mdio_common_driver(d), \ 656 struct phy_driver, mdiodrv) 657 658 #define PHY_ANY_ID "MATCH ANY PHY" 659 #define PHY_ANY_UID 0xffffffff 660 661 /* A Structure for boards to register fixups with the PHY Lib */ 662 struct phy_fixup { 663 struct list_head list; 664 char bus_id[MII_BUS_ID_SIZE + 3]; 665 u32 phy_uid; 666 u32 phy_uid_mask; 667 int (*run)(struct phy_device *phydev); 668 }; 669 670 /** 671 * phy_read_mmd - Convenience function for reading a register 672 * from an MMD on a given PHY. 673 * @phydev: The phy_device struct 674 * @devad: The MMD to read from 675 * @regnum: The register on the MMD to read 676 * 677 * Same rules as for phy_read(); 678 */ 679 int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum); 680 681 /** 682 * phy_read - Convenience function for reading a given PHY register 683 * @phydev: the phy_device struct 684 * @regnum: register number to read 685 * 686 * NOTE: MUST NOT be called from interrupt context, 687 * because the bus read/write functions may wait for an interrupt 688 * to conclude the operation. 689 */ 690 static inline int phy_read(struct phy_device *phydev, u32 regnum) 691 { 692 return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum); 693 } 694 695 /** 696 * phy_write - Convenience function for writing a given PHY register 697 * @phydev: the phy_device struct 698 * @regnum: register number to write 699 * @val: value to write to @regnum 700 * 701 * NOTE: MUST NOT be called from interrupt context, 702 * because the bus read/write functions may wait for an interrupt 703 * to conclude the operation. 704 */ 705 static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val) 706 { 707 return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val); 708 } 709 710 /** 711 * phy_interrupt_is_valid - Convenience function for testing a given PHY irq 712 * @phydev: the phy_device struct 713 * 714 * NOTE: must be kept in sync with addition/removal of PHY_POLL and 715 * PHY_IGNORE_INTERRUPT 716 */ 717 static inline bool phy_interrupt_is_valid(struct phy_device *phydev) 718 { 719 return phydev->irq != PHY_POLL && phydev->irq != PHY_IGNORE_INTERRUPT; 720 } 721 722 /** 723 * phy_is_internal - Convenience function for testing if a PHY is internal 724 * @phydev: the phy_device struct 725 */ 726 static inline bool phy_is_internal(struct phy_device *phydev) 727 { 728 return phydev->is_internal; 729 } 730 731 /** 732 * phy_interface_mode_is_rgmii - Convenience function for testing if a 733 * PHY interface mode is RGMII (all variants) 734 * @mode: the phy_interface_t enum 735 */ 736 static inline bool phy_interface_mode_is_rgmii(phy_interface_t mode) 737 { 738 return mode >= PHY_INTERFACE_MODE_RGMII && 739 mode <= PHY_INTERFACE_MODE_RGMII_TXID; 740 }; 741 742 /** 743 * phy_interface_is_rgmii - Convenience function for testing if a PHY interface 744 * is RGMII (all variants) 745 * @phydev: the phy_device struct 746 */ 747 static inline bool phy_interface_is_rgmii(struct phy_device *phydev) 748 { 749 return phy_interface_mode_is_rgmii(phydev->interface); 750 }; 751 752 /* 753 * phy_is_pseudo_fixed_link - Convenience function for testing if this 754 * PHY is the CPU port facing side of an Ethernet switch, or similar. 755 * @phydev: the phy_device struct 756 */ 757 static inline bool phy_is_pseudo_fixed_link(struct phy_device *phydev) 758 { 759 return phydev->is_pseudo_fixed_link; 760 } 761 762 /** 763 * phy_write_mmd - Convenience function for writing a register 764 * on an MMD on a given PHY. 765 * @phydev: The phy_device struct 766 * @devad: The MMD to read from 767 * @regnum: The register on the MMD to read 768 * @val: value to write to @regnum 769 * 770 * Same rules as for phy_write(); 771 */ 772 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val); 773 774 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id, 775 bool is_c45, 776 struct phy_c45_device_ids *c45_ids); 777 #if IS_ENABLED(CONFIG_PHYLIB) 778 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45); 779 int phy_device_register(struct phy_device *phy); 780 void phy_device_free(struct phy_device *phydev); 781 #else 782 static inline 783 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45) 784 { 785 return NULL; 786 } 787 788 static inline int phy_device_register(struct phy_device *phy) 789 { 790 return 0; 791 } 792 793 static inline void phy_device_free(struct phy_device *phydev) { } 794 #endif /* CONFIG_PHYLIB */ 795 void phy_device_remove(struct phy_device *phydev); 796 int phy_init_hw(struct phy_device *phydev); 797 int phy_suspend(struct phy_device *phydev); 798 int phy_resume(struct phy_device *phydev); 799 int phy_loopback(struct phy_device *phydev, bool enable); 800 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id, 801 phy_interface_t interface); 802 struct phy_device *phy_find_first(struct mii_bus *bus); 803 int phy_attach_direct(struct net_device *dev, struct phy_device *phydev, 804 u32 flags, phy_interface_t interface); 805 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev, 806 void (*handler)(struct net_device *), 807 phy_interface_t interface); 808 struct phy_device *phy_connect(struct net_device *dev, const char *bus_id, 809 void (*handler)(struct net_device *), 810 phy_interface_t interface); 811 void phy_disconnect(struct phy_device *phydev); 812 void phy_detach(struct phy_device *phydev); 813 void phy_start(struct phy_device *phydev); 814 void phy_stop(struct phy_device *phydev); 815 int phy_start_aneg(struct phy_device *phydev); 816 int phy_aneg_done(struct phy_device *phydev); 817 818 int phy_stop_interrupts(struct phy_device *phydev); 819 int phy_restart_aneg(struct phy_device *phydev); 820 821 static inline int phy_read_status(struct phy_device *phydev) 822 { 823 if (!phydev->drv) 824 return -EIO; 825 826 return phydev->drv->read_status(phydev); 827 } 828 829 #define phydev_err(_phydev, format, args...) \ 830 dev_err(&_phydev->mdio.dev, format, ##args) 831 832 #define phydev_dbg(_phydev, format, args...) \ 833 dev_dbg(&_phydev->mdio.dev, format, ##args) 834 835 static inline const char *phydev_name(const struct phy_device *phydev) 836 { 837 return dev_name(&phydev->mdio.dev); 838 } 839 840 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...) 841 __printf(2, 3); 842 void phy_attached_info(struct phy_device *phydev); 843 844 /* Clause 22 PHY */ 845 int genphy_config_init(struct phy_device *phydev); 846 int genphy_setup_forced(struct phy_device *phydev); 847 int genphy_restart_aneg(struct phy_device *phydev); 848 int genphy_config_aneg(struct phy_device *phydev); 849 int genphy_aneg_done(struct phy_device *phydev); 850 int genphy_update_link(struct phy_device *phydev); 851 int genphy_read_status(struct phy_device *phydev); 852 int genphy_suspend(struct phy_device *phydev); 853 int genphy_resume(struct phy_device *phydev); 854 int genphy_loopback(struct phy_device *phydev, bool enable); 855 int genphy_soft_reset(struct phy_device *phydev); 856 static inline int genphy_no_soft_reset(struct phy_device *phydev) 857 { 858 return 0; 859 } 860 861 /* Clause 45 PHY */ 862 int genphy_c45_restart_aneg(struct phy_device *phydev); 863 int genphy_c45_aneg_done(struct phy_device *phydev); 864 int genphy_c45_read_link(struct phy_device *phydev, u32 mmd_mask); 865 int genphy_c45_read_lpa(struct phy_device *phydev); 866 int genphy_c45_read_pma(struct phy_device *phydev); 867 int genphy_c45_pma_setup_forced(struct phy_device *phydev); 868 int genphy_c45_an_disable_aneg(struct phy_device *phydev); 869 870 void phy_driver_unregister(struct phy_driver *drv); 871 void phy_drivers_unregister(struct phy_driver *drv, int n); 872 int phy_driver_register(struct phy_driver *new_driver, struct module *owner); 873 int phy_drivers_register(struct phy_driver *new_driver, int n, 874 struct module *owner); 875 void phy_state_machine(struct work_struct *work); 876 void phy_change(struct phy_device *phydev); 877 void phy_change_work(struct work_struct *work); 878 void phy_mac_interrupt(struct phy_device *phydev, int new_link); 879 void phy_start_machine(struct phy_device *phydev); 880 void phy_stop_machine(struct phy_device *phydev); 881 void phy_trigger_machine(struct phy_device *phydev, bool sync); 882 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd); 883 void phy_ethtool_ksettings_get(struct phy_device *phydev, 884 struct ethtool_link_ksettings *cmd); 885 int phy_ethtool_ksettings_set(struct phy_device *phydev, 886 const struct ethtool_link_ksettings *cmd); 887 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd); 888 int phy_start_interrupts(struct phy_device *phydev); 889 void phy_print_status(struct phy_device *phydev); 890 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed); 891 892 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask, 893 int (*run)(struct phy_device *)); 894 int phy_register_fixup_for_id(const char *bus_id, 895 int (*run)(struct phy_device *)); 896 int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask, 897 int (*run)(struct phy_device *)); 898 899 int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask); 900 int phy_unregister_fixup_for_id(const char *bus_id); 901 int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask); 902 903 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable); 904 int phy_get_eee_err(struct phy_device *phydev); 905 int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data); 906 int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data); 907 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol); 908 void phy_ethtool_get_wol(struct phy_device *phydev, 909 struct ethtool_wolinfo *wol); 910 int phy_ethtool_get_link_ksettings(struct net_device *ndev, 911 struct ethtool_link_ksettings *cmd); 912 int phy_ethtool_set_link_ksettings(struct net_device *ndev, 913 const struct ethtool_link_ksettings *cmd); 914 int phy_ethtool_nway_reset(struct net_device *ndev); 915 916 #if IS_ENABLED(CONFIG_PHYLIB) 917 int __init mdio_bus_init(void); 918 void mdio_bus_exit(void); 919 #endif 920 921 extern struct bus_type mdio_bus_type; 922 923 struct mdio_board_info { 924 const char *bus_id; 925 char modalias[MDIO_NAME_SIZE]; 926 int mdio_addr; 927 const void *platform_data; 928 }; 929 930 #if IS_ENABLED(CONFIG_MDIO_DEVICE) 931 int mdiobus_register_board_info(const struct mdio_board_info *info, 932 unsigned int n); 933 #else 934 static inline int mdiobus_register_board_info(const struct mdio_board_info *i, 935 unsigned int n) 936 { 937 return 0; 938 } 939 #endif 940 941 942 /** 943 * module_phy_driver() - Helper macro for registering PHY drivers 944 * @__phy_drivers: array of PHY drivers to register 945 * 946 * Helper macro for PHY drivers which do not do anything special in module 947 * init/exit. Each module may only use this macro once, and calling it 948 * replaces module_init() and module_exit(). 949 */ 950 #define phy_module_driver(__phy_drivers, __count) \ 951 static int __init phy_module_init(void) \ 952 { \ 953 return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \ 954 } \ 955 module_init(phy_module_init); \ 956 static void __exit phy_module_exit(void) \ 957 { \ 958 phy_drivers_unregister(__phy_drivers, __count); \ 959 } \ 960 module_exit(phy_module_exit) 961 962 #define module_phy_driver(__phy_drivers) \ 963 phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers)) 964 965 #endif /* __PHY_H */ 966