LXR linux/include/linux/mii.h

   1/* SPDX-License-Identifier: GPL-2.0 */
   2/*
   3 * linux/mii.h: definitions for MII-compatible transceivers
   4 * Originally drivers/net/sunhme.h.
   5 *
   6 * Copyright (C) 1996, 1999, 2001 David S. Miller (davem@redhat.com)
   7 */
   8#ifndef __LINUX_MII_H__
   9#define __LINUX_MII_H__
  10
  11
  12#include <linux/if.h>
  13#include <linux/linkmode.h>
  14#include <uapi/linux/mii.h>
  15
  16struct ethtool_cmd;
  17
  18struct mii_if_info {
  19        int phy_id;
  20        int advertising;
  21        int phy_id_mask;
  22        int reg_num_mask;
  23
  24        unsigned int full_duplex : 1;   /* is full duplex? */
  25        unsigned int force_media : 1;   /* is autoneg. disabled? */
  26        unsigned int supports_gmii : 1; /* are GMII registers supported? */
  27
  28        struct net_device *dev;
  29        int (*mdio_read) (struct net_device *dev, int phy_id, int location);
  30        void (*mdio_write) (struct net_device *dev, int phy_id, int location, int val);
  31};
  32
  33extern int mii_link_ok (struct mii_if_info *mii);
  34extern int mii_nway_restart (struct mii_if_info *mii);
  35extern void mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
  36extern void mii_ethtool_get_link_ksettings(
  37        struct mii_if_info *mii, struct ethtool_link_ksettings *cmd);
  38extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
  39extern int mii_ethtool_set_link_ksettings(
  40        struct mii_if_info *mii, const struct ethtool_link_ksettings *cmd);
  41extern int mii_check_gmii_support(struct mii_if_info *mii);
  42extern void mii_check_link (struct mii_if_info *mii);
  43extern unsigned int mii_check_media (struct mii_if_info *mii,
  44                                     unsigned int ok_to_print,
  45                                     unsigned int init_media);
  46extern int generic_mii_ioctl(struct mii_if_info *mii_if,
  47                             struct mii_ioctl_data *mii_data, int cmd,
  48                             unsigned int *duplex_changed);
  49
  50
  51static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
  52{
  53        return (struct mii_ioctl_data *) &rq->ifr_ifru;
  54}
  55
  56/**
  57 * mii_nway_result
  58 * @negotiated: value of MII ANAR and'd with ANLPAR
  59 *
  60 * Given a set of MII abilities, check each bit and returns the
  61 * currently supported media, in the priority order defined by
  62 * IEEE 802.3u.  We use LPA_xxx constants but note this is not the
  63 * value of LPA solely, as described above.
  64 *
  65 * The one exception to IEEE 802.3u is that 100baseT4 is placed
  66 * between 100T-full and 100T-half.  If your phy does not support
  67 * 100T4 this is fine.  If your phy places 100T4 elsewhere in the
  68 * priority order, you will need to roll your own function.
  69 */
  70static inline unsigned int mii_nway_result (unsigned int negotiated)
  71{
  72        unsigned int ret;
  73
  74        if (negotiated & LPA_100FULL)
  75                ret = LPA_100FULL;
  76        else if (negotiated & LPA_100BASE4)
  77                ret = LPA_100BASE4;
  78        else if (negotiated & LPA_100HALF)
  79                ret = LPA_100HALF;
  80        else if (negotiated & LPA_10FULL)
  81                ret = LPA_10FULL;
  82        else
  83                ret = LPA_10HALF;
  84
  85        return ret;
  86}
  87
  88/**
  89 * mii_duplex
  90 * @duplex_lock: Non-zero if duplex is locked at full
  91 * @negotiated: value of MII ANAR and'd with ANLPAR
  92 *
  93 * A small helper function for a common case.  Returns one
  94 * if the media is operating or locked at full duplex, and
  95 * returns zero otherwise.
  96 */
  97static inline unsigned int mii_duplex (unsigned int duplex_lock,
  98                                       unsigned int negotiated)
  99{
 100        if (duplex_lock)
 101                return 1;
 102        if (mii_nway_result(negotiated) & LPA_DUPLEX)
 103                return 1;
 104        return 0;
 105}
 106
 107/**
 108 * ethtool_adv_to_mii_adv_t
 109 * @ethadv: the ethtool advertisement settings
 110 *
 111 * A small helper function that translates ethtool advertisement
 112 * settings to phy autonegotiation advertisements for the
 113 * MII_ADVERTISE register.
 114 */
 115static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv)
 116{
 117        u32 result = 0;
 118
 119        if (ethadv & ADVERTISED_10baseT_Half)
 120                result |= ADVERTISE_10HALF;
 121        if (ethadv & ADVERTISED_10baseT_Full)
 122                result |= ADVERTISE_10FULL;
 123        if (ethadv & ADVERTISED_100baseT_Half)
 124                result |= ADVERTISE_100HALF;
 125        if (ethadv & ADVERTISED_100baseT_Full)
 126                result |= ADVERTISE_100FULL;
 127        if (ethadv & ADVERTISED_Pause)
 128                result |= ADVERTISE_PAUSE_CAP;
 129        if (ethadv & ADVERTISED_Asym_Pause)
 130                result |= ADVERTISE_PAUSE_ASYM;
 131
 132        return result;
 133}
 134
 135/**
 136 * linkmode_adv_to_mii_adv_t
 137 * @advertising: the linkmode advertisement settings
 138 *
 139 * A small helper function that translates linkmode advertisement
 140 * settings to phy autonegotiation advertisements for the
 141 * MII_ADVERTISE register.
 142 */
 143static inline u32 linkmode_adv_to_mii_adv_t(unsigned long *advertising)
 144{
 145        u32 result = 0;
 146
 147        if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, advertising))
 148                result |= ADVERTISE_10HALF;
 149        if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, advertising))
 150                result |= ADVERTISE_10FULL;
 151        if (linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, advertising))
 152                result |= ADVERTISE_100HALF;
 153        if (linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, advertising))
 154                result |= ADVERTISE_100FULL;
 155        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising))
 156                result |= ADVERTISE_PAUSE_CAP;
 157        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertising))
 158                result |= ADVERTISE_PAUSE_ASYM;
 159
 160        return result;
 161}
 162
 163/**
 164 * mii_adv_to_ethtool_adv_t
 165 * @adv: value of the MII_ADVERTISE register
 166 *
 167 * A small helper function that translates MII_ADVERTISE bits
 168 * to ethtool advertisement settings.
 169 */
 170static inline u32 mii_adv_to_ethtool_adv_t(u32 adv)
 171{
 172        u32 result = 0;
 173
 174        if (adv & ADVERTISE_10HALF)
 175                result |= ADVERTISED_10baseT_Half;
 176        if (adv & ADVERTISE_10FULL)
 177                result |= ADVERTISED_10baseT_Full;
 178        if (adv & ADVERTISE_100HALF)
 179                result |= ADVERTISED_100baseT_Half;
 180        if (adv & ADVERTISE_100FULL)
 181                result |= ADVERTISED_100baseT_Full;
 182        if (adv & ADVERTISE_PAUSE_CAP)
 183                result |= ADVERTISED_Pause;
 184        if (adv & ADVERTISE_PAUSE_ASYM)
 185                result |= ADVERTISED_Asym_Pause;
 186
 187        return result;
 188}
 189
 190/**
 191 * ethtool_adv_to_mii_ctrl1000_t
 192 * @ethadv: the ethtool advertisement settings
 193 *
 194 * A small helper function that translates ethtool advertisement
 195 * settings to phy autonegotiation advertisements for the
 196 * MII_CTRL1000 register when in 1000T mode.
 197 */
 198static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv)
 199{
 200        u32 result = 0;
 201
 202        if (ethadv & ADVERTISED_1000baseT_Half)
 203                result |= ADVERTISE_1000HALF;
 204        if (ethadv & ADVERTISED_1000baseT_Full)
 205                result |= ADVERTISE_1000FULL;
 206
 207        return result;
 208}
 209
 210/**
 211 * linkmode_adv_to_mii_ctrl1000_t
 212 * @advertising: the linkmode advertisement settings
 213 *
 214 * A small helper function that translates linkmode advertisement
 215 * settings to phy autonegotiation advertisements for the
 216 * MII_CTRL1000 register when in 1000T mode.
 217 */
 218static inline u32 linkmode_adv_to_mii_ctrl1000_t(unsigned long *advertising)
 219{
 220        u32 result = 0;
 221
 222        if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
 223                              advertising))
 224                result |= ADVERTISE_1000HALF;
 225        if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
 226                              advertising))
 227                result |= ADVERTISE_1000FULL;
 228
 229        return result;
 230}
 231
 232/**
 233 * mii_ctrl1000_to_ethtool_adv_t
 234 * @adv: value of the MII_CTRL1000 register
 235 *
 236 * A small helper function that translates MII_CTRL1000
 237 * bits, when in 1000Base-T mode, to ethtool
 238 * advertisement settings.
 239 */
 240static inline u32 mii_ctrl1000_to_ethtool_adv_t(u32 adv)
 241{
 242        u32 result = 0;
 243
 244        if (adv & ADVERTISE_1000HALF)
 245                result |= ADVERTISED_1000baseT_Half;
 246        if (adv & ADVERTISE_1000FULL)
 247                result |= ADVERTISED_1000baseT_Full;
 248
 249        return result;
 250}
 251
 252/**
 253 * mii_lpa_to_ethtool_lpa_t
 254 * @adv: value of the MII_LPA register
 255 *
 256 * A small helper function that translates MII_LPA
 257 * bits, when in 1000Base-T mode, to ethtool
 258 * LP advertisement settings.
 259 */
 260static inline u32 mii_lpa_to_ethtool_lpa_t(u32 lpa)
 261{
 262        u32 result = 0;
 263
 264        if (lpa & LPA_LPACK)
 265                result |= ADVERTISED_Autoneg;
 266
 267        return result | mii_adv_to_ethtool_adv_t(lpa);
 268}
 269
 270/**
 271 * mii_stat1000_to_ethtool_lpa_t
 272 * @adv: value of the MII_STAT1000 register
 273 *
 274 * A small helper function that translates MII_STAT1000
 275 * bits, when in 1000Base-T mode, to ethtool
 276 * advertisement settings.
 277 */
 278static inline u32 mii_stat1000_to_ethtool_lpa_t(u32 lpa)
 279{
 280        u32 result = 0;
 281
 282        if (lpa & LPA_1000HALF)
 283                result |= ADVERTISED_1000baseT_Half;
 284        if (lpa & LPA_1000FULL)
 285                result |= ADVERTISED_1000baseT_Full;
 286
 287        return result;
 288}
 289
 290/**
 291 * mii_stat1000_mod_linkmode_lpa_t
 292 * @advertising: target the linkmode advertisement settings
 293 * @adv: value of the MII_STAT1000 register
 294 *
 295 * A small helper function that translates MII_STAT1000 bits, when in
 296 * 1000Base-T mode, to linkmode advertisement settings. Other bits in
 297 * advertising are not changes.
 298 */
 299static inline void mii_stat1000_mod_linkmode_lpa_t(unsigned long *advertising,
 300                                                   u32 lpa)
 301{
 302        linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
 303                         advertising, lpa & LPA_1000HALF);
 304
 305        linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
 306                         advertising, lpa & LPA_1000FULL);
 307}
 308
 309/**
 310 * ethtool_adv_to_mii_adv_x
 311 * @ethadv: the ethtool advertisement settings
 312 *
 313 * A small helper function that translates ethtool advertisement
 314 * settings to phy autonegotiation advertisements for the
 315 * MII_CTRL1000 register when in 1000Base-X mode.
 316 */
 317static inline u32 ethtool_adv_to_mii_adv_x(u32 ethadv)
 318{
 319        u32 result = 0;
 320
 321        if (ethadv & ADVERTISED_1000baseT_Half)
 322                result |= ADVERTISE_1000XHALF;
 323        if (ethadv & ADVERTISED_1000baseT_Full)
 324                result |= ADVERTISE_1000XFULL;
 325        if (ethadv & ADVERTISED_Pause)
 326                result |= ADVERTISE_1000XPAUSE;
 327        if (ethadv & ADVERTISED_Asym_Pause)
 328                result |= ADVERTISE_1000XPSE_ASYM;
 329
 330        return result;
 331}
 332
 333/**
 334 * mii_adv_to_ethtool_adv_x
 335 * @adv: value of the MII_CTRL1000 register
 336 *
 337 * A small helper function that translates MII_CTRL1000
 338 * bits, when in 1000Base-X mode, to ethtool
 339 * advertisement settings.
 340 */
 341static inline u32 mii_adv_to_ethtool_adv_x(u32 adv)
 342{
 343        u32 result = 0;
 344
 345        if (adv & ADVERTISE_1000XHALF)
 346                result |= ADVERTISED_1000baseT_Half;
 347        if (adv & ADVERTISE_1000XFULL)
 348                result |= ADVERTISED_1000baseT_Full;
 349        if (adv & ADVERTISE_1000XPAUSE)
 350                result |= ADVERTISED_Pause;
 351        if (adv & ADVERTISE_1000XPSE_ASYM)
 352                result |= ADVERTISED_Asym_Pause;
 353
 354        return result;
 355}
 356
 357/**
 358 * mii_adv_mod_linkmode_adv_t
 359 * @advertising:pointer to destination link mode.
 360 * @adv: value of the MII_ADVERTISE register
 361 *
 362 * A small helper function that translates MII_ADVERTISE bits to
 363 * linkmode advertisement settings. Leaves other bits unchanged.
 364 */
 365static inline void mii_adv_mod_linkmode_adv_t(unsigned long *advertising,
 366                                              u32 adv)
 367{
 368        linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT,
 369                         advertising, adv & ADVERTISE_10HALF);
 370
 371        linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT,
 372                         advertising, adv & ADVERTISE_10FULL);
 373
 374        linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT,
 375                         advertising, adv & ADVERTISE_100HALF);
 376
 377        linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
 378                         advertising, adv & ADVERTISE_100FULL);
 379
 380        linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising,
 381                         adv & ADVERTISE_PAUSE_CAP);
 382
 383        linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 384                         advertising, adv & ADVERTISE_PAUSE_ASYM);
 385}
 386
 387/**
 388 * mii_adv_to_linkmode_adv_t
 389 * @advertising:pointer to destination link mode.
 390 * @adv: value of the MII_ADVERTISE register
 391 *
 392 * A small helper function that translates MII_ADVERTISE bits
 393 * to linkmode advertisement settings. Clears the old value
 394 * of advertising.
 395 */
 396static inline void mii_adv_to_linkmode_adv_t(unsigned long *advertising,
 397                                             u32 adv)
 398{
 399        linkmode_zero(advertising);
 400
 401        mii_adv_mod_linkmode_adv_t(advertising, adv);
 402}
 403
 404/**
 405 * mii_lpa_to_linkmode_lpa_t
 406 * @adv: value of the MII_LPA register
 407 *
 408 * A small helper function that translates MII_LPA bits, when in
 409 * 1000Base-T mode, to linkmode LP advertisement settings. Clears the
 410 * old value of advertising
 411 */
 412static inline void mii_lpa_to_linkmode_lpa_t(unsigned long *lp_advertising,
 413                                             u32 lpa)
 414{
 415        mii_adv_to_linkmode_adv_t(lp_advertising, lpa);
 416
 417        if (lpa & LPA_LPACK)
 418                linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
 419                                 lp_advertising);
 420
 421}
 422
 423/**
 424 * mii_lpa_mod_linkmode_lpa_t
 425 * @adv: value of the MII_LPA register
 426 *
 427 * A small helper function that translates MII_LPA bits, when in
 428 * 1000Base-T mode, to linkmode LP advertisement settings. Leaves
 429 * other bits unchanged.
 430 */
 431static inline void mii_lpa_mod_linkmode_lpa_t(unsigned long *lp_advertising,
 432                                              u32 lpa)
 433{
 434        mii_adv_mod_linkmode_adv_t(lp_advertising, lpa);
 435
 436        linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
 437                         lp_advertising, lpa & LPA_LPACK);
 438}
 439
 440static inline void mii_ctrl1000_mod_linkmode_adv_t(unsigned long *advertising,
 441                                                   u32 ctrl1000)
 442{
 443        linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, advertising,
 444                         ctrl1000 & ADVERTISE_1000HALF);
 445        linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, advertising,
 446                         ctrl1000 & ADVERTISE_1000FULL);
 447}
 448
 449/**
 450 * linkmode_adv_to_lcl_adv_t
 451 * @advertising:pointer to linkmode advertising
 452 *
 453 * A small helper function that translates linkmode advertising to LVL
 454 * pause capabilities.
 455 */
 456static inline u32 linkmode_adv_to_lcl_adv_t(unsigned long *advertising)
 457{
 458        u32 lcl_adv = 0;
 459
 460        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
 461                              advertising))
 462                lcl_adv |= ADVERTISE_PAUSE_CAP;
 463        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
 464                              advertising))
 465                lcl_adv |= ADVERTISE_PAUSE_ASYM;
 466
 467        return lcl_adv;
 468}
 469
 470/**
 471 * mii_lpa_mod_linkmode_x - decode the link partner's config_reg to linkmodes
 472 * @linkmodes: link modes array
 473 * @lpa: config_reg word from link partner
 474 * @fd_bit: link mode for 1000XFULL bit
 475 */
 476static inline void mii_lpa_mod_linkmode_x(unsigned long *linkmodes, u16 lpa,
 477                                         int fd_bit)
 478{
 479        linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, linkmodes,
 480                         lpa & LPA_LPACK);
 481        linkmode_mod_bit(ETHTOOL_LINK_MODE_Pause_BIT, linkmodes,
 482                         lpa & LPA_1000XPAUSE);
 483        linkmode_mod_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, linkmodes,
 484                         lpa & LPA_1000XPAUSE_ASYM);
 485        linkmode_mod_bit(fd_bit, linkmodes,
 486                         lpa & LPA_1000XFULL);
 487}
 488
 489/**
 490 * linkmode_adv_to_mii_adv_x - encode a linkmode to config_reg
 491 * @linkmodes: linkmodes
 492 * @fd_bit: full duplex bit
 493 */
 494static inline u16 linkmode_adv_to_mii_adv_x(const unsigned long *linkmodes,
 495                                            int fd_bit)
 496{
 497        u16 adv = 0;
 498
 499        if (linkmode_test_bit(fd_bit, linkmodes))
 500                adv |= ADVERTISE_1000XFULL;
 501        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, linkmodes))
 502                adv |= ADVERTISE_1000XPAUSE;
 503        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, linkmodes))
 504                adv |= ADVERTISE_1000XPSE_ASYM;
 505
 506        return adv;
 507}
 508
 509/**
 510 * mii_advertise_flowctrl - get flow control advertisement flags
 511 * @cap: Flow control capabilities (FLOW_CTRL_RX, FLOW_CTRL_TX or both)
 512 */
 513static inline u16 mii_advertise_flowctrl(int cap)
 514{
 515        u16 adv = 0;
 516
 517        if (cap & FLOW_CTRL_RX)
 518                adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
 519        if (cap & FLOW_CTRL_TX)
 520                adv ^= ADVERTISE_PAUSE_ASYM;
 521
 522        return adv;
 523}
 524
 525/**
 526 * mii_resolve_flowctrl_fdx
 527 * @lcladv: value of MII ADVERTISE register
 528 * @rmtadv: value of MII LPA register
 529 *
 530 * Resolve full duplex flow control as per IEEE 802.3-2005 table 28B-3
 531 */
 532static inline u8 mii_resolve_flowctrl_fdx(u16 lcladv, u16 rmtadv)
 533{
 534        u8 cap = 0;
 535
 536        if (lcladv & rmtadv & ADVERTISE_PAUSE_CAP) {
 537                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
 538        } else if (lcladv & rmtadv & ADVERTISE_PAUSE_ASYM) {
 539                if (lcladv & ADVERTISE_PAUSE_CAP)
 540                        cap = FLOW_CTRL_RX;
 541                else if (rmtadv & ADVERTISE_PAUSE_CAP)
 542                        cap = FLOW_CTRL_TX;
 543        }
 544
 545        return cap;
 546}
 547
 548#endif /* __LINUX_MII_H__ */
 549