1 /* 2 * include/linux/phy.h 3 * 4 * Framework and drivers for configuring and reading different PHYs 5 * Based on code in sungem_phy.c and gianfar_phy.c 6 * 7 * Author: Andy Fleming 8 * 9 * Copyright (c) 2004 Freescale Semiconductor, Inc. 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the 13 * Free Software Foundation; either version 2 of the License, or (at your 14 * option) any later version. 15 * 16 */ 17 18 #ifndef __PHY_H 19 #define __PHY_H 20 21 #include <linux/spinlock.h> 22 #include <linux/device.h> 23 #include <linux/ethtool.h> 24 #include <linux/mii.h> 25 #include <linux/timer.h> 26 #include <linux/workqueue.h> 27 28 #define PHY_BASIC_FEATURES (SUPPORTED_10baseT_Half | \ 29 SUPPORTED_10baseT_Full | \ 30 SUPPORTED_100baseT_Half | \ 31 SUPPORTED_100baseT_Full | \ 32 SUPPORTED_Autoneg | \ 33 SUPPORTED_TP | \ 34 SUPPORTED_MII) 35 36 #define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES | \ 37 SUPPORTED_1000baseT_Half | \ 38 SUPPORTED_1000baseT_Full) 39 40 /* Set phydev->irq to PHY_POLL if interrupts are not supported, 41 * or not desired for this PHY. Set to PHY_IGNORE_INTERRUPT if 42 * the attached driver handles the interrupt 43 */ 44 #define PHY_POLL -1 45 #define PHY_IGNORE_INTERRUPT -2 46 47 #define PHY_HAS_INTERRUPT 0x00000001 48 #define PHY_HAS_MAGICANEG 0x00000002 49 50 /* Interface Mode definitions */ 51 typedef enum { 52 PHY_INTERFACE_MODE_MII, 53 PHY_INTERFACE_MODE_GMII, 54 PHY_INTERFACE_MODE_SGMII, 55 PHY_INTERFACE_MODE_TBI, 56 PHY_INTERFACE_MODE_RMII, 57 PHY_INTERFACE_MODE_RGMII, 58 PHY_INTERFACE_MODE_RTBI 59 } phy_interface_t; 60 61 #define MII_BUS_MAX 4 62 63 64 #define PHY_INIT_TIMEOUT 100000 65 #define PHY_STATE_TIME 1 66 #define PHY_FORCE_TIMEOUT 10 67 #define PHY_AN_TIMEOUT 10 68 69 #define PHY_MAX_ADDR 32 70 71 /* Used when trying to connect to a specific phy (mii bus id:phy device id) */ 72 #define PHY_ID_FMT "%x:%02x" 73 74 /* The Bus class for PHYs. Devices which provide access to 75 * PHYs should register using this structure */ 76 struct mii_bus { 77 const char *name; 78 int id; 79 void *priv; 80 int (*read)(struct mii_bus *bus, int phy_id, int regnum); 81 int (*write)(struct mii_bus *bus, int phy_id, int regnum, u16 val); 82 int (*reset)(struct mii_bus *bus); 83 84 /* A lock to ensure that only one thing can read/write 85 * the MDIO bus at a time */ 86 spinlock_t mdio_lock; 87 88 struct device *dev; 89 90 /* list of all PHYs on bus */ 91 struct phy_device *phy_map[PHY_MAX_ADDR]; 92 93 /* Phy addresses to be ignored when probing */ 94 u32 phy_mask; 95 96 /* Pointer to an array of interrupts, each PHY's 97 * interrupt at the index matching its address */ 98 int *irq; 99 }; 100 101 #define PHY_INTERRUPT_DISABLED 0x0 102 #define PHY_INTERRUPT_ENABLED 0x80000000 103 104 /* PHY state machine states: 105 * 106 * DOWN: PHY device and driver are not ready for anything. probe 107 * should be called if and only if the PHY is in this state, 108 * given that the PHY device exists. 109 * - PHY driver probe function will, depending on the PHY, set 110 * the state to STARTING or READY 111 * 112 * STARTING: PHY device is coming up, and the ethernet driver is 113 * not ready. PHY drivers may set this in the probe function. 114 * If they do, they are responsible for making sure the state is 115 * eventually set to indicate whether the PHY is UP or READY, 116 * depending on the state when the PHY is done starting up. 117 * - PHY driver will set the state to READY 118 * - start will set the state to PENDING 119 * 120 * READY: PHY is ready to send and receive packets, but the 121 * controller is not. By default, PHYs which do not implement 122 * probe will be set to this state by phy_probe(). If the PHY 123 * driver knows the PHY is ready, and the PHY state is STARTING, 124 * then it sets this STATE. 125 * - start will set the state to UP 126 * 127 * PENDING: PHY device is coming up, but the ethernet driver is 128 * ready. phy_start will set this state if the PHY state is 129 * STARTING. 130 * - PHY driver will set the state to UP when the PHY is ready 131 * 132 * UP: The PHY and attached device are ready to do work. 133 * Interrupts should be started here. 134 * - timer moves to AN 135 * 136 * AN: The PHY is currently negotiating the link state. Link is 137 * therefore down for now. phy_timer will set this state when it 138 * detects the state is UP. config_aneg will set this state 139 * whenever called with phydev->autoneg set to AUTONEG_ENABLE. 140 * - If autonegotiation finishes, but there's no link, it sets 141 * the state to NOLINK. 142 * - If aneg finishes with link, it sets the state to RUNNING, 143 * and calls adjust_link 144 * - If autonegotiation did not finish after an arbitrary amount 145 * of time, autonegotiation should be tried again if the PHY 146 * supports "magic" autonegotiation (back to AN) 147 * - If it didn't finish, and no magic_aneg, move to FORCING. 148 * 149 * NOLINK: PHY is up, but not currently plugged in. 150 * - If the timer notes that the link comes back, we move to RUNNING 151 * - config_aneg moves to AN 152 * - phy_stop moves to HALTED 153 * 154 * FORCING: PHY is being configured with forced settings 155 * - if link is up, move to RUNNING 156 * - If link is down, we drop to the next highest setting, and 157 * retry (FORCING) after a timeout 158 * - phy_stop moves to HALTED 159 * 160 * RUNNING: PHY is currently up, running, and possibly sending 161 * and/or receiving packets 162 * - timer will set CHANGELINK if we're polling (this ensures the 163 * link state is polled every other cycle of this state machine, 164 * which makes it every other second) 165 * - irq will set CHANGELINK 166 * - config_aneg will set AN 167 * - phy_stop moves to HALTED 168 * 169 * CHANGELINK: PHY experienced a change in link state 170 * - timer moves to RUNNING if link 171 * - timer moves to NOLINK if the link is down 172 * - phy_stop moves to HALTED 173 * 174 * HALTED: PHY is up, but no polling or interrupts are done. Or 175 * PHY is in an error state. 176 * 177 * - phy_start moves to RESUMING 178 * 179 * RESUMING: PHY was halted, but now wants to run again. 180 * - If we are forcing, or aneg is done, timer moves to RUNNING 181 * - If aneg is not done, timer moves to AN 182 * - phy_stop moves to HALTED 183 */ 184 enum phy_state { 185 PHY_DOWN=0, 186 PHY_STARTING, 187 PHY_READY, 188 PHY_PENDING, 189 PHY_UP, 190 PHY_AN, 191 PHY_RUNNING, 192 PHY_NOLINK, 193 PHY_FORCING, 194 PHY_CHANGELINK, 195 PHY_HALTED, 196 PHY_RESUMING 197 }; 198 199 /* phy_device: An instance of a PHY 200 * 201 * drv: Pointer to the driver for this PHY instance 202 * bus: Pointer to the bus this PHY is on 203 * dev: driver model device structure for this PHY 204 * phy_id: UID for this device found during discovery 205 * state: state of the PHY for management purposes 206 * dev_flags: Device-specific flags used by the PHY driver. 207 * addr: Bus address of PHY 208 * link_timeout: The number of timer firings to wait before the 209 * giving up on the current attempt at acquiring a link 210 * irq: IRQ number of the PHY's interrupt (-1 if none) 211 * phy_timer: The timer for handling the state machine 212 * phy_queue: A work_queue for the interrupt 213 * attached_dev: The attached enet driver's device instance ptr 214 * adjust_link: Callback for the enet controller to respond to 215 * changes in the link state. 216 * adjust_state: Callback for the enet driver to respond to 217 * changes in the state machine. 218 * 219 * speed, duplex, pause, supported, advertising, and 220 * autoneg are used like in mii_if_info 221 * 222 * interrupts currently only supports enabled or disabled, 223 * but could be changed in the future to support enabling 224 * and disabling specific interrupts 225 * 226 * Contains some infrastructure for polling and interrupt 227 * handling, as well as handling shifts in PHY hardware state 228 */ 229 struct phy_device { 230 /* Information about the PHY type */ 231 /* And management functions */ 232 struct phy_driver *drv; 233 234 struct mii_bus *bus; 235 236 struct device dev; 237 238 u32 phy_id; 239 240 enum phy_state state; 241 242 u32 dev_flags; 243 244 phy_interface_t interface; 245 246 /* Bus address of the PHY (0-32) */ 247 int addr; 248 249 /* forced speed & duplex (no autoneg) 250 * partner speed & duplex & pause (autoneg) 251 */ 252 int speed; 253 int duplex; 254 int pause; 255 int asym_pause; 256 257 /* The most recently read link state */ 258 int link; 259 260 /* Enabled Interrupts */ 261 u32 interrupts; 262 263 /* Union of PHY and Attached devices' supported modes */ 264 /* See mii.h for more info */ 265 u32 supported; 266 u32 advertising; 267 268 int autoneg; 269 270 int link_timeout; 271 272 /* Interrupt number for this PHY 273 * -1 means no interrupt */ 274 int irq; 275 276 /* private data pointer */ 277 /* For use by PHYs to maintain extra state */ 278 void *priv; 279 280 /* Interrupt and Polling infrastructure */ 281 struct work_struct phy_queue; 282 struct timer_list phy_timer; 283 284 spinlock_t lock; 285 286 struct net_device *attached_dev; 287 288 void (*adjust_link)(struct net_device *dev); 289 290 void (*adjust_state)(struct net_device *dev); 291 }; 292 #define to_phy_device(d) container_of(d, struct phy_device, dev) 293 294 /* struct phy_driver: Driver structure for a particular PHY type 295 * 296 * phy_id: The result of reading the UID registers of this PHY 297 * type, and ANDing them with the phy_id_mask. This driver 298 * only works for PHYs with IDs which match this field 299 * name: The friendly name of this PHY type 300 * phy_id_mask: Defines the important bits of the phy_id 301 * features: A list of features (speed, duplex, etc) supported 302 * by this PHY 303 * flags: A bitfield defining certain other features this PHY 304 * supports (like interrupts) 305 * 306 * The drivers must implement config_aneg and read_status. All 307 * other functions are optional. Note that none of these 308 * functions should be called from interrupt time. The goal is 309 * for the bus read/write functions to be able to block when the 310 * bus transaction is happening, and be freed up by an interrupt 311 * (The MPC85xx has this ability, though it is not currently 312 * supported in the driver). 313 */ 314 struct phy_driver { 315 u32 phy_id; 316 char *name; 317 unsigned int phy_id_mask; 318 u32 features; 319 u32 flags; 320 321 /* Called to initialize the PHY, 322 * including after a reset */ 323 int (*config_init)(struct phy_device *phydev); 324 325 /* Called during discovery. Used to set 326 * up device-specific structures, if any */ 327 int (*probe)(struct phy_device *phydev); 328 329 /* PHY Power Management */ 330 int (*suspend)(struct phy_device *phydev); 331 int (*resume)(struct phy_device *phydev); 332 333 /* Configures the advertisement and resets 334 * autonegotiation if phydev->autoneg is on, 335 * forces the speed to the current settings in phydev 336 * if phydev->autoneg is off */ 337 int (*config_aneg)(struct phy_device *phydev); 338 339 /* Determines the negotiated speed and duplex */ 340 int (*read_status)(struct phy_device *phydev); 341 342 /* Clears any pending interrupts */ 343 int (*ack_interrupt)(struct phy_device *phydev); 344 345 /* Enables or disables interrupts */ 346 int (*config_intr)(struct phy_device *phydev); 347 348 /* Clears up any memory if needed */ 349 void (*remove)(struct phy_device *phydev); 350 351 struct device_driver driver; 352 }; 353 #define to_phy_driver(d) container_of(d, struct phy_driver, driver) 354 355 int phy_read(struct phy_device *phydev, u16 regnum); 356 int phy_write(struct phy_device *phydev, u16 regnum, u16 val); 357 struct phy_device* get_phy_device(struct mii_bus *bus, int addr); 358 int phy_clear_interrupt(struct phy_device *phydev); 359 int phy_config_interrupt(struct phy_device *phydev, u32 interrupts); 360 struct phy_device * phy_attach(struct net_device *dev, 361 const char *phy_id, u32 flags, phy_interface_t interface); 362 struct phy_device * phy_connect(struct net_device *dev, const char *phy_id, 363 void (*handler)(struct net_device *), u32 flags, 364 phy_interface_t interface); 365 void phy_disconnect(struct phy_device *phydev); 366 void phy_detach(struct phy_device *phydev); 367 void phy_start(struct phy_device *phydev); 368 void phy_stop(struct phy_device *phydev); 369 int phy_start_aneg(struct phy_device *phydev); 370 371 int mdiobus_register(struct mii_bus *bus); 372 void mdiobus_unregister(struct mii_bus *bus); 373 void phy_sanitize_settings(struct phy_device *phydev); 374 int phy_stop_interrupts(struct phy_device *phydev); 375 376 static inline int phy_read_status(struct phy_device *phydev) { 377 return phydev->drv->read_status(phydev); 378 } 379 380 int genphy_config_advert(struct phy_device *phydev); 381 int genphy_setup_forced(struct phy_device *phydev); 382 int genphy_restart_aneg(struct phy_device *phydev); 383 int genphy_config_aneg(struct phy_device *phydev); 384 int genphy_update_link(struct phy_device *phydev); 385 int genphy_read_status(struct phy_device *phydev); 386 void phy_driver_unregister(struct phy_driver *drv); 387 int phy_driver_register(struct phy_driver *new_driver); 388 void phy_prepare_link(struct phy_device *phydev, 389 void (*adjust_link)(struct net_device *)); 390 void phy_start_machine(struct phy_device *phydev, 391 void (*handler)(struct net_device *)); 392 void phy_stop_machine(struct phy_device *phydev); 393 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd); 394 int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd); 395 int phy_mii_ioctl(struct phy_device *phydev, 396 struct mii_ioctl_data *mii_data, int cmd); 397 int phy_start_interrupts(struct phy_device *phydev); 398 void phy_print_status(struct phy_device *phydev); 399 struct phy_device* phy_device_create(struct mii_bus *bus, int addr, int phy_id); 400 401 extern struct bus_type mdio_bus_type; 402 #endif /* __PHY_H */ 403