LXR linux/include/linux/phy.h

   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#include <asm/atomic.h>
  29
  30#define PHY_BASIC_FEATURES      (SUPPORTED_10baseT_Half | \
  31                                 SUPPORTED_10baseT_Full | \
  32                                 SUPPORTED_100baseT_Half | \
  33                                 SUPPORTED_100baseT_Full | \
  34                                 SUPPORTED_Autoneg | \
  35                                 SUPPORTED_TP | \
  36                                 SUPPORTED_MII)
  37
  38#define PHY_GBIT_FEATURES       (PHY_BASIC_FEATURES | \
  39                                 SUPPORTED_1000baseT_Half | \
  40                                 SUPPORTED_1000baseT_Full)
  41
  42/*
  43 * Set phydev->irq to PHY_POLL if interrupts are not supported,
  44 * or not desired for this PHY.  Set to PHY_IGNORE_INTERRUPT if
  45 * the attached driver handles the interrupt
  46 */
  47#define PHY_POLL                -1
  48#define PHY_IGNORE_INTERRUPT    -2
  49
  50#define PHY_HAS_INTERRUPT       0x00000001
  51#define PHY_HAS_MAGICANEG       0x00000002
  52
  53/* Interface Mode definitions */
  54typedef enum {
  55        PHY_INTERFACE_MODE_MII,
  56        PHY_INTERFACE_MODE_GMII,
  57        PHY_INTERFACE_MODE_SGMII,
  58        PHY_INTERFACE_MODE_TBI,
  59        PHY_INTERFACE_MODE_RMII,
  60        PHY_INTERFACE_MODE_RGMII,
  61        PHY_INTERFACE_MODE_RGMII_ID,
  62        PHY_INTERFACE_MODE_RGMII_RXID,
  63        PHY_INTERFACE_MODE_RGMII_TXID,
  64        PHY_INTERFACE_MODE_RTBI
  65} phy_interface_t;
  66
  67
  68#define PHY_INIT_TIMEOUT        100000
  69#define PHY_STATE_TIME          1
  70#define PHY_FORCE_TIMEOUT       10
  71#define PHY_AN_TIMEOUT          10
  72
  73#define PHY_MAX_ADDR    32
  74
  75/* Used when trying to connect to a specific phy (mii bus id:phy device id) */
  76#define PHY_ID_FMT "%s:%02x"
  77
  78/*
  79 * Need to be a little smaller than phydev->dev.bus_id to leave room
  80 * for the ":%02x"
  81 */
  82#define MII_BUS_ID_SIZE (20 - 3)
  83
  84/*
  85 * The Bus class for PHYs.  Devices which provide access to
  86 * PHYs should register using this structure
  87 */
  88struct mii_bus {
  89        const char *name;
  90        char id[MII_BUS_ID_SIZE];
  91        void *priv;
  92        int (*read)(struct mii_bus *bus, int phy_id, int regnum);
  93        int (*write)(struct mii_bus *bus, int phy_id, int regnum, u16 val);
  94        int (*reset)(struct mii_bus *bus);
  95
  96        /*
  97         * A lock to ensure that only one thing can read/write
  98         * the MDIO bus at a time
  99         */
 100        struct mutex mdio_lock;
 101
 102        struct device *parent;
 103        enum {
 104                MDIOBUS_ALLOCATED = 1,
 105                MDIOBUS_REGISTERED,
 106                MDIOBUS_UNREGISTERED,
 107                MDIOBUS_RELEASED,
 108        } state;
 109        struct device dev;
 110
 111        /* list of all PHYs on bus */
 112        struct phy_device *phy_map[PHY_MAX_ADDR];
 113
 114        /* Phy addresses to be ignored when probing */
 115        u32 phy_mask;
 116
 117        /*
 118         * Pointer to an array of interrupts, each PHY's
 119         * interrupt at the index matching its address
 120         */
 121        int *irq;
 122};
 123#define to_mii_bus(d) container_of(d, struct mii_bus, dev)
 124
 125struct mii_bus *mdiobus_alloc(void);
 126int mdiobus_register(struct mii_bus *bus);
 127void mdiobus_unregister(struct mii_bus *bus);
 128void mdiobus_free(struct mii_bus *bus);
 129struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
 130int mdiobus_read(struct mii_bus *bus, int addr, u16 regnum);
 131int mdiobus_write(struct mii_bus *bus, int addr, u16 regnum, u16 val);
 132
 133
 134#define PHY_INTERRUPT_DISABLED  0x0
 135#define PHY_INTERRUPT_ENABLED   0x80000000
 136
 137/* PHY state machine states:
 138 *
 139 * DOWN: PHY device and driver are not ready for anything.  probe
 140 * should be called if and only if the PHY is in this state,
 141 * given that the PHY device exists.
 142 * - PHY driver probe function will, depending on the PHY, set
 143 * the state to STARTING or READY
 144 *
 145 * STARTING:  PHY device is coming up, and the ethernet driver is
 146 * not ready.  PHY drivers may set this in the probe function.
 147 * If they do, they are responsible for making sure the state is
 148 * eventually set to indicate whether the PHY is UP or READY,
 149 * depending on the state when the PHY is done starting up.
 150 * - PHY driver will set the state to READY
 151 * - start will set the state to PENDING
 152 *
 153 * READY: PHY is ready to send and receive packets, but the
 154 * controller is not.  By default, PHYs which do not implement
 155 * probe will be set to this state by phy_probe().  If the PHY
 156 * driver knows the PHY is ready, and the PHY state is STARTING,
 157 * then it sets this STATE.
 158 * - start will set the state to UP
 159 *
 160 * PENDING: PHY device is coming up, but the ethernet driver is
 161 * ready.  phy_start will set this state if the PHY state is
 162 * STARTING.
 163 * - PHY driver will set the state to UP when the PHY is ready
 164 *
 165 * UP: The PHY and attached device are ready to do work.
 166 * Interrupts should be started here.
 167 * - timer moves to AN
 168 *
 169 * AN: The PHY is currently negotiating the link state.  Link is
 170 * therefore down for now.  phy_timer will set this state when it
 171 * detects the state is UP.  config_aneg will set this state
 172 * whenever called with phydev->autoneg set to AUTONEG_ENABLE.
 173 * - If autonegotiation finishes, but there's no link, it sets
 174 *   the state to NOLINK.
 175 * - If aneg finishes with link, it sets the state to RUNNING,
 176 *   and calls adjust_link
 177 * - If autonegotiation did not finish after an arbitrary amount
 178 *   of time, autonegotiation should be tried again if the PHY
 179 *   supports "magic" autonegotiation (back to AN)
 180 * - If it didn't finish, and no magic_aneg, move to FORCING.
 181 *
 182 * NOLINK: PHY is up, but not currently plugged in.
 183 * - If the timer notes that the link comes back, we move to RUNNING
 184 * - config_aneg moves to AN
 185 * - phy_stop moves to HALTED
 186 *
 187 * FORCING: PHY is being configured with forced settings
 188 * - if link is up, move to RUNNING
 189 * - If link is down, we drop to the next highest setting, and
 190 *   retry (FORCING) after a timeout
 191 * - phy_stop moves to HALTED
 192 *
 193 * RUNNING: PHY is currently up, running, and possibly sending
 194 * and/or receiving packets
 195 * - timer will set CHANGELINK if we're polling (this ensures the
 196 *   link state is polled every other cycle of this state machine,
 197 *   which makes it every other second)
 198 * - irq will set CHANGELINK
 199 * - config_aneg will set AN
 200 * - phy_stop moves to HALTED
 201 *
 202 * CHANGELINK: PHY experienced a change in link state
 203 * - timer moves to RUNNING if link
 204 * - timer moves to NOLINK if the link is down
 205 * - phy_stop moves to HALTED
 206 *
 207 * HALTED: PHY is up, but no polling or interrupts are done. Or
 208 * PHY is in an error state.
 209 *
 210 * - phy_start moves to RESUMING
 211 *
 212 * RESUMING: PHY was halted, but now wants to run again.
 213 * - If we are forcing, or aneg is done, timer moves to RUNNING
 214 * - If aneg is not done, timer moves to AN
 215 * - phy_stop moves to HALTED
 216 */
 217enum phy_state {
 218        PHY_DOWN=0,
 219        PHY_STARTING,
 220        PHY_READY,
 221        PHY_PENDING,
 222        PHY_UP,
 223        PHY_AN,
 224        PHY_RUNNING,
 225        PHY_NOLINK,
 226        PHY_FORCING,
 227        PHY_CHANGELINK,
 228        PHY_HALTED,
 229        PHY_RESUMING
 230};
 231
 232/* phy_device: An instance of a PHY
 233 *
 234 * drv: Pointer to the driver for this PHY instance
 235 * bus: Pointer to the bus this PHY is on
 236 * dev: driver model device structure for this PHY
 237 * phy_id: UID for this device found during discovery
 238 * state: state of the PHY for management purposes
 239 * dev_flags: Device-specific flags used by the PHY driver.
 240 * addr: Bus address of PHY
 241 * link_timeout: The number of timer firings to wait before the
 242 * giving up on the current attempt at acquiring a link
 243 * irq: IRQ number of the PHY's interrupt (-1 if none)
 244 * phy_timer: The timer for handling the state machine
 245 * phy_queue: A work_queue for the interrupt
 246 * attached_dev: The attached enet driver's device instance ptr
 247 * adjust_link: Callback for the enet controller to respond to
 248 * changes in the link state.
 249 * adjust_state: Callback for the enet driver to respond to
 250 * changes in the state machine.
 251 *
 252 * speed, duplex, pause, supported, advertising, and
 253 * autoneg are used like in mii_if_info
 254 *
 255 * interrupts currently only supports enabled or disabled,
 256 * but could be changed in the future to support enabling
 257 * and disabling specific interrupts
 258 *
 259 * Contains some infrastructure for polling and interrupt
 260 * handling, as well as handling shifts in PHY hardware state
 261 */
 262struct phy_device {
 263        /* Information about the PHY type */
 264        /* And management functions */
 265        struct phy_driver *drv;
 266
 267        struct mii_bus *bus;
 268
 269        struct device dev;
 270
 271        u32 phy_id;
 272
 273        enum phy_state state;
 274
 275        u32 dev_flags;
 276
 277        phy_interface_t interface;
 278
 279        /* Bus address of the PHY (0-32) */
 280        int addr;
 281
 282        /*
 283         * forced speed & duplex (no autoneg)
 284         * partner speed & duplex & pause (autoneg)
 285         */
 286        int speed;
 287        int duplex;
 288        int pause;
 289        int asym_pause;
 290
 291        /* The most recently read link state */
 292        int link;
 293
 294        /* Enabled Interrupts */
 295        u32 interrupts;
 296
 297        /* Union of PHY and Attached devices' supported modes */
 298        /* See mii.h for more info */
 299        u32 supported;
 300        u32 advertising;
 301
 302        int autoneg;
 303
 304        int link_timeout;
 305
 306        /*
 307         * Interrupt number for this PHY
 308         * -1 means no interrupt
 309         */
 310        int irq;
 311
 312        /* private data pointer */
 313        /* For use by PHYs to maintain extra state */
 314        void *priv;
 315
 316        /* Interrupt and Polling infrastructure */
 317        struct work_struct phy_queue;
 318        struct delayed_work state_queue;
 319        atomic_t irq_disable;
 320
 321        struct mutex lock;
 322
 323        struct net_device *attached_dev;
 324
 325        void (*adjust_link)(struct net_device *dev);
 326
 327        void (*adjust_state)(struct net_device *dev);
 328};
 329#define to_phy_device(d) container_of(d, struct phy_device, dev)
 330
 331/* struct phy_driver: Driver structure for a particular PHY type
 332 *
 333 * phy_id: The result of reading the UID registers of this PHY
 334 *   type, and ANDing them with the phy_id_mask.  This driver
 335 *   only works for PHYs with IDs which match this field
 336 * name: The friendly name of this PHY type
 337 * phy_id_mask: Defines the important bits of the phy_id
 338 * features: A list of features (speed, duplex, etc) supported
 339 *   by this PHY
 340 * flags: A bitfield defining certain other features this PHY
 341 *   supports (like interrupts)
 342 *
 343 * The drivers must implement config_aneg and read_status.  All
 344 * other functions are optional. Note that none of these
 345 * functions should be called from interrupt time.  The goal is
 346 * for the bus read/write functions to be able to block when the
 347 * bus transaction is happening, and be freed up by an interrupt
 348 * (The MPC85xx has this ability, though it is not currently
 349 * supported in the driver).
 350 */
 351struct phy_driver {
 352        u32 phy_id;
 353        char *name;
 354        unsigned int phy_id_mask;
 355        u32 features;
 356        u32 flags;
 357
 358        /*
 359         * Called to initialize the PHY,
 360         * including after a reset
 361         */
 362        int (*config_init)(struct phy_device *phydev);
 363
 364        /*
 365         * Called during discovery.  Used to set
 366         * up device-specific structures, if any
 367         */
 368        int (*probe)(struct phy_device *phydev);
 369
 370        /* PHY Power Management */
 371        int (*suspend)(struct phy_device *phydev);
 372        int (*resume)(struct phy_device *phydev);
 373
 374        /*
 375         * Configures the advertisement and resets
 376         * autonegotiation if phydev->autoneg is on,
 377         * forces the speed to the current settings in phydev
 378         * if phydev->autoneg is off
 379         */
 380        int (*config_aneg)(struct phy_device *phydev);
 381
 382        /* Determines the negotiated speed and duplex */
 383        int (*read_status)(struct phy_device *phydev);
 384
 385        /* Clears any pending interrupts */
 386        int (*ack_interrupt)(struct phy_device *phydev);
 387
 388        /* Enables or disables interrupts */
 389        int (*config_intr)(struct phy_device *phydev);
 390
 391        /*
 392         * Checks if the PHY generated an interrupt.
 393         * For multi-PHY devices with shared PHY interrupt pin
 394         */
 395        int (*did_interrupt)(struct phy_device *phydev);
 396
 397        /* Clears up any memory if needed */
 398        void (*remove)(struct phy_device *phydev);
 399
 400        struct device_driver driver;
 401};
 402#define to_phy_driver(d) container_of(d, struct phy_driver, driver)
 403
 404#define PHY_ANY_ID "MATCH ANY PHY"
 405#define PHY_ANY_UID 0xffffffff
 406
 407/* A Structure for boards to register fixups with the PHY Lib */
 408struct phy_fixup {
 409        struct list_head list;
 410        char bus_id[20];
 411        u32 phy_uid;
 412        u32 phy_uid_mask;
 413        int (*run)(struct phy_device *phydev);
 414};
 415
 416/**
 417 * phy_read - Convenience function for reading a given PHY register
 418 * @phydev: the phy_device struct
 419 * @regnum: register number to read
 420 *
 421 * NOTE: MUST NOT be called from interrupt context,
 422 * because the bus read/write functions may wait for an interrupt
 423 * to conclude the operation.
 424 */
 425static inline int phy_read(struct phy_device *phydev, u16 regnum)
 426{
 427        return mdiobus_read(phydev->bus, phydev->addr, regnum);
 428}
 429
 430/**
 431 * phy_write - Convenience function for writing a given PHY register
 432 * @phydev: the phy_device struct
 433 * @regnum: register number to write
 434 * @val: value to write to @regnum
 435 *
 436 * NOTE: MUST NOT be called from interrupt context,
 437 * because the bus read/write functions may wait for an interrupt
 438 * to conclude the operation.
 439 */
 440static inline int phy_write(struct phy_device *phydev, u16 regnum, u16 val)
 441{
 442        return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
 443}
 444
 445int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id);
 446struct phy_device* get_phy_device(struct mii_bus *bus, int addr);
 447int phy_device_register(struct phy_device *phy);
 448int phy_clear_interrupt(struct phy_device *phydev);
 449int phy_config_interrupt(struct phy_device *phydev, u32 interrupts);
 450int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
 451                u32 flags, phy_interface_t interface);
 452struct phy_device * phy_attach(struct net_device *dev,
 453                const char *bus_id, u32 flags, phy_interface_t interface);
 454int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
 455                void (*handler)(struct net_device *), u32 flags,
 456                phy_interface_t interface);
 457struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
 458                void (*handler)(struct net_device *), u32 flags,
 459                phy_interface_t interface);
 460void phy_disconnect(struct phy_device *phydev);
 461void phy_detach(struct phy_device *phydev);
 462void phy_start(struct phy_device *phydev);
 463void phy_stop(struct phy_device *phydev);
 464int phy_start_aneg(struct phy_device *phydev);
 465
 466void phy_sanitize_settings(struct phy_device *phydev);
 467int phy_stop_interrupts(struct phy_device *phydev);
 468int phy_enable_interrupts(struct phy_device *phydev);
 469int phy_disable_interrupts(struct phy_device *phydev);
 470
 471static inline int phy_read_status(struct phy_device *phydev) {
 472        return phydev->drv->read_status(phydev);
 473}
 474
 475int genphy_config_advert(struct phy_device *phydev);
 476int genphy_setup_forced(struct phy_device *phydev);
 477int genphy_restart_aneg(struct phy_device *phydev);
 478int genphy_config_aneg(struct phy_device *phydev);
 479int genphy_update_link(struct phy_device *phydev);
 480int genphy_read_status(struct phy_device *phydev);
 481int genphy_suspend(struct phy_device *phydev);
 482int genphy_resume(struct phy_device *phydev);
 483void phy_driver_unregister(struct phy_driver *drv);
 484int phy_driver_register(struct phy_driver *new_driver);
 485void phy_prepare_link(struct phy_device *phydev,
 486                void (*adjust_link)(struct net_device *));
 487void phy_start_machine(struct phy_device *phydev,
 488                void (*handler)(struct net_device *));
 489void phy_stop_machine(struct phy_device *phydev);
 490int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
 491int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd);
 492int phy_mii_ioctl(struct phy_device *phydev,
 493                struct mii_ioctl_data *mii_data, int cmd);
 494int phy_start_interrupts(struct phy_device *phydev);
 495void phy_print_status(struct phy_device *phydev);
 496struct phy_device* phy_device_create(struct mii_bus *bus, int addr, int phy_id);
 497void phy_device_free(struct phy_device *phydev);
 498
 499int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
 500                int (*run)(struct phy_device *));
 501int phy_register_fixup_for_id(const char *bus_id,
 502                int (*run)(struct phy_device *));
 503int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
 504                int (*run)(struct phy_device *));
 505int phy_scan_fixups(struct phy_device *phydev);
 506
 507int __init mdio_bus_init(void);
 508void mdio_bus_exit(void);
 509
 510extern struct bus_type mdio_bus_type;
 511#endif /* __PHY_H */
 512