phy.h 28.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Framework and drivers for configuring and reading different PHYs
 * Based on code in sungem_phy.c and gianfar_phy.c
 *
 * Author: Andy Fleming
 *
 * Copyright (c) 2004 Freescale Semiconductor, Inc.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 *
 */

#ifndef __PHY_H
#define __PHY_H

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>
R
Russell King 已提交
24
#include <linux/module.h>
25 26
#include <linux/timer.h>
#include <linux/workqueue.h>
27
#include <linux/mod_devicetable.h>
28

A
Arun Sharma 已提交
29
#include <linux/atomic.h>
30

31
#define PHY_DEFAULT_FEATURES	(SUPPORTED_Autoneg | \
32 33 34
				 SUPPORTED_TP | \
				 SUPPORTED_MII)

35 36 37 38 39 40 41
#define PHY_10BT_FEATURES	(SUPPORTED_10baseT_Half | \
				 SUPPORTED_10baseT_Full)

#define PHY_100BT_FEATURES	(SUPPORTED_100baseT_Half | \
				 SUPPORTED_100baseT_Full)

#define PHY_1000BT_FEATURES	(SUPPORTED_1000baseT_Half | \
42 43
				 SUPPORTED_1000baseT_Full)

44 45 46 47 48 49 50 51
#define PHY_BASIC_FEATURES	(PHY_10BT_FEATURES | \
				 PHY_100BT_FEATURES | \
				 PHY_DEFAULT_FEATURES)

#define PHY_GBIT_FEATURES	(PHY_BASIC_FEATURES | \
				 PHY_1000BT_FEATURES)


A
Andy Fleming 已提交
52 53
/*
 * Set phydev->irq to PHY_POLL if interrupts are not supported,
54 55 56 57 58 59 60
 * or not desired for this PHY.  Set to PHY_IGNORE_INTERRUPT if
 * the attached driver handles the interrupt
 */
#define PHY_POLL		-1
#define PHY_IGNORE_INTERRUPT	-2

#define PHY_HAS_INTERRUPT	0x00000001
61
#define PHY_IS_INTERNAL		0x00000002
62
#define MDIO_DEVICE_IS_PHY	0x80000000
63

64 65
/* Interface Mode definitions */
typedef enum {
66
	PHY_INTERFACE_MODE_NA,
67 68 69 70
	PHY_INTERFACE_MODE_MII,
	PHY_INTERFACE_MODE_GMII,
	PHY_INTERFACE_MODE_SGMII,
	PHY_INTERFACE_MODE_TBI,
71
	PHY_INTERFACE_MODE_REVMII,
72 73
	PHY_INTERFACE_MODE_RMII,
	PHY_INTERFACE_MODE_RGMII,
74
	PHY_INTERFACE_MODE_RGMII_ID,
75 76
	PHY_INTERFACE_MODE_RGMII_RXID,
	PHY_INTERFACE_MODE_RGMII_TXID,
77 78
	PHY_INTERFACE_MODE_RTBI,
	PHY_INTERFACE_MODE_SMII,
79
	PHY_INTERFACE_MODE_XGMII,
F
Florian Fainelli 已提交
80
	PHY_INTERFACE_MODE_MOCA,
81
	PHY_INTERFACE_MODE_QSGMII,
82
	PHY_INTERFACE_MODE_TRGMII,
83 84 85
	PHY_INTERFACE_MODE_1000BASEX,
	PHY_INTERFACE_MODE_2500BASEX,
	PHY_INTERFACE_MODE_RXAUI,
86
	PHY_INTERFACE_MODE_MAX,
87 88
} phy_interface_t;

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
/**
 * phy_supported_speeds - return all speeds currently supported by a phy device
 * @phy: The phy device to return supported speeds of.
 * @speeds: buffer to store supported speeds in.
 * @size: size of speeds buffer.
 *
 * Description: Returns the number of supported speeds, and
 * fills the speeds * buffer with the supported speeds. If speeds buffer is
 * too small to contain * all currently supported speeds, will return as
 * many speeds as can fit.
 */
unsigned int phy_supported_speeds(struct phy_device *phy,
				      unsigned int *speeds,
				      unsigned int size);

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
/**
 * It maps 'enum phy_interface_t' found in include/linux/phy.h
 * into the device tree binding of 'phy-mode', so that Ethernet
 * device driver can get phy interface from device tree.
 */
static inline const char *phy_modes(phy_interface_t interface)
{
	switch (interface) {
	case PHY_INTERFACE_MODE_NA:
		return "";
	case PHY_INTERFACE_MODE_MII:
		return "mii";
	case PHY_INTERFACE_MODE_GMII:
		return "gmii";
	case PHY_INTERFACE_MODE_SGMII:
		return "sgmii";
	case PHY_INTERFACE_MODE_TBI:
		return "tbi";
	case PHY_INTERFACE_MODE_REVMII:
		return "rev-mii";
	case PHY_INTERFACE_MODE_RMII:
		return "rmii";
	case PHY_INTERFACE_MODE_RGMII:
		return "rgmii";
	case PHY_INTERFACE_MODE_RGMII_ID:
		return "rgmii-id";
	case PHY_INTERFACE_MODE_RGMII_RXID:
		return "rgmii-rxid";
	case PHY_INTERFACE_MODE_RGMII_TXID:
		return "rgmii-txid";
	case PHY_INTERFACE_MODE_RTBI:
		return "rtbi";
	case PHY_INTERFACE_MODE_SMII:
		return "smii";
	case PHY_INTERFACE_MODE_XGMII:
		return "xgmii";
F
Florian Fainelli 已提交
140 141
	case PHY_INTERFACE_MODE_MOCA:
		return "moca";
142 143
	case PHY_INTERFACE_MODE_QSGMII:
		return "qsgmii";
144 145
	case PHY_INTERFACE_MODE_TRGMII:
		return "trgmii";
146 147 148 149 150 151
	case PHY_INTERFACE_MODE_1000BASEX:
		return "1000base-x";
	case PHY_INTERFACE_MODE_2500BASEX:
		return "2500base-x";
	case PHY_INTERFACE_MODE_RXAUI:
		return "rxaui";
152 153 154 155 156
	default:
		return "unknown";
	}
}

157

158
#define PHY_INIT_TIMEOUT	100000
159 160 161 162
#define PHY_STATE_TIME		1
#define PHY_FORCE_TIMEOUT	10
#define PHY_AN_TIMEOUT		10

163
#define PHY_MAX_ADDR	32
164

165
/* Used when trying to connect to a specific phy (mii bus id:phy device id) */
166 167
#define PHY_ID_FMT "%s:%02x"

168
#define MII_BUS_ID_SIZE	61
169

170 171 172 173
/* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
   IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
#define MII_ADDR_C45 (1<<30)

174 175 176
struct device;
struct sk_buff;

A
Andy Fleming 已提交
177 178 179 180
/*
 * The Bus class for PHYs.  Devices which provide access to
 * PHYs should register using this structure
 */
181
struct mii_bus {
R
Russell King 已提交
182
	struct module *owner;
183
	const char *name;
184
	char id[MII_BUS_ID_SIZE];
185
	void *priv;
186 187
	int (*read)(struct mii_bus *bus, int addr, int regnum);
	int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
188 189
	int (*reset)(struct mii_bus *bus);

A
Andy Fleming 已提交
190 191 192 193
	/*
	 * A lock to ensure that only one thing can read/write
	 * the MDIO bus at a time
	 */
194
	struct mutex mdio_lock;
195

196
	struct device *parent;
197 198 199 200 201 202 203
	enum {
		MDIOBUS_ALLOCATED = 1,
		MDIOBUS_REGISTERED,
		MDIOBUS_UNREGISTERED,
		MDIOBUS_RELEASED,
	} state;
	struct device dev;
204 205

	/* list of all PHYs on bus */
206
	struct mdio_device *mdio_map[PHY_MAX_ADDR];
207

208
	/* PHY addresses to be ignored when probing */
209 210
	u32 phy_mask;

211 212 213
	/* PHY addresses to ignore the TA/read failure */
	u32 phy_ignore_ta_mask;

A
Andy Fleming 已提交
214
	/*
215 216
	 * An array of interrupts, each PHY's interrupt at the index
	 * matching its address
A
Andy Fleming 已提交
217
	 */
218
	int irq[PHY_MAX_ADDR];
219 220 221 222 223 224 225

	/* GPIO reset pulse width in microseconds */
	int reset_delay_us;
	/* Number of reset GPIOs */
	int num_reset_gpios;
	/* Array of RESET GPIO descriptors */
	struct gpio_desc **reset_gpiod;
226
};
227
#define to_mii_bus(d) container_of(d, struct mii_bus, dev)
228

229 230 231 232 233 234
struct mii_bus *mdiobus_alloc_size(size_t);
static inline struct mii_bus *mdiobus_alloc(void)
{
	return mdiobus_alloc_size(0);
}

R
Russell King 已提交
235 236
int __mdiobus_register(struct mii_bus *bus, struct module *owner);
#define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE)
237 238
void mdiobus_unregister(struct mii_bus *bus);
void mdiobus_free(struct mii_bus *bus);
239 240 241 242 243 244 245
struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv);
static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev)
{
	return devm_mdiobus_alloc_size(dev, 0);
}

void devm_mdiobus_free(struct device *dev, struct mii_bus *bus);
246 247
struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);

248 249
#define PHY_INTERRUPT_DISABLED	0x0
#define PHY_INTERRUPT_ENABLED	0x80000000
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331

/* PHY state machine states:
 *
 * DOWN: PHY device and driver are not ready for anything.  probe
 * should be called if and only if the PHY is in this state,
 * given that the PHY device exists.
 * - PHY driver probe function will, depending on the PHY, set
 * the state to STARTING or READY
 *
 * STARTING:  PHY device is coming up, and the ethernet driver is
 * not ready.  PHY drivers may set this in the probe function.
 * If they do, they are responsible for making sure the state is
 * eventually set to indicate whether the PHY is UP or READY,
 * depending on the state when the PHY is done starting up.
 * - PHY driver will set the state to READY
 * - start will set the state to PENDING
 *
 * READY: PHY is ready to send and receive packets, but the
 * controller is not.  By default, PHYs which do not implement
 * probe will be set to this state by phy_probe().  If the PHY
 * driver knows the PHY is ready, and the PHY state is STARTING,
 * then it sets this STATE.
 * - start will set the state to UP
 *
 * PENDING: PHY device is coming up, but the ethernet driver is
 * ready.  phy_start will set this state if the PHY state is
 * STARTING.
 * - PHY driver will set the state to UP when the PHY is ready
 *
 * UP: The PHY and attached device are ready to do work.
 * Interrupts should be started here.
 * - timer moves to AN
 *
 * AN: The PHY is currently negotiating the link state.  Link is
 * therefore down for now.  phy_timer will set this state when it
 * detects the state is UP.  config_aneg will set this state
 * whenever called with phydev->autoneg set to AUTONEG_ENABLE.
 * - If autonegotiation finishes, but there's no link, it sets
 *   the state to NOLINK.
 * - If aneg finishes with link, it sets the state to RUNNING,
 *   and calls adjust_link
 * - If autonegotiation did not finish after an arbitrary amount
 *   of time, autonegotiation should be tried again if the PHY
 *   supports "magic" autonegotiation (back to AN)
 * - If it didn't finish, and no magic_aneg, move to FORCING.
 *
 * NOLINK: PHY is up, but not currently plugged in.
 * - If the timer notes that the link comes back, we move to RUNNING
 * - config_aneg moves to AN
 * - phy_stop moves to HALTED
 *
 * FORCING: PHY is being configured with forced settings
 * - if link is up, move to RUNNING
 * - If link is down, we drop to the next highest setting, and
 *   retry (FORCING) after a timeout
 * - phy_stop moves to HALTED
 *
 * RUNNING: PHY is currently up, running, and possibly sending
 * and/or receiving packets
 * - timer will set CHANGELINK if we're polling (this ensures the
 *   link state is polled every other cycle of this state machine,
 *   which makes it every other second)
 * - irq will set CHANGELINK
 * - config_aneg will set AN
 * - phy_stop moves to HALTED
 *
 * CHANGELINK: PHY experienced a change in link state
 * - timer moves to RUNNING if link
 * - timer moves to NOLINK if the link is down
 * - phy_stop moves to HALTED
 *
 * HALTED: PHY is up, but no polling or interrupts are done. Or
 * PHY is in an error state.
 *
 * - phy_start moves to RESUMING
 *
 * RESUMING: PHY was halted, but now wants to run again.
 * - If we are forcing, or aneg is done, timer moves to RUNNING
 * - If aneg is not done, timer moves to AN
 * - phy_stop moves to HALTED
 */
enum phy_state {
332
	PHY_DOWN = 0,
333 334 335 336 337 338 339 340 341 342 343 344 345
	PHY_STARTING,
	PHY_READY,
	PHY_PENDING,
	PHY_UP,
	PHY_AN,
	PHY_RUNNING,
	PHY_NOLINK,
	PHY_FORCING,
	PHY_CHANGELINK,
	PHY_HALTED,
	PHY_RESUMING
};

346 347 348 349 350 351 352 353 354
/**
 * struct phy_c45_device_ids - 802.3-c45 Device Identifiers
 * @devices_in_package: Bit vector of devices present.
 * @device_ids: The device identifer for each present device.
 */
struct phy_c45_device_ids {
	u32 devices_in_package;
	u32 device_ids[8];
};
355

356 357 358 359
/* phy_device: An instance of a PHY
 *
 * drv: Pointer to the driver for this PHY instance
 * phy_id: UID for this device found during discovery
360 361
 * c45_ids: 802.3-c45 Device Identifers if is_c45.
 * is_c45:  Set to true if this phy uses clause 45 addressing.
362
 * is_internal: Set to true if this phy is internal to a MAC.
363
 * is_pseudo_fixed_link: Set to true if this phy is an Ethernet switch, etc.
364
 * has_fixups: Set to true if this phy has fixups/quirks.
365
 * suspended: Set to true if this phy has been suspended successfully.
366 367 368 369 370 371
 * state: state of the PHY for management purposes
 * dev_flags: Device-specific flags used by the PHY driver.
 * link_timeout: The number of timer firings to wait before the
 * giving up on the current attempt at acquiring a link
 * irq: IRQ number of the PHY's interrupt (-1 if none)
 * phy_timer: The timer for handling the state machine
372
 * phy_queue: A work_queue for the phy_mac_interrupt
373 374 375 376
 * attached_dev: The attached enet driver's device instance ptr
 * adjust_link: Callback for the enet controller to respond to
 * changes in the link state.
 *
377 378
 * speed, duplex, pause, supported, advertising, lp_advertising,
 * and autoneg are used like in mii_if_info
379 380 381 382 383 384 385 386 387
 *
 * interrupts currently only supports enabled or disabled,
 * but could be changed in the future to support enabling
 * and disabling specific interrupts
 *
 * Contains some infrastructure for polling and interrupt
 * handling, as well as handling shifts in PHY hardware state
 */
struct phy_device {
A
Andrew Lunn 已提交
388 389
	struct mdio_device mdio;

390 391 392 393 394 395
	/* Information about the PHY type */
	/* And management functions */
	struct phy_driver *drv;

	u32 phy_id;

396 397
	struct phy_c45_device_ids c45_ids;
	bool is_c45;
398
	bool is_internal;
399
	bool is_pseudo_fixed_link;
400
	bool has_fixups;
401
	bool suspended;
402

403 404 405 406
	enum phy_state state;

	u32 dev_flags;

407 408
	phy_interface_t interface;

A
Andy Fleming 已提交
409 410
	/*
	 * forced speed & duplex (no autoneg)
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
	 * partner speed & duplex & pause (autoneg)
	 */
	int speed;
	int duplex;
	int pause;
	int asym_pause;

	/* The most recently read link state */
	int link;

	/* Enabled Interrupts */
	u32 interrupts;

	/* Union of PHY and Attached devices' supported modes */
	/* See mii.h for more info */
	u32 supported;
	u32 advertising;
428
	u32 lp_advertising;
429

430 431 432
	/* Energy efficient ethernet modes which should be prohibited */
	u32 eee_broken_modes;

433 434 435 436
	int autoneg;

	int link_timeout;

437 438 439 440 441 442
#ifdef CONFIG_LED_TRIGGER_PHY
	struct phy_led_trigger *phy_led_triggers;
	unsigned int phy_num_led_triggers;
	struct phy_led_trigger *last_triggered;
#endif

A
Andy Fleming 已提交
443 444 445 446
	/*
	 * Interrupt number for this PHY
	 * -1 means no interrupt
	 */
447 448 449 450 451 452 453 454
	int irq;

	/* private data pointer */
	/* For use by PHYs to maintain extra state */
	void *priv;

	/* Interrupt and Polling infrastructure */
	struct work_struct phy_queue;
455
	struct delayed_work state_queue;
456
	atomic_t irq_disable;
457

458
	struct mutex lock;
459 460 461

	struct net_device *attached_dev;

462
	u8 mdix;
463
	u8 mdix_ctrl;
464

465 466
	void (*adjust_link)(struct net_device *dev);
};
A
Andrew Lunn 已提交
467 468
#define to_phy_device(d) container_of(to_mdio_device(d), \
				      struct phy_device, mdio)
469 470 471

/* struct phy_driver: Driver structure for a particular PHY type
 *
472
 * driver_data: static driver data
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
 * phy_id: The result of reading the UID registers of this PHY
 *   type, and ANDing them with the phy_id_mask.  This driver
 *   only works for PHYs with IDs which match this field
 * name: The friendly name of this PHY type
 * phy_id_mask: Defines the important bits of the phy_id
 * features: A list of features (speed, duplex, etc) supported
 *   by this PHY
 * flags: A bitfield defining certain other features this PHY
 *   supports (like interrupts)
 *
 * The drivers must implement config_aneg and read_status.  All
 * other functions are optional. Note that none of these
 * functions should be called from interrupt time.  The goal is
 * for the bus read/write functions to be able to block when the
 * bus transaction is happening, and be freed up by an interrupt
 * (The MPC85xx has this ability, though it is not currently
 * supported in the driver).
 */
struct phy_driver {
492
	struct mdio_driver_common mdiodrv;
493 494 495 496 497
	u32 phy_id;
	char *name;
	unsigned int phy_id_mask;
	u32 features;
	u32 flags;
498
	const void *driver_data;
499

A
Andy Fleming 已提交
500
	/*
501 502 503 504 505
	 * Called to issue a PHY software reset
	 */
	int (*soft_reset)(struct phy_device *phydev);

	/*
A
Andy Fleming 已提交
506 507 508
	 * Called to initialize the PHY,
	 * including after a reset
	 */
509 510
	int (*config_init)(struct phy_device *phydev);

A
Andy Fleming 已提交
511 512 513 514
	/*
	 * Called during discovery.  Used to set
	 * up device-specific structures, if any
	 */
515 516 517 518 519 520
	int (*probe)(struct phy_device *phydev);

	/* PHY Power Management */
	int (*suspend)(struct phy_device *phydev);
	int (*resume)(struct phy_device *phydev);

A
Andy Fleming 已提交
521 522
	/*
	 * Configures the advertisement and resets
523 524
	 * autonegotiation if phydev->autoneg is on,
	 * forces the speed to the current settings in phydev
A
Andy Fleming 已提交
525 526
	 * if phydev->autoneg is off
	 */
527 528
	int (*config_aneg)(struct phy_device *phydev);

529 530 531
	/* Determines the auto negotiation result */
	int (*aneg_done)(struct phy_device *phydev);

532 533 534 535 536 537 538 539 540
	/* Determines the negotiated speed and duplex */
	int (*read_status)(struct phy_device *phydev);

	/* Clears any pending interrupts */
	int (*ack_interrupt)(struct phy_device *phydev);

	/* Enables or disables interrupts */
	int (*config_intr)(struct phy_device *phydev);

541 542 543 544 545 546
	/*
	 * Checks if the PHY generated an interrupt.
	 * For multi-PHY devices with shared PHY interrupt pin
	 */
	int (*did_interrupt)(struct phy_device *phydev);

547 548 549
	/* Clears up any memory if needed */
	void (*remove)(struct phy_device *phydev);

550 551 552 553 554 555
	/* Returns true if this is a suitable driver for the given
	 * phydev.  If NULL, matching is based on phy_id and
	 * phy_id_mask.
	 */
	int (*match_phy_device)(struct phy_device *phydev);

556 557 558
	/* Handles ethtool queries for hardware time stamping. */
	int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti);

559 560 561 562 563 564 565 566 567 568 569 570 571 572
	/* Handles SIOCSHWTSTAMP ioctl for hardware time stamping. */
	int  (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr);

	/*
	 * Requests a Rx timestamp for 'skb'. If the skb is accepted,
	 * the phy driver promises to deliver it using netif_rx() as
	 * soon as a timestamp becomes available. One of the
	 * PTP_CLASS_ values is passed in 'type'. The function must
	 * return true if the skb is accepted for delivery.
	 */
	bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);

	/*
	 * Requests a Tx timestamp for 'skb'. The phy driver promises
573
	 * to deliver it using skb_complete_tx_timestamp() as soon as a
574 575 576 577 578
	 * timestamp becomes available. One of the PTP_CLASS_ values
	 * is passed in 'type'.
	 */
	void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);

579 580 581 582 583 584 585 586
	/* Some devices (e.g. qnap TS-119P II) require PHY register changes to
	 * enable Wake on LAN, so set_wol is provided to be called in the
	 * ethernet driver's set_wol function. */
	int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);

	/* See set_wol, but for checking whether Wake on LAN is enabled. */
	void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);

587 588 589 590 591 592 593 594 595
	/*
	 * Called to inform a PHY device driver when the core is about to
	 * change the link state. This callback is supposed to be used as
	 * fixup hook for drivers that need to take action when the link
	 * state changes. Drivers are by no means allowed to mess with the
	 * PHY device structure in their implementations.
	 */
	void (*link_change_notify)(struct phy_device *dev);

596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
	/*
	 * Phy specific driver override for reading a MMD register.
	 * This function is optional for PHY specific drivers.  When
	 * not provided, the default MMD read function will be used
	 * by phy_read_mmd(), which will use either a direct read for
	 * Clause 45 PHYs or an indirect read for Clause 22 PHYs.
	 *  devnum is the MMD device number within the PHY device,
	 *  regnum is the register within the selected MMD device.
	 */
	int (*read_mmd)(struct phy_device *dev, int devnum, u16 regnum);

	/*
	 * Phy specific driver override for writing a MMD register.
	 * This function is optional for PHY specific drivers.  When
	 * not provided, the default MMD write function will be used
	 * by phy_write_mmd(), which will use either a direct write for
	 * Clause 45 PHYs, or an indirect write for Clause 22 PHYs.
	 *  devnum is the MMD device number within the PHY device,
	 *  regnum is the register within the selected MMD device.
	 *  val is the value to be written.
	 */
	int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum,
			 u16 val);

620 621 622 623 624 625 626 627 628
	/* Get the size and type of the eeprom contained within a plug-in
	 * module */
	int (*module_info)(struct phy_device *dev,
			   struct ethtool_modinfo *modinfo);

	/* Get the eeprom information from the plug-in module */
	int (*module_eeprom)(struct phy_device *dev,
			     struct ethtool_eeprom *ee, u8 *data);

A
Andrew Lunn 已提交
629 630 631 632 633
	/* Get statistics from the phy using ethtool */
	int (*get_sset_count)(struct phy_device *dev);
	void (*get_strings)(struct phy_device *dev, u8 *data);
	void (*get_stats)(struct phy_device *dev,
			  struct ethtool_stats *stats, u64 *data);
634 635 636 637 638 639 640

	/* Get and Set PHY tunables */
	int (*get_tunable)(struct phy_device *dev,
			   struct ethtool_tunable *tuna, void *data);
	int (*set_tunable)(struct phy_device *dev,
			    struct ethtool_tunable *tuna,
			    const void *data);
641
};
642 643
#define to_phy_driver(d) container_of(to_mdio_common_driver(d),		\
				      struct phy_driver, mdiodrv)
644

645 646 647 648 649 650
#define PHY_ANY_ID "MATCH ANY PHY"
#define PHY_ANY_UID 0xffffffff

/* A Structure for boards to register fixups with the PHY Lib */
struct phy_fixup {
	struct list_head list;
651
	char bus_id[MII_BUS_ID_SIZE + 3];
652 653 654 655 656
	u32 phy_uid;
	u32 phy_uid_mask;
	int (*run)(struct phy_device *phydev);
};

657 658 659 660 661 662 663 664 665
/**
 * phy_read_mmd - Convenience function for reading a register
 * from an MMD on a given PHY.
 * @phydev: The phy_device struct
 * @devad: The MMD to read from
 * @regnum: The register on the MMD to read
 *
 * Same rules as for phy_read();
 */
666
int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum);
667

668 669 670 671 672 673 674 675 676
/**
 * phy_read - Convenience function for reading a given PHY register
 * @phydev: the phy_device struct
 * @regnum: register number to read
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
677
static inline int phy_read(struct phy_device *phydev, u32 regnum)
678
{
A
Andrew Lunn 已提交
679
	return mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum);
680 681 682 683 684 685 686 687 688 689 690 691
}

/**
 * phy_write - Convenience function for writing a given PHY register
 * @phydev: the phy_device struct
 * @regnum: register number to write
 * @val: value to write to @regnum
 *
 * NOTE: MUST NOT be called from interrupt context,
 * because the bus read/write functions may wait for an interrupt
 * to conclude the operation.
 */
692
static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
693
{
A
Andrew Lunn 已提交
694
	return mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum, val);
695 696
}

697 698 699 700 701 702 703 704 705 706 707 708
/**
 * phy_interrupt_is_valid - Convenience function for testing a given PHY irq
 * @phydev: the phy_device struct
 *
 * NOTE: must be kept in sync with addition/removal of PHY_POLL and
 * PHY_IGNORE_INTERRUPT
 */
static inline bool phy_interrupt_is_valid(struct phy_device *phydev)
{
	return phydev->irq != PHY_POLL && phydev->irq != PHY_IGNORE_INTERRUPT;
}

709 710 711 712 713 714 715 716 717
/**
 * phy_is_internal - Convenience function for testing if a PHY is internal
 * @phydev: the phy_device struct
 */
static inline bool phy_is_internal(struct phy_device *phydev)
{
	return phydev->is_internal;
}

718 719 720 721 722 723 724 725 726
/**
 * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
 * is RGMII (all variants)
 * @phydev: the phy_device struct
 */
static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
{
	return phydev->interface >= PHY_INTERFACE_MODE_RGMII &&
		phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID;
727 728 729 730 731 732 733 734 735 736
};

/*
 * phy_is_pseudo_fixed_link - Convenience function for testing if this
 * PHY is the CPU port facing side of an Ethernet switch, or similar.
 * @phydev: the phy_device struct
 */
static inline bool phy_is_pseudo_fixed_link(struct phy_device *phydev)
{
	return phydev->is_pseudo_fixed_link;
737 738
}

739 740 741 742 743 744 745 746 747 748
/**
 * phy_write_mmd - Convenience function for writing a register
 * on an MMD on a given PHY.
 * @phydev: The phy_device struct
 * @devad: The MMD to read from
 * @regnum: The register on the MMD to read
 * @val: value to write to @regnum
 *
 * Same rules as for phy_write();
 */
749
int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
750

751
struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
752 753
				     bool is_c45,
				     struct phy_c45_device_ids *c45_ids);
754
#if IS_ENABLED(CONFIG_PHYLIB)
755
struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45);
756
int phy_device_register(struct phy_device *phy);
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
void phy_device_free(struct phy_device *phydev);
#else
static inline
struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45)
{
	return NULL;
}

static inline int phy_device_register(struct phy_device *phy)
{
	return 0;
}

static inline void phy_device_free(struct phy_device *phydev) { }
#endif /* CONFIG_PHYLIB */
R
Russell King 已提交
772
void phy_device_remove(struct phy_device *phydev);
773
int phy_init_hw(struct phy_device *phydev);
774 775
int phy_suspend(struct phy_device *phydev);
int phy_resume(struct phy_device *phydev);
776 777
struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
			      phy_interface_t interface);
J
Jiri Pirko 已提交
778
struct phy_device *phy_find_first(struct mii_bus *bus);
779 780
int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
		      u32 flags, phy_interface_t interface);
781
int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
782 783 784 785 786
		       void (*handler)(struct net_device *),
		       phy_interface_t interface);
struct phy_device *phy_connect(struct net_device *dev, const char *bus_id,
			       void (*handler)(struct net_device *),
			       phy_interface_t interface);
A
Andy Fleming 已提交
787 788 789 790 791
void phy_disconnect(struct phy_device *phydev);
void phy_detach(struct phy_device *phydev);
void phy_start(struct phy_device *phydev);
void phy_stop(struct phy_device *phydev);
int phy_start_aneg(struct phy_device *phydev);
792
int phy_aneg_done(struct phy_device *phydev);
A
Andy Fleming 已提交
793 794

int phy_stop_interrupts(struct phy_device *phydev);
795

796 797
static inline int phy_read_status(struct phy_device *phydev)
{
F
Florian Fainelli 已提交
798 799 800
	if (!phydev->drv)
		return -EIO;

801 802 803
	return phydev->drv->read_status(phydev);
}

804
#define phydev_err(_phydev, format, args...)	\
A
Andrew Lunn 已提交
805
	dev_err(&_phydev->mdio.dev, format, ##args)
806 807

#define phydev_dbg(_phydev, format, args...)	\
A
Andrew Lunn 已提交
808
	dev_dbg(&_phydev->mdio.dev, format, ##args);
809

A
Andrew Lunn 已提交
810 811
static inline const char *phydev_name(const struct phy_device *phydev)
{
A
Andrew Lunn 已提交
812
	return dev_name(&phydev->mdio.dev);
A
Andrew Lunn 已提交
813 814
}

815 816 817
void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
	__printf(2, 3);
void phy_attached_info(struct phy_device *phydev);
818
int genphy_config_init(struct phy_device *phydev);
819
int genphy_setup_forced(struct phy_device *phydev);
820 821
int genphy_restart_aneg(struct phy_device *phydev);
int genphy_config_aneg(struct phy_device *phydev);
822
int genphy_aneg_done(struct phy_device *phydev);
823 824
int genphy_update_link(struct phy_device *phydev);
int genphy_read_status(struct phy_device *phydev);
G
Giuseppe Cavallaro 已提交
825 826
int genphy_suspend(struct phy_device *phydev);
int genphy_resume(struct phy_device *phydev);
827
int genphy_soft_reset(struct phy_device *phydev);
828 829 830 831
static inline int genphy_no_soft_reset(struct phy_device *phydev)
{
	return 0;
}
832
void phy_driver_unregister(struct phy_driver *drv);
833
void phy_drivers_unregister(struct phy_driver *drv, int n);
834 835 836
int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
int phy_drivers_register(struct phy_driver *new_driver, int n,
			 struct module *owner);
837
void phy_state_machine(struct work_struct *work);
838 839
void phy_change(struct phy_device *phydev);
void phy_change_work(struct work_struct *work);
840
void phy_mac_interrupt(struct phy_device *phydev, int new_link);
841
void phy_start_machine(struct phy_device *phydev);
842
void phy_stop_machine(struct phy_device *phydev);
843
void phy_trigger_machine(struct phy_device *phydev, bool sync);
844 845
int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
int phy_ethtool_gset(struct phy_device *phydev, struct ethtool_cmd *cmd);
846 847 848 849
int phy_ethtool_ksettings_get(struct phy_device *phydev,
			      struct ethtool_link_ksettings *cmd);
int phy_ethtool_ksettings_set(struct phy_device *phydev,
			      const struct ethtool_link_ksettings *cmd);
850
int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd);
A
Andy Fleming 已提交
851 852
int phy_start_interrupts(struct phy_device *phydev);
void phy_print_status(struct phy_device *phydev);
853
int phy_set_max_speed(struct phy_device *phydev, u32 max_speed);
854

855
int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
856
		       int (*run)(struct phy_device *));
857
int phy_register_fixup_for_id(const char *bus_id,
858
			      int (*run)(struct phy_device *));
859
int phy_register_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask,
860
			       int (*run)(struct phy_device *));
861

862 863 864 865
int phy_unregister_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask);
int phy_unregister_fixup_for_id(const char *bus_id);
int phy_unregister_fixup_for_uid(u32 phy_uid, u32 phy_uid_mask);

866 867 868 869
int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable);
int phy_get_eee_err(struct phy_device *phydev);
int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data);
int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data);
870
int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol);
871 872
void phy_ethtool_get_wol(struct phy_device *phydev,
			 struct ethtool_wolinfo *wol);
873 874 875 876
int phy_ethtool_get_link_ksettings(struct net_device *ndev,
				   struct ethtool_link_ksettings *cmd);
int phy_ethtool_set_link_ksettings(struct net_device *ndev,
				   const struct ethtool_link_ksettings *cmd);
877
int phy_ethtool_nway_reset(struct net_device *ndev);
878

879
#if IS_ENABLED(CONFIG_PHYLIB)
A
Andy Fleming 已提交
880 881
int __init mdio_bus_init(void);
void mdio_bus_exit(void);
882
#endif
A
Andy Fleming 已提交
883

884
extern struct bus_type mdio_bus_type;
885

886 887 888 889 890 891 892
struct mdio_board_info {
	const char	*bus_id;
	char		modalias[MDIO_NAME_SIZE];
	int		mdio_addr;
	const void	*platform_data;
};

893
#if IS_ENABLED(CONFIG_MDIO_DEVICE)
894 895 896 897 898 899 900 901 902 903 904
int mdiobus_register_board_info(const struct mdio_board_info *info,
				unsigned int n);
#else
static inline int mdiobus_register_board_info(const struct mdio_board_info *i,
					      unsigned int n)
{
	return 0;
}
#endif


905 906 907 908 909 910 911 912 913 914 915
/**
 * module_phy_driver() - Helper macro for registering PHY drivers
 * @__phy_drivers: array of PHY drivers to register
 *
 * Helper macro for PHY drivers which do not do anything special in module
 * init/exit. Each module may only use this macro once, and calling it
 * replaces module_init() and module_exit().
 */
#define phy_module_driver(__phy_drivers, __count)			\
static int __init phy_module_init(void)					\
{									\
916
	return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \
917 918 919 920 921 922 923 924 925 926 927
}									\
module_init(phy_module_init);						\
static void __exit phy_module_exit(void)				\
{									\
	phy_drivers_unregister(__phy_drivers, __count);			\
}									\
module_exit(phy_module_exit)

#define module_phy_driver(__phy_drivers)				\
	phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers))

928
#endif /* __PHY_H */