/src/u-boot/include/phy.h

Source
/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright 2011 Freescale Semiconductor, Inc.
 *  Andy Fleming <afleming@gmail.com>
 *
 * This file pretty much stolen from Linux's mii.h/ethtool.h/phy.h
 */

#ifndef _PHY_H
#define _PHY_H

#include <asm-generic/gpio.h>
#include <log.h>
#include <phy_interface.h>
#include <dm/ofnode.h>
#include <dm/read.h>
#include <linux/errno.h>
#include <linux/list.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/mdio.h>

struct udevice;

#define PHY_FIXED_ID    0xa5a55a5a
#define PHY_NCSI_ID            0xbeefcafe

/*
 * There is no actual id for this.
 * This is just a dummy id for gmii2rgmmi converter.
 */
#define PHY_GMII2RGMII_ID 0x5a5a5a5a

#define PHY_MAX_ADDR 32

#define PHY_FLAG_BROKEN_RESET (1 << 0) /* soft reset not supported */

#define PHY_DEFAULT_FEATURES  (SUPPORTED_Autoneg | \
         SUPPORTED_TP | \
         SUPPORTED_MII)

#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 | \
         SUPPORTED_1000baseT_Full)

#define PHY_BASIC_FEATURES  (PHY_10BT_FEATURES | \
         PHY_100BT_FEATURES | \
         PHY_DEFAULT_FEATURES)

#define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES | \
         PHY_1000BT_FEATURES)

#define PHY_10G_FEATURES  (PHY_GBIT_FEATURES | \
        SUPPORTED_10000baseT_Full)

struct phy_device;

#define MDIO_NAME_LEN 32

struct mii_dev {
  struct list_head link;
  char name[MDIO_NAME_LEN];
  void *priv;
  int (*read)(struct mii_dev *bus, int addr, int devad, int reg);
  int (*write)(struct mii_dev *bus, int addr, int devad, int reg,
      u16 val);
  int (*reset)(struct mii_dev *bus);
  struct phy_device *phymap[PHY_MAX_ADDR];
  u32 phy_mask;
  /** @reset_delay_us: Bus GPIO reset pulse width in microseconds */
  int reset_delay_us;
  /** @reset_post_delay_us: Bus GPIO reset deassert delay in microseconds */
  int reset_post_delay_us;
  /** @reset_gpiod: Bus Reset GPIO descriptor pointer */
  struct gpio_desc reset_gpiod;
};

/* struct phy_driver: a structure which defines PHY behavior
 *
 * uid will contain a number which represents the PHY.  During
 * startup, the driver will poll the PHY to find out what its
 * UID--as defined by registers 2 and 3--is.  The 32-bit result
 * gotten from the PHY will be masked to
 * discard any bits which may change based on revision numbers
 * unimportant to functionality
 *
 */
struct phy_driver {
  char *name;
  unsigned int uid;
  unsigned int mask;
  unsigned int mmds;

  u32 features;

  /* Called to do any driver startup necessities */
  /* Will be called during phy_connect */
  int (*probe)(struct phy_device *phydev);

  /* Called to configure the PHY, and modify the controller
   * based on the results.  Should be called after phy_connect */
  int (*config)(struct phy_device *phydev);

  /* Called when starting up the controller */
  int (*startup)(struct phy_device *phydev);

  /* Called when bringing down the controller */
  int (*shutdown)(struct phy_device *phydev);

  int (*readext)(struct phy_device *phydev, int addr, int devad, int reg);
  int (*writeext)(struct phy_device *phydev, int addr, int devad, int reg,
      u16 val);

  /* Phy specific driver override for reading a MMD register */
  int (*read_mmd)(struct phy_device *phydev, int devad, int reg);

  /* Phy specific driver override for writing a MMD register */
  int (*write_mmd)(struct phy_device *phydev, int devad, int reg,
       u16 val);

  /** @read_page: Return the current PHY register page number */
  int (*read_page)(struct phy_device *phydev);
  /** @write_page: Set the current PHY register page number */
  int (*write_page)(struct phy_device *phydev, int page);

  /* driver private data */
  ulong data;
};

struct phy_device {
  /* Information about the PHY type */
  /* And management functions */
  struct mii_dev *bus;
  struct phy_driver *drv;
  void *priv;

  struct udevice *dev;
  ofnode node;

  /* forced speed & duplex (no autoneg)
   * partner speed & duplex & pause (autoneg)
   */
  int speed;
  int duplex;

  /* The most recently read link state */
  int link;
  int port;
  phy_interface_t interface;

  u32 advertising;
  u32 supported;
  u32 mmds;

  int autoneg;
  int addr;
  int pause;
  int asym_pause;
  u32 phy_id;
  bool is_c45;
  u32 flags;
};

struct fixed_link {
  int phy_id;
  int duplex;
  int link_speed;
  int pause;
  int asym_pause;
};

/**
 * phy_reset() - Resets the specified PHY
 * Issues a reset of the PHY and waits for it to complete
 *
 * @phydev: PHY to reset
 * @return: 0 if OK, -ve on error
 */
int phy_reset(struct phy_device *phydev);

/**
 * phy_gpio_reset() - Resets the specified PHY using GPIO reset
 * Toggles the optional PHY reset GPIO
 *
 * @dev:  PHY udevice to reset
 * @return: 0 if OK, -ve on error
 */
int phy_gpio_reset(struct udevice *dev);

/**
 * phy_find_by_mask() - Searches for a PHY on the specified MDIO bus
 * The function checks the PHY addresses flagged in phy_mask and returns a
 * phy_device pointer if it detects a PHY.
 * This function should only be called if just one PHY is expected to be present
 * in the set of addresses flagged in phy_mask.  If multiple PHYs are present,
 * it is undefined which of these PHYs is returned.
 *
 * @bus:  MII/MDIO bus to scan
 * @phy_mask: bitmap of PYH addresses to scan
 * @return: pointer to phy_device if a PHY is found, or NULL otherwise
 */
struct phy_device *phy_find_by_mask(struct mii_dev *bus, unsigned phy_mask);

#ifdef CONFIG_PHY_FIXED

/**
 * fixed_phy_create() - create an unconnected fixed-link pseudo-PHY device
 * @node: OF node for the container of the fixed-link node
 *
 * Description: Creates a struct phy_device based on a fixed-link of_node
 * description. Can be used without phy_connect by drivers which do not expose
 * a UCLASS_ETH udevice.
 */
struct phy_device *fixed_phy_create(ofnode node);

#else

static inline struct phy_device *fixed_phy_create(ofnode node)
{
  return NULL;
}

#endif

/**
 * phy_connect() - Creates a PHY device for the Ethernet interface
 * Creates a PHY device for the PHY at the given address, if one doesn't exist
 * already, and associates it with the Ethernet device.
 * The function may be called with addr <= 0, in this case addr value is ignored
 * and the bus is scanned to detect a PHY.  Scanning should only be used if only
 * one PHY is expected to be present on the MDIO bus, otherwise it is undefined
 * which PHY is returned.
 *
 * @bus:  MII/MDIO bus that hosts the PHY
 * @addr: PHY address on MDIO bus
 * @dev:  Ethernet device to associate to the PHY
 * @interface:  type of MAC-PHY interface
 * @return: pointer to phy_device if a PHY is found, or NULL otherwise
 */
struct phy_device *phy_connect(struct mii_dev *bus, int addr,
        struct udevice *dev,
        phy_interface_t interface);
/**
 * phy_device_create() - Create a PHY device
 *
 * @bus:    MII/MDIO bus that hosts the PHY
 * @addr:   PHY address on MDIO bus
 * @phy_id:   where to store the ID retrieved
 * @is_c45:   Device Identifiers if is_c45
 * @return: pointer to phy_device if a PHY is found, or NULL otherwise
 */
struct phy_device *phy_device_create(struct mii_dev *bus, int addr,
             u32 phy_id, bool is_c45);

/**
 * phy_connect_phy_id() - Connect to phy device by reading PHY id
 *        from phy node.
 *
 * @bus:    MII/MDIO bus that hosts the PHY
 * @dev:    Ethernet device to associate to the PHY
 * @return:   pointer to phy_device if a PHY is found,
 *      or NULL otherwise
 */
struct phy_device *phy_connect_phy_id(struct mii_dev *bus, struct udevice *dev,
              int phyaddr);

static inline ofnode phy_get_ofnode(struct phy_device *phydev)
{
  if (ofnode_valid(phydev->node))
    return phydev->node;
  else
    return dev_ofnode(phydev->dev);
}

/**
 * phy_read_mmd_poll_timeout - Periodically poll a PHY register until a
 *                             condition is met or a timeout occurs
 *
 * @phydev: The phy_device struct
 * @devaddr: The MMD to read from
 * @regnum: The register on the MMD to read
 * @val: Variable to read the register into
 * @cond: Break condition (usually involving @val)
 * @sleep_us: Maximum time to sleep between reads in us (0
 *            tight-loops).  Should be less than ~20ms since usleep_range
 *            is used (see Documentation/timers/timers-howto.rst).
 * @timeout_us: Timeout in us, 0 means never timeout
 * @sleep_before_read: if it is true, sleep @sleep_us before read.
 * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
 * case, the last read value at @args is stored in @val. Must not
 * be called from atomic context if sleep_us or timeout_us are used.
 */
#define phy_read_mmd_poll_timeout(phydev, devaddr, regnum, val, cond, \
          sleep_us, timeout_us, sleep_before_read) \
({ \
  int __ret = read_poll_timeout(phy_read_mmd, val, (cond) || val < 0, \
          sleep_us, timeout_us, \
          phydev, devaddr, regnum); \
  if (val <  0) \
    __ret = val; \
  if (__ret) \
    dev_err(phydev->dev, "%s failed: %d\n", __func__, __ret); \
  __ret; \
})

int phy_read(struct phy_device *phydev, int devad, int regnum);
int phy_write(struct phy_device *phydev, int devad, int regnum, u16 val);
void phy_mmd_start_indirect(struct phy_device *phydev, int devad, int regnum);
int phy_read_mmd(struct phy_device *phydev, int devad, int regnum);
int phy_write_mmd(struct phy_device *phydev, int devad, int regnum, u16 val);
int phy_set_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
int phy_clear_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
         u16 mask, u16 set);
int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
       u16 mask, u16 set);
int phy_save_page(struct phy_device *phydev);
int phy_select_page(struct phy_device *phydev, int page);
int phy_restore_page(struct phy_device *phydev, int oldpage, int ret);

int phy_startup(struct phy_device *phydev);
int phy_config(struct phy_device *phydev);
int phy_shutdown(struct phy_device *phydev);
int phy_set_supported(struct phy_device *phydev, u32 max_speed);
int phy_modify(struct phy_device *phydev, int devad, int regnum, u16 mask,
         u16 set);
int genphy_config_aneg(struct phy_device *phydev);
int genphy_restart_aneg(struct phy_device *phydev);
int genphy_update_link(struct phy_device *phydev);
int genphy_parse_link(struct phy_device *phydev);
int genphy_config(struct phy_device *phydev);
int genphy_startup(struct phy_device *phydev);
int genphy_shutdown(struct phy_device *phydev);
int gen10g_config(struct phy_device *phydev);
int gen10g_startup(struct phy_device *phydev);
int gen10g_shutdown(struct phy_device *phydev);
int gen10g_discover_mmds(struct phy_device *phydev);

/**
 * phy_set_bits - Convenience function for setting bits in a PHY register
 * @phydev: the phy_device struct
 * @devad: The MMD to read from
 * @regnum: register number to write
 * @val: bits to set
 */
static inline int phy_set_bits(struct phy_device *phydev, int devad, u32 regnum, u16 val)
{
  return phy_modify(phydev, devad, regnum, 0, val);
}

/**
 * phy_clear_bits - Convenience function for clearing bits in a PHY register
 * @phydev: the phy_device struct
 * @devad: The MMD to write to
 * @regnum: register number to write
 * @val: bits to clear
 */
static inline int phy_clear_bits(struct phy_device *phydev, int devad, u32 regnum, u16 val)
{
  return phy_modify(phydev, devad, regnum, val, 0);
}

/**
 * U_BOOT_PHY_DRIVER() - Declare a new U-Boot driver
 * @__name: name of the driver
 */
#define U_BOOT_PHY_DRIVER(__name)         \
  ll_entry_declare(struct phy_driver, __name, phy_driver)

int board_phy_config(struct phy_device *phydev);
int get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id);

/**
 * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
 * is RGMII (all variants)
 * @phydev: the phy_device struct
 * @return: true if MII bus is RGMII or false if it is not
 */
static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
{
  switch (phydev->interface) {
  case PHY_INTERFACE_MODE_RGMII:
  case PHY_INTERFACE_MODE_RGMII_ID:
  case PHY_INTERFACE_MODE_RGMII_RXID:
  case PHY_INTERFACE_MODE_RGMII_TXID:
    return 1;
  default:
    return 0;
  }
}

bool phy_interface_is_ncsi(void);

/* PHY UIDs for various PHYs that are referenced in external code */
#define PHY_UID_CS4340    0x13e51002
#define PHY_UID_CS4223    0x03e57003
#define PHY_UID_TN2020    0x00a19410
#define PHY_UID_IN112525_S03  0x02107440

#endif

Coverage Report

Created: 2026-03-11 06:21

Line	Count	Source
1		/* SPDX-License-Identifier: GPL-2.0+ */
2		/*
3		* Copyright 2011 Freescale Semiconductor, Inc.
4		* Andy Fleming <afleming@gmail.com>
5		*
6		* This file pretty much stolen from Linux's mii.h/ethtool.h/phy.h
7		*/
8
9		#ifndef _PHY_H
10		#define _PHY_H
11
12		#include <asm-generic/gpio.h>
13		#include <log.h>
14		#include <phy_interface.h>
15		#include <dm/ofnode.h>
16		#include <dm/read.h>
17		#include <linux/errno.h>
18		#include <linux/list.h>
19		#include <linux/mii.h>
20		#include <linux/ethtool.h>
21		#include <linux/mdio.h>
22
23		struct udevice;
24
25	0	#define PHY_FIXED_ID 0xa5a55a5a
26	0	#define PHY_NCSI_ID 0xbeefcafe
27
28		/*
29		* There is no actual id for this.
30		* This is just a dummy id for gmii2rgmmi converter.
31		*/
32		#define PHY_GMII2RGMII_ID 0x5a5a5a5a
33
34	0	#define PHY_MAX_ADDR 32
35
36	0	#define PHY_FLAG_BROKEN_RESET (1 << 0) /* soft reset not supported */
37
38	0	#define PHY_DEFAULT_FEATURES (SUPPORTED_Autoneg \| \
39	0	SUPPORTED_TP \| \
40	0	SUPPORTED_MII)
41
42	0	#define PHY_10BT_FEATURES (SUPPORTED_10baseT_Half \| \
43	0	SUPPORTED_10baseT_Full)
44
45	0	#define PHY_100BT_FEATURES (SUPPORTED_100baseT_Half \| \
46	0	SUPPORTED_100baseT_Full)
47
48	0	#define PHY_1000BT_FEATURES (SUPPORTED_1000baseT_Half \| \
49	0	SUPPORTED_1000baseT_Full)
50
51	0	#define PHY_BASIC_FEATURES (PHY_10BT_FEATURES \| \
52	0	PHY_100BT_FEATURES \| \
53	0	PHY_DEFAULT_FEATURES)
54
55	0	#define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES \| \
56	0	PHY_1000BT_FEATURES)
57
58	0	#define PHY_10G_FEATURES (PHY_GBIT_FEATURES \| \
59	0	SUPPORTED_10000baseT_Full)
60
61		struct phy_device;
62
63	0	#define MDIO_NAME_LEN 32
64
65		struct mii_dev {
66		struct list_head link;
67		char name[MDIO_NAME_LEN];
68		void *priv;
69		int (read)(struct mii_dev bus, int addr, int devad, int reg);
70		int (write)(struct mii_dev bus, int addr, int devad, int reg,
71		u16 val);
72		int (reset)(struct mii_dev bus);
73		struct phy_device *phymap[PHY_MAX_ADDR];
74		u32 phy_mask;
75		/** @reset_delay_us: Bus GPIO reset pulse width in microseconds */
76		int reset_delay_us;
77		/** @reset_post_delay_us: Bus GPIO reset deassert delay in microseconds */
78		int reset_post_delay_us;
79		/** @reset_gpiod: Bus Reset GPIO descriptor pointer */
80		struct gpio_desc reset_gpiod;
81		};
82
83		/* struct phy_driver: a structure which defines PHY behavior
84		*
85		* uid will contain a number which represents the PHY. During
86		* startup, the driver will poll the PHY to find out what its
87		* UID--as defined by registers 2 and 3--is. The 32-bit result
88		* gotten from the PHY will be masked to
89		* discard any bits which may change based on revision numbers
90		* unimportant to functionality
91		*
92		*/
93		struct phy_driver {
94		char *name;
95		unsigned int uid;
96		unsigned int mask;
97		unsigned int mmds;
98
99		u32 features;
100
101		/* Called to do any driver startup necessities */
102		/* Will be called during phy_connect */
103		int (probe)(struct phy_device phydev);
104
105		/* Called to configure the PHY, and modify the controller
106		* based on the results. Should be called after phy_connect */
107		int (config)(struct phy_device phydev);
108
109		/* Called when starting up the controller */
110		int (startup)(struct phy_device phydev);
111
112		/* Called when bringing down the controller */
113		int (shutdown)(struct phy_device phydev);
114
115		int (readext)(struct phy_device phydev, int addr, int devad, int reg);
116		int (writeext)(struct phy_device phydev, int addr, int devad, int reg,
117		u16 val);
118
119		/* Phy specific driver override for reading a MMD register */
120		int (read_mmd)(struct phy_device phydev, int devad, int reg);
121
122		/* Phy specific driver override for writing a MMD register */
123		int (write_mmd)(struct phy_device phydev, int devad, int reg,
124		u16 val);
125
126		/** @read_page: Return the current PHY register page number */
127		int (read_page)(struct phy_device phydev);
128		/** @write_page: Set the current PHY register page number */
129		int (write_page)(struct phy_device phydev, int page);
130
131		/* driver private data */
132		ulong data;
133		};
134
135		struct phy_device {
136		/* Information about the PHY type */
137		/* And management functions */
138		struct mii_dev *bus;
139		struct phy_driver *drv;
140		void *priv;
141
142		struct udevice *dev;
143		ofnode node;
144
145		/* forced speed & duplex (no autoneg)
146		* partner speed & duplex & pause (autoneg)
147		*/
148		int speed;
149		int duplex;
150
151		/* The most recently read link state */
152		int link;
153		int port;
154		phy_interface_t interface;
155
156		u32 advertising;
157		u32 supported;
158		u32 mmds;
159
160		int autoneg;
161		int addr;
162		int pause;
163		int asym_pause;
164		u32 phy_id;
165		bool is_c45;
166		u32 flags;
167		};
168
169		struct fixed_link {
170		int phy_id;
171		int duplex;
172		int link_speed;
173		int pause;
174		int asym_pause;
175		};
176
177		/**
178		* phy_reset() - Resets the specified PHY
179		* Issues a reset of the PHY and waits for it to complete
180		*
181		* @phydev: PHY to reset
182		* @return: 0 if OK, -ve on error
183		*/
184		int phy_reset(struct phy_device *phydev);
185
186		/**
187		* phy_gpio_reset() - Resets the specified PHY using GPIO reset
188		* Toggles the optional PHY reset GPIO
189		*
190		* @dev: PHY udevice to reset
191		* @return: 0 if OK, -ve on error
192		*/
193		int phy_gpio_reset(struct udevice *dev);
194
195		/**
196		* phy_find_by_mask() - Searches for a PHY on the specified MDIO bus
197		* The function checks the PHY addresses flagged in phy_mask and returns a
198		* phy_device pointer if it detects a PHY.
199		* This function should only be called if just one PHY is expected to be present
200		* in the set of addresses flagged in phy_mask. If multiple PHYs are present,
201		* it is undefined which of these PHYs is returned.
202		*
203		* @bus: MII/MDIO bus to scan
204		* @phy_mask: bitmap of PYH addresses to scan
205		* @return: pointer to phy_device if a PHY is found, or NULL otherwise
206		*/
207		struct phy_device phy_find_by_mask(struct mii_dev bus, unsigned phy_mask);
208
209		#ifdef CONFIG_PHY_FIXED
210
211		/**
212		* fixed_phy_create() - create an unconnected fixed-link pseudo-PHY device
213		* @node: OF node for the container of the fixed-link node
214		*
215		* Description: Creates a struct phy_device based on a fixed-link of_node
216		* description. Can be used without phy_connect by drivers which do not expose
217		* a UCLASS_ETH udevice.
218		*/
219		struct phy_device *fixed_phy_create(ofnode node);
220
221		#else
222
223		static inline struct phy_device *fixed_phy_create(ofnode node)
224		{
225		return NULL;
226		}
227
228		#endif
229
230		/**
231		* phy_connect() - Creates a PHY device for the Ethernet interface
232		* Creates a PHY device for the PHY at the given address, if one doesn't exist
233		* already, and associates it with the Ethernet device.
234		* The function may be called with addr <= 0, in this case addr value is ignored
235		* and the bus is scanned to detect a PHY. Scanning should only be used if only
236		* one PHY is expected to be present on the MDIO bus, otherwise it is undefined
237		* which PHY is returned.
238		*
239		* @bus: MII/MDIO bus that hosts the PHY
240		* @addr: PHY address on MDIO bus
241		* @dev: Ethernet device to associate to the PHY
242		* @interface: type of MAC-PHY interface
243		* @return: pointer to phy_device if a PHY is found, or NULL otherwise
244		*/
245		struct phy_device phy_connect(struct mii_dev bus, int addr,
246		struct udevice *dev,
247		phy_interface_t interface);
248		/**
249		* phy_device_create() - Create a PHY device
250		*
251		* @bus: MII/MDIO bus that hosts the PHY
252		* @addr: PHY address on MDIO bus
253		* @phy_id: where to store the ID retrieved
254		* @is_c45: Device Identifiers if is_c45
255		* @return: pointer to phy_device if a PHY is found, or NULL otherwise
256		*/
257		struct phy_device phy_device_create(struct mii_dev bus, int addr,
258		u32 phy_id, bool is_c45);
259
260		/**
261		* phy_connect_phy_id() - Connect to phy device by reading PHY id
262		* from phy node.
263		*
264		* @bus: MII/MDIO bus that hosts the PHY
265		* @dev: Ethernet device to associate to the PHY
266		* @return: pointer to phy_device if a PHY is found,
267		* or NULL otherwise
268		*/
269		struct phy_device phy_connect_phy_id(struct mii_dev bus, struct udevice *dev,
270		int phyaddr);
271
272		static inline ofnode phy_get_ofnode(struct phy_device *phydev)
273	0	{
274	0	if (ofnode_valid(phydev->node))
275	0	return phydev->node;
276	0	else
277	0	return dev_ofnode(phydev->dev);
278	0	} Unexecuted instantiation: mii.c:phy_get_ofnode Unexecuted instantiation: mdio.c:phy_get_ofnode Unexecuted instantiation: net.c:phy_get_ofnode Unexecuted instantiation: board_r.c:phy_get_ofnode Unexecuted instantiation: miiphyutil.c:phy_get_ofnode Unexecuted instantiation: dsa_sandbox.c:phy_get_ofnode Unexecuted instantiation: mdio_mux_sandbox.c:phy_get_ofnode Unexecuted instantiation: mdio_sandbox.c:phy_get_ofnode Unexecuted instantiation: phy.c:phy_get_ofnode Unexecuted instantiation: fixed.c:phy_get_ofnode Unexecuted instantiation: dsa-uclass.c:phy_get_ofnode Unexecuted instantiation: eth-uclass.c:phy_get_ofnode Unexecuted instantiation: mdio-uclass.c:phy_get_ofnode Unexecuted instantiation: mdio-mux-uclass.c:phy_get_ofnode Unexecuted instantiation: eth_common.c:phy_get_ofnode Unexecuted instantiation: dsa.c:phy_get_ofnode Unexecuted instantiation: mdio_mux.c:phy_get_ofnode
279
280		/**
281		* phy_read_mmd_poll_timeout - Periodically poll a PHY register until a
282		* condition is met or a timeout occurs
283		*
284		* @phydev: The phy_device struct
285		* @devaddr: The MMD to read from
286		* @regnum: The register on the MMD to read
287		* @val: Variable to read the register into
288		* @cond: Break condition (usually involving @val)
289		* @sleep_us: Maximum time to sleep between reads in us (0
290		* tight-loops). Should be less than ~20ms since usleep_range
291		* is used (see Documentation/timers/timers-howto.rst).
292		* @timeout_us: Timeout in us, 0 means never timeout
293		* @sleep_before_read: if it is true, sleep @sleep_us before read.
294		* Returns 0 on success and -ETIMEDOUT upon a timeout. In either
295		* case, the last read value at @args is stored in @val. Must not
296		* be called from atomic context if sleep_us or timeout_us are used.
297		*/
298		#define phy_read_mmd_poll_timeout(phydev, devaddr, regnum, val, cond, \
299		sleep_us, timeout_us, sleep_before_read) \
300		({ \
301		int __ret = read_poll_timeout(phy_read_mmd, val, (cond) \|\| val < 0, \
302		sleep_us, timeout_us, \
303		phydev, devaddr, regnum); \
304		if (val < 0) \
305		__ret = val; \
306		if (__ret) \
307		dev_err(phydev->dev, "%s failed: %d\n", __func__, __ret); \
308		__ret; \
309		})
310
311		int phy_read(struct phy_device *phydev, int devad, int regnum);
312		int phy_write(struct phy_device *phydev, int devad, int regnum, u16 val);
313		void phy_mmd_start_indirect(struct phy_device *phydev, int devad, int regnum);
314		int phy_read_mmd(struct phy_device *phydev, int devad, int regnum);
315		int phy_write_mmd(struct phy_device *phydev, int devad, int regnum, u16 val);
316		int phy_set_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
317		int phy_clear_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
318		int phy_modify_mmd_changed(struct phy_device *phydev, int devad, u32 regnum,
319		u16 mask, u16 set);
320		int phy_modify_mmd(struct phy_device *phydev, int devad, u32 regnum,
321		u16 mask, u16 set);
322		int phy_save_page(struct phy_device *phydev);
323		int phy_select_page(struct phy_device *phydev, int page);
324		int phy_restore_page(struct phy_device *phydev, int oldpage, int ret);
325
326		int phy_startup(struct phy_device *phydev);
327		int phy_config(struct phy_device *phydev);
328		int phy_shutdown(struct phy_device *phydev);
329		int phy_set_supported(struct phy_device *phydev, u32 max_speed);
330		int phy_modify(struct phy_device *phydev, int devad, int regnum, u16 mask,
331		u16 set);
332		int genphy_config_aneg(struct phy_device *phydev);
333		int genphy_restart_aneg(struct phy_device *phydev);
334		int genphy_update_link(struct phy_device *phydev);
335		int genphy_parse_link(struct phy_device *phydev);
336		int genphy_config(struct phy_device *phydev);
337		int genphy_startup(struct phy_device *phydev);
338		int genphy_shutdown(struct phy_device *phydev);
339		int gen10g_config(struct phy_device *phydev);
340		int gen10g_startup(struct phy_device *phydev);
341		int gen10g_shutdown(struct phy_device *phydev);
342		int gen10g_discover_mmds(struct phy_device *phydev);
343
344		/**
345		* phy_set_bits - Convenience function for setting bits in a PHY register
346		* @phydev: the phy_device struct
347		* @devad: The MMD to read from
348		* @regnum: register number to write
349		* @val: bits to set
350		*/
351		static inline int phy_set_bits(struct phy_device *phydev, int devad, u32 regnum, u16 val)
352	0	{
353	0	return phy_modify(phydev, devad, regnum, 0, val);
354	0	} Unexecuted instantiation: mii.c:phy_set_bits Unexecuted instantiation: mdio.c:phy_set_bits Unexecuted instantiation: net.c:phy_set_bits Unexecuted instantiation: board_r.c:phy_set_bits Unexecuted instantiation: miiphyutil.c:phy_set_bits Unexecuted instantiation: dsa_sandbox.c:phy_set_bits Unexecuted instantiation: mdio_mux_sandbox.c:phy_set_bits Unexecuted instantiation: mdio_sandbox.c:phy_set_bits Unexecuted instantiation: phy.c:phy_set_bits Unexecuted instantiation: fixed.c:phy_set_bits Unexecuted instantiation: dsa-uclass.c:phy_set_bits Unexecuted instantiation: eth-uclass.c:phy_set_bits Unexecuted instantiation: mdio-uclass.c:phy_set_bits Unexecuted instantiation: mdio-mux-uclass.c:phy_set_bits Unexecuted instantiation: eth_common.c:phy_set_bits Unexecuted instantiation: dsa.c:phy_set_bits Unexecuted instantiation: mdio_mux.c:phy_set_bits
355
356		/**
357		* phy_clear_bits - Convenience function for clearing bits in a PHY register
358		* @phydev: the phy_device struct
359		* @devad: The MMD to write to
360		* @regnum: register number to write
361		* @val: bits to clear
362		*/
363		static inline int phy_clear_bits(struct phy_device *phydev, int devad, u32 regnum, u16 val)
364	0	{
365	0	return phy_modify(phydev, devad, regnum, val, 0);
366	0	} Unexecuted instantiation: mii.c:phy_clear_bits Unexecuted instantiation: mdio.c:phy_clear_bits Unexecuted instantiation: net.c:phy_clear_bits Unexecuted instantiation: board_r.c:phy_clear_bits Unexecuted instantiation: miiphyutil.c:phy_clear_bits Unexecuted instantiation: dsa_sandbox.c:phy_clear_bits Unexecuted instantiation: mdio_mux_sandbox.c:phy_clear_bits Unexecuted instantiation: mdio_sandbox.c:phy_clear_bits Unexecuted instantiation: phy.c:phy_clear_bits Unexecuted instantiation: fixed.c:phy_clear_bits Unexecuted instantiation: dsa-uclass.c:phy_clear_bits Unexecuted instantiation: eth-uclass.c:phy_clear_bits Unexecuted instantiation: mdio-uclass.c:phy_clear_bits Unexecuted instantiation: mdio-mux-uclass.c:phy_clear_bits Unexecuted instantiation: eth_common.c:phy_clear_bits Unexecuted instantiation: dsa.c:phy_clear_bits Unexecuted instantiation: mdio_mux.c:phy_clear_bits
367
368		/**
369		* U_BOOT_PHY_DRIVER() - Declare a new U-Boot driver
370		* @__name: name of the driver
371		*/
372		#define U_BOOT_PHY_DRIVER(__name) \
373		ll_entry_declare(struct phy_driver, __name, phy_driver)
374
375		int board_phy_config(struct phy_device *phydev);
376		int get_phy_id(struct mii_dev bus, int addr, int devad, u32 phy_id);
377
378		/**
379		* phy_interface_is_rgmii - Convenience function for testing if a PHY interface
380		* is RGMII (all variants)
381		* @phydev: the phy_device struct
382		* @return: true if MII bus is RGMII or false if it is not
383		*/
384		static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
385	0	{
386	0	switch (phydev->interface) {
387	0	case PHY_INTERFACE_MODE_RGMII:
388	0	case PHY_INTERFACE_MODE_RGMII_ID:
389	0	case PHY_INTERFACE_MODE_RGMII_RXID:
390	0	case PHY_INTERFACE_MODE_RGMII_TXID:
391	0	return 1;
392	0	default:
393	0	return 0;
394	0	}
395	0	} Unexecuted instantiation: mii.c:phy_interface_is_rgmii Unexecuted instantiation: mdio.c:phy_interface_is_rgmii Unexecuted instantiation: net.c:phy_interface_is_rgmii Unexecuted instantiation: board_r.c:phy_interface_is_rgmii Unexecuted instantiation: miiphyutil.c:phy_interface_is_rgmii Unexecuted instantiation: dsa_sandbox.c:phy_interface_is_rgmii Unexecuted instantiation: mdio_mux_sandbox.c:phy_interface_is_rgmii Unexecuted instantiation: mdio_sandbox.c:phy_interface_is_rgmii Unexecuted instantiation: phy.c:phy_interface_is_rgmii Unexecuted instantiation: fixed.c:phy_interface_is_rgmii Unexecuted instantiation: dsa-uclass.c:phy_interface_is_rgmii Unexecuted instantiation: eth-uclass.c:phy_interface_is_rgmii Unexecuted instantiation: mdio-uclass.c:phy_interface_is_rgmii Unexecuted instantiation: mdio-mux-uclass.c:phy_interface_is_rgmii Unexecuted instantiation: eth_common.c:phy_interface_is_rgmii Unexecuted instantiation: dsa.c:phy_interface_is_rgmii Unexecuted instantiation: mdio_mux.c:phy_interface_is_rgmii
396
397		bool phy_interface_is_ncsi(void);
398
399		/* PHY UIDs for various PHYs that are referenced in external code */
400		#define PHY_UID_CS4340 0x13e51002
401		#define PHY_UID_CS4223 0x03e57003
402		#define PHY_UID_TN2020 0x00a19410
403		#define PHY_UID_IN112525_S03 0x02107440
404
405		#endif