Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 2 | /* |
| 3 | * Copyright 2011 Freescale Semiconductor, Inc. |
Andy Fleming | b36a4d4 | 2014-07-25 17:39:08 -0500 | [diff] [blame] | 4 | * Andy Fleming <afleming@gmail.com> |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 5 | * |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 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 | |
Simon Glass | 992b603 | 2020-07-19 10:15:39 -0600 | [diff] [blame] | 12 | #include <log.h> |
| 13 | #include <phy_interface.h> |
| 14 | #include <dm/ofnode.h> |
| 15 | #include <dm/read.h> |
Simon Glass | fb6f482 | 2020-02-03 07:36:17 -0700 | [diff] [blame] | 16 | #include <linux/errno.h> |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 17 | #include <linux/list.h> |
| 18 | #include <linux/mii.h> |
| 19 | #include <linux/ethtool.h> |
| 20 | #include <linux/mdio.h> |
Simon Glass | 992b603 | 2020-07-19 10:15:39 -0600 | [diff] [blame] | 21 | |
| 22 | struct udevice; |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 23 | |
Hannes Schmelzer | da49460 | 2017-03-23 15:11:43 +0100 | [diff] [blame] | 24 | #define PHY_FIXED_ID 0xa5a55a5a |
Samuel Mendoza-Jonas | 2325c44 | 2019-06-18 11:37:17 +1000 | [diff] [blame] | 25 | #define PHY_NCSI_ID 0xbeefcafe |
| 26 | |
Siva Durga Prasad Paladugu | d5c4e1e | 2018-11-27 11:49:11 +0530 | [diff] [blame] | 27 | /* |
| 28 | * There is no actual id for this. |
| 29 | * This is just a dummy id for gmii2rgmmi converter. |
| 30 | */ |
| 31 | #define PHY_GMII2RGMII_ID 0x5a5a5a5a |
Hannes Schmelzer | da49460 | 2017-03-23 15:11:43 +0100 | [diff] [blame] | 32 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 33 | #define PHY_MAX_ADDR 32 |
| 34 | |
Shaohui Xie | 62a7b92 | 2016-01-28 15:55:46 +0800 | [diff] [blame] | 35 | #define PHY_FLAG_BROKEN_RESET (1 << 0) /* soft reset not supported */ |
| 36 | |
Florian Fainelli | 33bbc24 | 2016-01-13 16:59:33 +0300 | [diff] [blame] | 37 | #define PHY_DEFAULT_FEATURES (SUPPORTED_Autoneg | \ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 38 | SUPPORTED_TP | \ |
| 39 | SUPPORTED_MII) |
| 40 | |
Florian Fainelli | 33bbc24 | 2016-01-13 16:59:33 +0300 | [diff] [blame] | 41 | #define PHY_10BT_FEATURES (SUPPORTED_10baseT_Half | \ |
| 42 | SUPPORTED_10baseT_Full) |
| 43 | |
| 44 | #define PHY_100BT_FEATURES (SUPPORTED_100baseT_Half | \ |
| 45 | SUPPORTED_100baseT_Full) |
| 46 | |
| 47 | #define PHY_1000BT_FEATURES (SUPPORTED_1000baseT_Half | \ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 48 | SUPPORTED_1000baseT_Full) |
| 49 | |
Florian Fainelli | 33bbc24 | 2016-01-13 16:59:33 +0300 | [diff] [blame] | 50 | #define PHY_BASIC_FEATURES (PHY_10BT_FEATURES | \ |
| 51 | PHY_100BT_FEATURES | \ |
| 52 | PHY_DEFAULT_FEATURES) |
| 53 | |
Radu Pirea (NXP OSS) | f2d36cb | 2021-06-18 21:58:30 +0300 | [diff] [blame] | 54 | #define PHY_100BT1_FEATURES (SUPPORTED_TP | \ |
| 55 | SUPPORTED_MII | \ |
| 56 | SUPPORTED_100baseT_Full) |
| 57 | |
Florian Fainelli | 33bbc24 | 2016-01-13 16:59:33 +0300 | [diff] [blame] | 58 | #define PHY_GBIT_FEATURES (PHY_BASIC_FEATURES | \ |
| 59 | PHY_1000BT_FEATURES) |
| 60 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 61 | #define PHY_10G_FEATURES (PHY_GBIT_FEATURES | \ |
| 62 | SUPPORTED_10000baseT_Full) |
| 63 | |
Stefan Roese | b6af557 | 2014-10-22 12:13:15 +0200 | [diff] [blame] | 64 | #ifndef PHY_ANEG_TIMEOUT |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 65 | #define PHY_ANEG_TIMEOUT 4000 |
Stefan Roese | b6af557 | 2014-10-22 12:13:15 +0200 | [diff] [blame] | 66 | #endif |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 67 | |
| 68 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 69 | struct phy_device; |
| 70 | |
| 71 | #define MDIO_NAME_LEN 32 |
| 72 | |
| 73 | struct mii_dev { |
| 74 | struct list_head link; |
| 75 | char name[MDIO_NAME_LEN]; |
| 76 | void *priv; |
| 77 | int (*read)(struct mii_dev *bus, int addr, int devad, int reg); |
| 78 | int (*write)(struct mii_dev *bus, int addr, int devad, int reg, |
| 79 | u16 val); |
| 80 | int (*reset)(struct mii_dev *bus); |
| 81 | struct phy_device *phymap[PHY_MAX_ADDR]; |
| 82 | u32 phy_mask; |
| 83 | }; |
| 84 | |
| 85 | /* struct phy_driver: a structure which defines PHY behavior |
| 86 | * |
| 87 | * uid will contain a number which represents the PHY. During |
| 88 | * startup, the driver will poll the PHY to find out what its |
| 89 | * UID--as defined by registers 2 and 3--is. The 32-bit result |
| 90 | * gotten from the PHY will be masked to |
| 91 | * discard any bits which may change based on revision numbers |
| 92 | * unimportant to functionality |
| 93 | * |
| 94 | */ |
| 95 | struct phy_driver { |
| 96 | char *name; |
| 97 | unsigned int uid; |
| 98 | unsigned int mask; |
| 99 | unsigned int mmds; |
| 100 | |
| 101 | u32 features; |
| 102 | |
| 103 | /* Called to do any driver startup necessities */ |
| 104 | /* Will be called during phy_connect */ |
| 105 | int (*probe)(struct phy_device *phydev); |
| 106 | |
| 107 | /* Called to configure the PHY, and modify the controller |
| 108 | * based on the results. Should be called after phy_connect */ |
| 109 | int (*config)(struct phy_device *phydev); |
| 110 | |
| 111 | /* Called when starting up the controller */ |
| 112 | int (*startup)(struct phy_device *phydev); |
| 113 | |
| 114 | /* Called when bringing down the controller */ |
| 115 | int (*shutdown)(struct phy_device *phydev); |
| 116 | |
Stefano Babic | 6b8c597 | 2013-09-02 15:42:30 +0200 | [diff] [blame] | 117 | int (*readext)(struct phy_device *phydev, int addr, int devad, int reg); |
| 118 | int (*writeext)(struct phy_device *phydev, int addr, int devad, int reg, |
| 119 | u16 val); |
Carlo Caione | 4de87e2 | 2019-02-08 17:25:06 +0000 | [diff] [blame] | 120 | |
| 121 | /* Phy specific driver override for reading a MMD register */ |
| 122 | int (*read_mmd)(struct phy_device *phydev, int devad, int reg); |
| 123 | |
| 124 | /* Phy specific driver override for writing a MMD register */ |
| 125 | int (*write_mmd)(struct phy_device *phydev, int devad, int reg, |
| 126 | u16 val); |
| 127 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 128 | struct list_head list; |
Alex Marginean | 1fd5416 | 2019-11-14 18:28:29 +0200 | [diff] [blame] | 129 | |
| 130 | /* driver private data */ |
| 131 | ulong data; |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 132 | }; |
| 133 | |
| 134 | struct phy_device { |
| 135 | /* Information about the PHY type */ |
| 136 | /* And management functions */ |
| 137 | struct mii_dev *bus; |
| 138 | struct phy_driver *drv; |
| 139 | void *priv; |
| 140 | |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 141 | #ifdef CONFIG_DM_ETH |
| 142 | struct udevice *dev; |
Grygorii Strashko | 6189c06 | 2018-07-05 12:02:48 -0500 | [diff] [blame] | 143 | ofnode node; |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 144 | #else |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 145 | struct eth_device *dev; |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 146 | #endif |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 147 | |
| 148 | /* forced speed & duplex (no autoneg) |
| 149 | * partner speed & duplex & pause (autoneg) |
| 150 | */ |
| 151 | int speed; |
| 152 | int duplex; |
| 153 | |
| 154 | /* The most recently read link state */ |
| 155 | int link; |
| 156 | int port; |
| 157 | phy_interface_t interface; |
| 158 | |
| 159 | u32 advertising; |
| 160 | u32 supported; |
| 161 | u32 mmds; |
| 162 | |
| 163 | int autoneg; |
| 164 | int addr; |
| 165 | int pause; |
| 166 | int asym_pause; |
| 167 | u32 phy_id; |
Pankaj Bansal | 3c43a48 | 2018-11-16 06:26:18 +0000 | [diff] [blame] | 168 | bool is_c45; |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 169 | u32 flags; |
| 170 | }; |
| 171 | |
Shaohui Xie | b48127f | 2013-11-14 19:00:31 +0800 | [diff] [blame] | 172 | struct fixed_link { |
| 173 | int phy_id; |
| 174 | int duplex; |
| 175 | int link_speed; |
| 176 | int pause; |
| 177 | int asym_pause; |
| 178 | }; |
| 179 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 180 | #ifdef CONFIG_PHYLIB_10G |
| 181 | extern struct phy_driver gen10g_driver; |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 182 | #endif |
| 183 | |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 184 | /** |
| 185 | * phy_init() - Initializes the PHY drivers |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 186 | * This function registers all available PHY drivers |
| 187 | * |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 188 | * @return: 0 if OK, -ve on error |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 189 | */ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 190 | int phy_init(void); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 191 | |
| 192 | /** |
| 193 | * phy_reset() - Resets the specified PHY |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 194 | * Issues a reset of the PHY and waits for it to complete |
| 195 | * |
| 196 | * @phydev: PHY to reset |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 197 | * @return: 0 if OK, -ve on error |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 198 | */ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 199 | int phy_reset(struct phy_device *phydev); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 200 | |
| 201 | /** |
| 202 | * phy_find_by_mask() - Searches for a PHY on the specified MDIO bus |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 203 | * The function checks the PHY addresses flagged in phy_mask and returns a |
| 204 | * phy_device pointer if it detects a PHY. |
| 205 | * This function should only be called if just one PHY is expected to be present |
| 206 | * in the set of addresses flagged in phy_mask. If multiple PHYs are present, |
| 207 | * it is undefined which of these PHYs is returned. |
| 208 | * |
| 209 | * @bus: MII/MDIO bus to scan |
| 210 | * @phy_mask: bitmap of PYH addresses to scan |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 211 | * @return: pointer to phy_device if a PHY is found, or NULL otherwise |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 212 | */ |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 213 | struct phy_device *phy_find_by_mask(struct mii_dev *bus, unsigned phy_mask); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 214 | |
Vladimir Oltean | 8c089f7 | 2021-01-25 14:23:52 +0200 | [diff] [blame] | 215 | #ifdef CONFIG_PHY_FIXED |
| 216 | |
| 217 | /** |
| 218 | * fixed_phy_create() - create an unconnected fixed-link pseudo-PHY device |
| 219 | * @node: OF node for the container of the fixed-link node |
| 220 | * |
| 221 | * Description: Creates a struct phy_device based on a fixed-link of_node |
| 222 | * description. Can be used without phy_connect by drivers which do not expose |
| 223 | * a UCLASS_ETH udevice. |
| 224 | */ |
| 225 | struct phy_device *fixed_phy_create(ofnode node); |
| 226 | |
| 227 | #else |
| 228 | |
| 229 | static inline struct phy_device *fixed_phy_create(ofnode node) |
| 230 | { |
| 231 | return NULL; |
| 232 | } |
| 233 | |
| 234 | #endif |
| 235 | |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 236 | #ifdef CONFIG_DM_ETH |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 237 | |
| 238 | /** |
| 239 | * phy_connect_dev() - Associates the given pair of PHY and Ethernet devices |
| 240 | * @phydev: PHY device |
| 241 | * @dev: Ethernet device |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 242 | * @interface: type of MAC-PHY interface |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 243 | */ |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 244 | void phy_connect_dev(struct phy_device *phydev, struct udevice *dev, |
| 245 | phy_interface_t interface); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 246 | |
| 247 | /** |
| 248 | * phy_connect() - Creates a PHY device for the Ethernet interface |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 249 | * Creates a PHY device for the PHY at the given address, if one doesn't exist |
| 250 | * already, and associates it with the Ethernet device. |
| 251 | * The function may be called with addr <= 0, in this case addr value is ignored |
| 252 | * and the bus is scanned to detect a PHY. Scanning should only be used if only |
| 253 | * one PHY is expected to be present on the MDIO bus, otherwise it is undefined |
| 254 | * which PHY is returned. |
| 255 | * |
| 256 | * @bus: MII/MDIO bus that hosts the PHY |
| 257 | * @addr: PHY address on MDIO bus |
| 258 | * @dev: Ethernet device to associate to the PHY |
| 259 | * @interface: type of MAC-PHY interface |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 260 | * @return: pointer to phy_device if a PHY is found, or NULL otherwise |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 261 | */ |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 262 | struct phy_device *phy_connect(struct mii_dev *bus, int addr, |
| 263 | struct udevice *dev, |
| 264 | phy_interface_t interface); |
Michal Simek | c1c1603 | 2022-02-23 15:45:41 +0100 | [diff] [blame] | 265 | /** |
| 266 | * phy_device_create() - Create a PHY device |
| 267 | * |
| 268 | * @bus: MII/MDIO bus that hosts the PHY |
| 269 | * @addr: PHY address on MDIO bus |
| 270 | * @phy_id: where to store the ID retrieved |
| 271 | * @is_c45: Device Identifiers if is_c45 |
Michal Simek | c1c1603 | 2022-02-23 15:45:41 +0100 | [diff] [blame] | 272 | * @return: pointer to phy_device if a PHY is found, or NULL otherwise |
| 273 | */ |
| 274 | struct phy_device *phy_device_create(struct mii_dev *bus, int addr, |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 275 | u32 phy_id, bool is_c45); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 276 | |
Michal Simek | 488eec5 | 2022-02-23 15:45:42 +0100 | [diff] [blame] | 277 | /** |
| 278 | * phy_connect_phy_id() - Connect to phy device by reading PHY id |
| 279 | * from phy node. |
| 280 | * |
| 281 | * @bus: MII/MDIO bus that hosts the PHY |
| 282 | * @dev: Ethernet device to associate to the PHY |
Michal Simek | 488eec5 | 2022-02-23 15:45:42 +0100 | [diff] [blame] | 283 | * @return: pointer to phy_device if a PHY is found, |
| 284 | * or NULL otherwise |
| 285 | */ |
| 286 | struct phy_device *phy_connect_phy_id(struct mii_dev *bus, struct udevice *dev, |
Tom Rini | 6a25a7e | 2022-04-15 08:09:52 -0400 | [diff] [blame] | 287 | int phyaddr); |
Michal Simek | 488eec5 | 2022-02-23 15:45:42 +0100 | [diff] [blame] | 288 | |
Grygorii Strashko | 6189c06 | 2018-07-05 12:02:48 -0500 | [diff] [blame] | 289 | static inline ofnode phy_get_ofnode(struct phy_device *phydev) |
| 290 | { |
| 291 | if (ofnode_valid(phydev->node)) |
| 292 | return phydev->node; |
| 293 | else |
| 294 | return dev_ofnode(phydev->dev); |
| 295 | } |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 296 | #else |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 297 | |
| 298 | /** |
| 299 | * phy_connect_dev() - Associates the given pair of PHY and Ethernet devices |
| 300 | * @phydev: PHY device |
| 301 | * @dev: Ethernet device |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 302 | * @interface: type of MAC-PHY interface |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 303 | */ |
Marek Behún | 3927efb | 2022-04-07 00:33:08 +0200 | [diff] [blame] | 304 | void phy_connect_dev(struct phy_device *phydev, struct eth_device *dev, |
| 305 | phy_interface_t interface); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 306 | |
| 307 | /** |
| 308 | * phy_connect() - Creates a PHY device for the Ethernet interface |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 309 | * Creates a PHY device for the PHY at the given address, if one doesn't exist |
| 310 | * already, and associates it with the Ethernet device. |
| 311 | * The function may be called with addr <= 0, in this case addr value is ignored |
| 312 | * and the bus is scanned to detect a PHY. Scanning should only be used if only |
| 313 | * one PHY is expected to be present on the MDIO bus, otherwise it is undefined |
| 314 | * which PHY is returned. |
| 315 | * |
| 316 | * @bus: MII/MDIO bus that hosts the PHY |
| 317 | * @addr: PHY address on MDIO bus |
| 318 | * @dev: Ethernet device to associate to the PHY |
| 319 | * @interface: type of MAC-PHY interface |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 320 | * @return: pointer to phy_device if a PHY is found, or NULL otherwise |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 321 | */ |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 322 | struct phy_device *phy_connect(struct mii_dev *bus, int addr, |
| 323 | struct eth_device *dev, |
| 324 | phy_interface_t interface); |
Alex Marginean | 64d5f39 | 2019-07-11 18:32:56 +0300 | [diff] [blame] | 325 | |
Grygorii Strashko | 6189c06 | 2018-07-05 12:02:48 -0500 | [diff] [blame] | 326 | static inline ofnode phy_get_ofnode(struct phy_device *phydev) |
| 327 | { |
| 328 | return ofnode_null(); |
| 329 | } |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 330 | #endif |
Ramon Fried | 5d74726 | 2022-06-05 03:44:15 +0300 | [diff] [blame] | 331 | |
| 332 | int phy_read(struct phy_device *phydev, int devad, int regnum); |
| 333 | int phy_write(struct phy_device *phydev, int devad, int regnum, u16 val); |
| 334 | void phy_mmd_start_indirect(struct phy_device *phydev, int devad, int regnum); |
| 335 | int phy_read_mmd(struct phy_device *phydev, int devad, int regnum); |
| 336 | int phy_write_mmd(struct phy_device *phydev, int devad, int regnum, u16 val); |
| 337 | int phy_set_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val); |
| 338 | int phy_clear_bits_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val); |
| 339 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 340 | int phy_startup(struct phy_device *phydev); |
| 341 | int phy_config(struct phy_device *phydev); |
| 342 | int phy_shutdown(struct phy_device *phydev); |
| 343 | int phy_register(struct phy_driver *drv); |
Alexey Brodkin | e476bb2 | 2016-01-13 16:59:34 +0300 | [diff] [blame] | 344 | int phy_set_supported(struct phy_device *phydev, u32 max_speed); |
Ariel D'Alessandro | 9c18c91 | 2022-04-12 10:31:36 -0300 | [diff] [blame] | 345 | int phy_modify(struct phy_device *phydev, int devad, int regnum, u16 mask, |
| 346 | u16 set); |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 347 | int genphy_config_aneg(struct phy_device *phydev); |
Troy Kisky | 80b6b09 | 2012-02-07 14:08:48 +0000 | [diff] [blame] | 348 | int genphy_restart_aneg(struct phy_device *phydev); |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 349 | int genphy_update_link(struct phy_device *phydev); |
Yegor Yefremov | c40f5d3 | 2012-11-28 11:15:17 +0100 | [diff] [blame] | 350 | int genphy_parse_link(struct phy_device *phydev); |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 351 | int genphy_config(struct phy_device *phydev); |
| 352 | int genphy_startup(struct phy_device *phydev); |
| 353 | int genphy_shutdown(struct phy_device *phydev); |
| 354 | int gen10g_config(struct phy_device *phydev); |
| 355 | int gen10g_startup(struct phy_device *phydev); |
| 356 | int gen10g_shutdown(struct phy_device *phydev); |
| 357 | int gen10g_discover_mmds(struct phy_device *phydev); |
| 358 | |
Florian Fainelli | 01b4ade | 2017-12-09 14:59:54 -0800 | [diff] [blame] | 359 | int phy_b53_init(void); |
Kevin Smith | 87b2c4e | 2016-03-31 19:33:12 +0000 | [diff] [blame] | 360 | int phy_mv88e61xx_init(void); |
Nate Drude | a9521ea | 2022-04-08 11:28:14 -0500 | [diff] [blame] | 361 | int phy_adin_init(void); |
Shaohui Xie | 0e548d7 | 2014-12-30 18:32:04 +0800 | [diff] [blame] | 362 | int phy_aquantia_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 363 | int phy_atheros_init(void); |
| 364 | int phy_broadcom_init(void); |
Shengzhou Liu | c878bdb | 2014-11-10 18:32:29 +0800 | [diff] [blame] | 365 | int phy_cortina_init(void); |
Abbie Chang | 556872f | 2021-01-14 13:34:12 -0800 | [diff] [blame] | 366 | int phy_cortina_access_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 367 | int phy_davicom_init(void); |
Matt Porter | 3bbeb79 | 2013-03-20 05:38:13 +0000 | [diff] [blame] | 368 | int phy_et1011c_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 369 | int phy_lxt_init(void); |
| 370 | int phy_marvell_init(void); |
Alexandru Gagniuc | 757bb67 | 2017-07-07 11:36:57 -0700 | [diff] [blame] | 371 | int phy_micrel_ksz8xxx_init(void); |
| 372 | int phy_micrel_ksz90x1_init(void); |
Neil Armstrong | 7a4c90d | 2017-10-18 10:02:10 +0200 | [diff] [blame] | 373 | int phy_meson_gxl_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 374 | int phy_natsemi_init(void); |
Ariel D'Alessandro | 97504bc | 2022-04-12 10:31:34 -0300 | [diff] [blame] | 375 | int phy_nxp_c45_tja11xx_init(void); |
Michael Trimarchi | 80ba436 | 2022-04-12 10:31:37 -0300 | [diff] [blame] | 376 | int phy_nxp_tja11xx_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 377 | int phy_realtek_init(void); |
Vladimir Zapolskiy | af9605f | 2011-12-29 15:18:37 +0000 | [diff] [blame] | 378 | int phy_smsc_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 379 | int phy_teranetics_init(void); |
Edgar E. Iglesias | 8d3ce68 | 2015-09-25 23:46:08 -0700 | [diff] [blame] | 380 | int phy_ti_init(void); |
Andy Fleming | 60ca78b | 2011-04-07 21:56:05 -0500 | [diff] [blame] | 381 | int phy_vitesse_init(void); |
Siva Durga Prasad Paladugu | dd6cbd3 | 2016-02-05 13:22:10 +0530 | [diff] [blame] | 382 | int phy_xilinx_init(void); |
John Haechten | ee253f9 | 2016-12-09 22:15:17 +0000 | [diff] [blame] | 383 | int phy_mscc_init(void); |
Hannes Schmelzer | da49460 | 2017-03-23 15:11:43 +0100 | [diff] [blame] | 384 | int phy_fixed_init(void); |
Samuel Mendoza-Jonas | b069c4a | 2019-06-18 11:37:18 +1000 | [diff] [blame] | 385 | int phy_ncsi_init(void); |
Siva Durga Prasad Paladugu | d5c4e1e | 2018-11-27 11:49:11 +0530 | [diff] [blame] | 386 | int phy_xilinx_gmii2rgmii_init(void); |
Timur Tabi | 856f32f | 2011-10-18 18:44:34 -0500 | [diff] [blame] | 387 | |
Fabio Estevam | 55e0f19 | 2014-02-15 14:52:00 -0200 | [diff] [blame] | 388 | int board_phy_config(struct phy_device *phydev); |
Shengzhou Liu | 072b0fa | 2015-04-07 18:46:32 +0800 | [diff] [blame] | 389 | int get_phy_id(struct mii_dev *bus, int addr, int devad, u32 *phy_id); |
Fabio Estevam | 55e0f19 | 2014-02-15 14:52:00 -0200 | [diff] [blame] | 390 | |
Simon Glass | dbad346 | 2015-04-05 16:07:39 -0600 | [diff] [blame] | 391 | /** |
Dan Murphy | 63e3cde | 2016-05-02 15:46:00 -0500 | [diff] [blame] | 392 | * phy_interface_is_rgmii - Convenience function for testing if a PHY interface |
| 393 | * is RGMII (all variants) |
| 394 | * @phydev: the phy_device struct |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 395 | * @return: true if MII bus is RGMII or false if it is not |
Dan Murphy | 63e3cde | 2016-05-02 15:46:00 -0500 | [diff] [blame] | 396 | */ |
| 397 | static inline bool phy_interface_is_rgmii(struct phy_device *phydev) |
| 398 | { |
| 399 | return phydev->interface >= PHY_INTERFACE_MODE_RGMII && |
| 400 | phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID; |
| 401 | } |
| 402 | |
Dan Murphy | 07cf56a | 2016-05-02 15:46:01 -0500 | [diff] [blame] | 403 | /** |
| 404 | * phy_interface_is_sgmii - Convenience function for testing if a PHY interface |
| 405 | * is SGMII (all variants) |
| 406 | * @phydev: the phy_device struct |
Dan Murphy | 98422d9 | 2020-05-04 16:14:37 -0500 | [diff] [blame] | 407 | * @return: true if MII bus is SGMII or false if it is not |
Dan Murphy | 07cf56a | 2016-05-02 15:46:01 -0500 | [diff] [blame] | 408 | */ |
| 409 | static inline bool phy_interface_is_sgmii(struct phy_device *phydev) |
| 410 | { |
| 411 | return phydev->interface >= PHY_INTERFACE_MODE_SGMII && |
| 412 | phydev->interface <= PHY_INTERFACE_MODE_QSGMII; |
| 413 | } |
| 414 | |
Samuel Mendoza-Jonas | c8f4ab0 | 2022-08-08 21:46:03 +0930 | [diff] [blame] | 415 | bool phy_interface_is_ncsi(void); |
| 416 | |
Timur Tabi | 856f32f | 2011-10-18 18:44:34 -0500 | [diff] [blame] | 417 | /* PHY UIDs for various PHYs that are referenced in external code */ |
Wolfgang Denk | 62fb2b4 | 2021-09-27 17:42:39 +0200 | [diff] [blame] | 418 | #define PHY_UID_CS4340 0x13e51002 |
| 419 | #define PHY_UID_CS4223 0x03e57003 |
Priyanka Jain | 46fa2bd | 2018-10-11 04:47:05 +0000 | [diff] [blame] | 420 | #define PHY_UID_TN2020 0x00a19410 |
| 421 | #define PHY_UID_IN112525_S03 0x02107440 |
Timur Tabi | 856f32f | 2011-10-18 18:44:34 -0500 | [diff] [blame] | 422 | |
Andy Fleming | aecf6fc | 2011-04-08 02:10:27 -0500 | [diff] [blame] | 423 | #endif |