mdio.h 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516
  1. /* SPDX-License-Identifier: GPL-2.0-only */
  2. /*
  3. * linux/mdio.h: definitions for MDIO (clause 45) transceivers
  4. * Copyright 2006-2009 Solarflare Communications Inc.
  5. */
  6. #ifndef __LINUX_MDIO_H__
  7. #define __LINUX_MDIO_H__
  8. #include <uapi/linux/mdio.h>
  9. #include <linux/bitfield.h>
  10. #include <linux/mod_devicetable.h>
  11. /* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
  12. * IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips.
  13. */
  14. #define MII_ADDR_C45 (1<<30)
  15. #define MII_DEVADDR_C45_SHIFT 16
  16. #define MII_DEVADDR_C45_MASK GENMASK(20, 16)
  17. #define MII_REGADDR_C45_MASK GENMASK(15, 0)
  18. struct gpio_desc;
  19. struct mii_bus;
  20. struct reset_control;
  21. /* Multiple levels of nesting are possible. However typically this is
  22. * limited to nested DSA like layer, a MUX layer, and the normal
  23. * user. Instead of trying to handle the general case, just define
  24. * these cases.
  25. */
  26. enum mdio_mutex_lock_class {
  27. MDIO_MUTEX_NORMAL,
  28. MDIO_MUTEX_MUX,
  29. MDIO_MUTEX_NESTED,
  30. };
  31. struct mdio_device {
  32. struct device dev;
  33. struct mii_bus *bus;
  34. char modalias[MDIO_NAME_SIZE];
  35. int (*bus_match)(struct device *dev, struct device_driver *drv);
  36. void (*device_free)(struct mdio_device *mdiodev);
  37. void (*device_remove)(struct mdio_device *mdiodev);
  38. /* Bus address of the MDIO device (0-31) */
  39. int addr;
  40. int flags;
  41. struct gpio_desc *reset_gpio;
  42. struct reset_control *reset_ctrl;
  43. unsigned int reset_assert_delay;
  44. unsigned int reset_deassert_delay;
  45. };
  46. static inline struct mdio_device *to_mdio_device(const struct device *dev)
  47. {
  48. return container_of(dev, struct mdio_device, dev);
  49. }
  50. /* struct mdio_driver_common: Common to all MDIO drivers */
  51. struct mdio_driver_common {
  52. struct device_driver driver;
  53. int flags;
  54. };
  55. #define MDIO_DEVICE_FLAG_PHY 1
  56. static inline struct mdio_driver_common *
  57. to_mdio_common_driver(const struct device_driver *driver)
  58. {
  59. return container_of(driver, struct mdio_driver_common, driver);
  60. }
  61. /* struct mdio_driver: Generic MDIO driver */
  62. struct mdio_driver {
  63. struct mdio_driver_common mdiodrv;
  64. /*
  65. * Called during discovery. Used to set
  66. * up device-specific structures, if any
  67. */
  68. int (*probe)(struct mdio_device *mdiodev);
  69. /* Clears up any memory if needed */
  70. void (*remove)(struct mdio_device *mdiodev);
  71. /* Quiesces the device on system shutdown, turns off interrupts etc */
  72. void (*shutdown)(struct mdio_device *mdiodev);
  73. };
  74. static inline struct mdio_driver *
  75. to_mdio_driver(const struct device_driver *driver)
  76. {
  77. return container_of(to_mdio_common_driver(driver), struct mdio_driver,
  78. mdiodrv);
  79. }
  80. /* device driver data */
  81. static inline void mdiodev_set_drvdata(struct mdio_device *mdio, void *data)
  82. {
  83. dev_set_drvdata(&mdio->dev, data);
  84. }
  85. static inline void *mdiodev_get_drvdata(struct mdio_device *mdio)
  86. {
  87. return dev_get_drvdata(&mdio->dev);
  88. }
  89. void mdio_device_free(struct mdio_device *mdiodev);
  90. struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr);
  91. int mdio_device_register(struct mdio_device *mdiodev);
  92. void mdio_device_remove(struct mdio_device *mdiodev);
  93. void mdio_device_reset(struct mdio_device *mdiodev, int value);
  94. int mdio_driver_register(struct mdio_driver *drv);
  95. void mdio_driver_unregister(struct mdio_driver *drv);
  96. int mdio_device_bus_match(struct device *dev, struct device_driver *drv);
  97. static inline bool mdio_phy_id_is_c45(int phy_id)
  98. {
  99. return (phy_id & MDIO_PHY_ID_C45) && !(phy_id & ~MDIO_PHY_ID_C45_MASK);
  100. }
  101. static inline __u16 mdio_phy_id_prtad(int phy_id)
  102. {
  103. return (phy_id & MDIO_PHY_ID_PRTAD) >> 5;
  104. }
  105. static inline __u16 mdio_phy_id_devad(int phy_id)
  106. {
  107. return phy_id & MDIO_PHY_ID_DEVAD;
  108. }
  109. /**
  110. * struct mdio_if_info - Ethernet controller MDIO interface
  111. * @prtad: PRTAD of the PHY (%MDIO_PRTAD_NONE if not present/unknown)
  112. * @mmds: Mask of MMDs expected to be present in the PHY. This must be
  113. * non-zero unless @prtad = %MDIO_PRTAD_NONE.
  114. * @mode_support: MDIO modes supported. If %MDIO_SUPPORTS_C22 is set then
  115. * MII register access will be passed through with @devad =
  116. * %MDIO_DEVAD_NONE. If %MDIO_EMULATE_C22 is set then access to
  117. * commonly used clause 22 registers will be translated into
  118. * clause 45 registers.
  119. * @dev: Net device structure
  120. * @mdio_read: Register read function; returns value or negative error code
  121. * @mdio_write: Register write function; returns 0 or negative error code
  122. */
  123. struct mdio_if_info {
  124. int prtad;
  125. u32 mmds;
  126. unsigned mode_support;
  127. struct net_device *dev;
  128. int (*mdio_read)(struct net_device *dev, int prtad, int devad,
  129. u16 addr);
  130. int (*mdio_write)(struct net_device *dev, int prtad, int devad,
  131. u16 addr, u16 val);
  132. };
  133. #define MDIO_PRTAD_NONE (-1)
  134. #define MDIO_DEVAD_NONE (-1)
  135. #define MDIO_SUPPORTS_C22 1
  136. #define MDIO_SUPPORTS_C45 2
  137. #define MDIO_EMULATE_C22 4
  138. struct ethtool_cmd;
  139. struct ethtool_pauseparam;
  140. extern int mdio45_probe(struct mdio_if_info *mdio, int prtad);
  141. extern int mdio_set_flag(const struct mdio_if_info *mdio,
  142. int prtad, int devad, u16 addr, int mask,
  143. bool sense);
  144. extern int mdio45_links_ok(const struct mdio_if_info *mdio, u32 mmds);
  145. extern int mdio45_nway_restart(const struct mdio_if_info *mdio);
  146. extern void mdio45_ethtool_gset_npage(const struct mdio_if_info *mdio,
  147. struct ethtool_cmd *ecmd,
  148. u32 npage_adv, u32 npage_lpa);
  149. extern void
  150. mdio45_ethtool_ksettings_get_npage(const struct mdio_if_info *mdio,
  151. struct ethtool_link_ksettings *cmd,
  152. u32 npage_adv, u32 npage_lpa);
  153. /**
  154. * mdio45_ethtool_gset - get settings for ETHTOOL_GSET
  155. * @mdio: MDIO interface
  156. * @ecmd: Ethtool request structure
  157. *
  158. * Since the CSRs for auto-negotiation using next pages are not fully
  159. * standardised, this function does not attempt to decode them. Use
  160. * mdio45_ethtool_gset_npage() to specify advertisement bits from next
  161. * pages.
  162. */
  163. static inline void mdio45_ethtool_gset(const struct mdio_if_info *mdio,
  164. struct ethtool_cmd *ecmd)
  165. {
  166. mdio45_ethtool_gset_npage(mdio, ecmd, 0, 0);
  167. }
  168. /**
  169. * mdio45_ethtool_ksettings_get - get settings for ETHTOOL_GLINKSETTINGS
  170. * @mdio: MDIO interface
  171. * @cmd: Ethtool request structure
  172. *
  173. * Since the CSRs for auto-negotiation using next pages are not fully
  174. * standardised, this function does not attempt to decode them. Use
  175. * mdio45_ethtool_ksettings_get_npage() to specify advertisement bits
  176. * from next pages.
  177. */
  178. static inline void
  179. mdio45_ethtool_ksettings_get(const struct mdio_if_info *mdio,
  180. struct ethtool_link_ksettings *cmd)
  181. {
  182. mdio45_ethtool_ksettings_get_npage(mdio, cmd, 0, 0);
  183. }
  184. extern int mdio_mii_ioctl(const struct mdio_if_info *mdio,
  185. struct mii_ioctl_data *mii_data, int cmd);
  186. /**
  187. * mmd_eee_cap_to_ethtool_sup_t
  188. * @eee_cap: value of the MMD EEE Capability register
  189. *
  190. * A small helper function that translates MMD EEE Capability (3.20) bits
  191. * to ethtool supported settings.
  192. */
  193. static inline u32 mmd_eee_cap_to_ethtool_sup_t(u16 eee_cap)
  194. {
  195. u32 supported = 0;
  196. if (eee_cap & MDIO_EEE_100TX)
  197. supported |= SUPPORTED_100baseT_Full;
  198. if (eee_cap & MDIO_EEE_1000T)
  199. supported |= SUPPORTED_1000baseT_Full;
  200. if (eee_cap & MDIO_EEE_10GT)
  201. supported |= SUPPORTED_10000baseT_Full;
  202. if (eee_cap & MDIO_EEE_1000KX)
  203. supported |= SUPPORTED_1000baseKX_Full;
  204. if (eee_cap & MDIO_EEE_10GKX4)
  205. supported |= SUPPORTED_10000baseKX4_Full;
  206. if (eee_cap & MDIO_EEE_10GKR)
  207. supported |= SUPPORTED_10000baseKR_Full;
  208. return supported;
  209. }
  210. /**
  211. * mmd_eee_adv_to_ethtool_adv_t
  212. * @eee_adv: value of the MMD EEE Advertisement/Link Partner Ability registers
  213. *
  214. * A small helper function that translates the MMD EEE Advertisment (7.60)
  215. * and MMD EEE Link Partner Ability (7.61) bits to ethtool advertisement
  216. * settings.
  217. */
  218. static inline u32 mmd_eee_adv_to_ethtool_adv_t(u16 eee_adv)
  219. {
  220. u32 adv = 0;
  221. if (eee_adv & MDIO_EEE_100TX)
  222. adv |= ADVERTISED_100baseT_Full;
  223. if (eee_adv & MDIO_EEE_1000T)
  224. adv |= ADVERTISED_1000baseT_Full;
  225. if (eee_adv & MDIO_EEE_10GT)
  226. adv |= ADVERTISED_10000baseT_Full;
  227. if (eee_adv & MDIO_EEE_1000KX)
  228. adv |= ADVERTISED_1000baseKX_Full;
  229. if (eee_adv & MDIO_EEE_10GKX4)
  230. adv |= ADVERTISED_10000baseKX4_Full;
  231. if (eee_adv & MDIO_EEE_10GKR)
  232. adv |= ADVERTISED_10000baseKR_Full;
  233. return adv;
  234. }
  235. /**
  236. * ethtool_adv_to_mmd_eee_adv_t
  237. * @adv: the ethtool advertisement settings
  238. *
  239. * A small helper function that translates ethtool advertisement settings
  240. * to EEE advertisements for the MMD EEE Advertisement (7.60) and
  241. * MMD EEE Link Partner Ability (7.61) registers.
  242. */
  243. static inline u16 ethtool_adv_to_mmd_eee_adv_t(u32 adv)
  244. {
  245. u16 reg = 0;
  246. if (adv & ADVERTISED_100baseT_Full)
  247. reg |= MDIO_EEE_100TX;
  248. if (adv & ADVERTISED_1000baseT_Full)
  249. reg |= MDIO_EEE_1000T;
  250. if (adv & ADVERTISED_10000baseT_Full)
  251. reg |= MDIO_EEE_10GT;
  252. if (adv & ADVERTISED_1000baseKX_Full)
  253. reg |= MDIO_EEE_1000KX;
  254. if (adv & ADVERTISED_10000baseKX4_Full)
  255. reg |= MDIO_EEE_10GKX4;
  256. if (adv & ADVERTISED_10000baseKR_Full)
  257. reg |= MDIO_EEE_10GKR;
  258. return reg;
  259. }
  260. /**
  261. * linkmode_adv_to_mii_10gbt_adv_t
  262. * @advertising: the linkmode advertisement settings
  263. *
  264. * A small helper function that translates linkmode advertisement
  265. * settings to phy autonegotiation advertisements for the C45
  266. * 10GBASE-T AN CONTROL (7.32) register.
  267. */
  268. static inline u32 linkmode_adv_to_mii_10gbt_adv_t(unsigned long *advertising)
  269. {
  270. u32 result = 0;
  271. if (linkmode_test_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
  272. advertising))
  273. result |= MDIO_AN_10GBT_CTRL_ADV2_5G;
  274. if (linkmode_test_bit(ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
  275. advertising))
  276. result |= MDIO_AN_10GBT_CTRL_ADV5G;
  277. if (linkmode_test_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
  278. advertising))
  279. result |= MDIO_AN_10GBT_CTRL_ADV10G;
  280. return result;
  281. }
  282. /**
  283. * mii_10gbt_stat_mod_linkmode_lpa_t
  284. * @advertising: target the linkmode advertisement settings
  285. * @lpa: value of the C45 10GBASE-T AN STATUS register
  286. *
  287. * A small helper function that translates C45 10GBASE-T AN STATUS register bits
  288. * to linkmode advertisement settings. Other bits in advertising aren't changed.
  289. */
  290. static inline void mii_10gbt_stat_mod_linkmode_lpa_t(unsigned long *advertising,
  291. u32 lpa)
  292. {
  293. linkmode_mod_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT,
  294. advertising, lpa & MDIO_AN_10GBT_STAT_LP2_5G);
  295. linkmode_mod_bit(ETHTOOL_LINK_MODE_5000baseT_Full_BIT,
  296. advertising, lpa & MDIO_AN_10GBT_STAT_LP5G);
  297. linkmode_mod_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
  298. advertising, lpa & MDIO_AN_10GBT_STAT_LP10G);
  299. }
  300. /**
  301. * mii_t1_adv_l_mod_linkmode_t
  302. * @advertising: target the linkmode advertisement settings
  303. * @lpa: value of the BASE-T1 Autonegotiation Advertisement [15:0] Register
  304. *
  305. * A small helper function that translates BASE-T1 Autonegotiation
  306. * Advertisement [15:0] Register bits to linkmode advertisement settings.
  307. * Other bits in advertising aren't changed.
  308. */
  309. static inline void mii_t1_adv_l_mod_linkmode_t(unsigned long *advertising, u32 lpa)
  310. {
  311. linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising,
  312. lpa & MDIO_AN_T1_ADV_L_PAUSE_CAP);
  313. linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertising,
  314. lpa & MDIO_AN_T1_ADV_L_PAUSE_ASYM);
  315. }
  316. /**
  317. * mii_t1_adv_m_mod_linkmode_t
  318. * @advertising: target the linkmode advertisement settings
  319. * @lpa: value of the BASE-T1 Autonegotiation Advertisement [31:16] Register
  320. *
  321. * A small helper function that translates BASE-T1 Autonegotiation
  322. * Advertisement [31:16] Register bits to linkmode advertisement settings.
  323. * Other bits in advertising aren't changed.
  324. */
  325. static inline void mii_t1_adv_m_mod_linkmode_t(unsigned long *advertising, u32 lpa)
  326. {
  327. linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT1L_Full_BIT,
  328. advertising, lpa & MDIO_AN_T1_ADV_M_B10L);
  329. }
  330. /**
  331. * linkmode_adv_to_mii_t1_adv_l_t
  332. * @advertising: the linkmode advertisement settings
  333. *
  334. * A small helper function that translates linkmode advertisement
  335. * settings to phy autonegotiation advertisements for the
  336. * BASE-T1 Autonegotiation Advertisement [15:0] Register.
  337. */
  338. static inline u32 linkmode_adv_to_mii_t1_adv_l_t(unsigned long *advertising)
  339. {
  340. u32 result = 0;
  341. if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising))
  342. result |= MDIO_AN_T1_ADV_L_PAUSE_CAP;
  343. if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertising))
  344. result |= MDIO_AN_T1_ADV_L_PAUSE_ASYM;
  345. return result;
  346. }
  347. /**
  348. * linkmode_adv_to_mii_t1_adv_m_t
  349. * @advertising: the linkmode advertisement settings
  350. *
  351. * A small helper function that translates linkmode advertisement
  352. * settings to phy autonegotiation advertisements for the
  353. * BASE-T1 Autonegotiation Advertisement [31:16] Register.
  354. */
  355. static inline u32 linkmode_adv_to_mii_t1_adv_m_t(unsigned long *advertising)
  356. {
  357. u32 result = 0;
  358. if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT1L_Full_BIT, advertising))
  359. result |= MDIO_AN_T1_ADV_M_B10L;
  360. return result;
  361. }
  362. int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
  363. int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
  364. int __mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
  365. u16 mask, u16 set);
  366. int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
  367. int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum);
  368. int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
  369. int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val);
  370. int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
  371. u16 set);
  372. int mdiobus_modify_changed(struct mii_bus *bus, int addr, u32 regnum,
  373. u16 mask, u16 set);
  374. static inline int mdiodev_read(struct mdio_device *mdiodev, u32 regnum)
  375. {
  376. return mdiobus_read(mdiodev->bus, mdiodev->addr, regnum);
  377. }
  378. static inline int mdiodev_write(struct mdio_device *mdiodev, u32 regnum,
  379. u16 val)
  380. {
  381. return mdiobus_write(mdiodev->bus, mdiodev->addr, regnum, val);
  382. }
  383. static inline int mdiodev_modify(struct mdio_device *mdiodev, u32 regnum,
  384. u16 mask, u16 set)
  385. {
  386. return mdiobus_modify(mdiodev->bus, mdiodev->addr, regnum, mask, set);
  387. }
  388. static inline int mdiodev_modify_changed(struct mdio_device *mdiodev,
  389. u32 regnum, u16 mask, u16 set)
  390. {
  391. return mdiobus_modify_changed(mdiodev->bus, mdiodev->addr, regnum,
  392. mask, set);
  393. }
  394. static inline u32 mdiobus_c45_addr(int devad, u16 regnum)
  395. {
  396. return MII_ADDR_C45 | devad << MII_DEVADDR_C45_SHIFT | regnum;
  397. }
  398. static inline u16 mdiobus_c45_regad(u32 regnum)
  399. {
  400. return FIELD_GET(MII_REGADDR_C45_MASK, regnum);
  401. }
  402. static inline u16 mdiobus_c45_devad(u32 regnum)
  403. {
  404. return FIELD_GET(MII_DEVADDR_C45_MASK, regnum);
  405. }
  406. static inline int __mdiobus_c45_read(struct mii_bus *bus, int prtad, int devad,
  407. u16 regnum)
  408. {
  409. return __mdiobus_read(bus, prtad, mdiobus_c45_addr(devad, regnum));
  410. }
  411. static inline int __mdiobus_c45_write(struct mii_bus *bus, int prtad, int devad,
  412. u16 regnum, u16 val)
  413. {
  414. return __mdiobus_write(bus, prtad, mdiobus_c45_addr(devad, regnum),
  415. val);
  416. }
  417. static inline int mdiobus_c45_read(struct mii_bus *bus, int prtad, int devad,
  418. u16 regnum)
  419. {
  420. return mdiobus_read(bus, prtad, mdiobus_c45_addr(devad, regnum));
  421. }
  422. static inline int mdiobus_c45_write(struct mii_bus *bus, int prtad, int devad,
  423. u16 regnum, u16 val)
  424. {
  425. return mdiobus_write(bus, prtad, mdiobus_c45_addr(devad, regnum), val);
  426. }
  427. int mdiobus_register_device(struct mdio_device *mdiodev);
  428. int mdiobus_unregister_device(struct mdio_device *mdiodev);
  429. bool mdiobus_is_registered_device(struct mii_bus *bus, int addr);
  430. struct phy_device *mdiobus_get_phy(struct mii_bus *bus, int addr);
  431. /**
  432. * mdio_module_driver() - Helper macro for registering mdio drivers
  433. * @_mdio_driver: driver to register
  434. *
  435. * Helper macro for MDIO drivers which do not do anything special in module
  436. * init/exit. Each module may only use this macro once, and calling it
  437. * replaces module_init() and module_exit().
  438. */
  439. #define mdio_module_driver(_mdio_driver) \
  440. static int __init mdio_module_init(void) \
  441. { \
  442. return mdio_driver_register(&_mdio_driver); \
  443. } \
  444. module_init(mdio_module_init); \
  445. static void __exit mdio_module_exit(void) \
  446. { \
  447. mdio_driver_unregister(&_mdio_driver); \
  448. } \
  449. module_exit(mdio_module_exit)
  450. #endif /* __LINUX_MDIO_H__ */