include/linux/mii.h

   1 /*
   2  * linux/mii.h: definitions for MII-compatible transceivers
   3  * Originally drivers/net/sunhme.h.
   4  *
   5  * Copyright (C) 1996, 1999, 2001 David S. Miller (davem@redhat.com)
   6  */
   7 #ifndef __LINUX_MII_H__
   8 #define __LINUX_MII_H__
   9
  10
  11 #include <linux/if.h>
  12 #include <uapi/linux/mii.h>
  13
  14 struct ethtool_cmd;
  15
  16 struct mii_if_info {
  17         int phy_id;
  18         int advertising;
  19         int phy_id_mask;
  20         int reg_num_mask;
  21
  22         unsigned int full_duplex : 1;   /* is full duplex? */
  23         unsigned int force_media : 1;   /* is autoneg. disabled? */
  24         unsigned int supports_gmii : 1; /* are GMII registers supported? */
  25
  26         struct net_device *dev;
  27         int (*mdio_read) (struct net_device *dev, int phy_id, int location);
  28         void (*mdio_write) (struct net_device *dev, int phy_id, int location, int val);
  29 };
  30
  31 extern int mii_link_ok (struct mii_if_info *mii);
  32 extern int mii_nway_restart (struct mii_if_info *mii);
  33 extern int mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
  34 extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
  35 extern int mii_check_gmii_support(struct mii_if_info *mii);
  36 extern void mii_check_link (struct mii_if_info *mii);
  37 extern unsigned int mii_check_media (struct mii_if_info *mii,
  38                                      unsigned int ok_to_print,
  39                                      unsigned int init_media);
  40 extern int generic_mii_ioctl(struct mii_if_info *mii_if,
  41                              struct mii_ioctl_data *mii_data, int cmd,
  42                              unsigned int *duplex_changed);
  43
  44
  45 static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
  46 {
  47         return (struct mii_ioctl_data *) &rq->ifr_ifru;
  48 }
  49
  50 /**
  51  * mii_nway_result
  52  * @negotiated: value of MII ANAR and'd with ANLPAR
  53  *
  54  * Given a set of MII abilities, check each bit and returns the
  55  * currently supported media, in the priority order defined by
  56  * IEEE 802.3u.  We use LPA_xxx constants but note this is not the
  57  * value of LPA solely, as described above.
  58  *
  59  * The one exception to IEEE 802.3u is that 100baseT4 is placed
  60  * between 100T-full and 100T-half.  If your phy does not support
  61  * 100T4 this is fine.  If your phy places 100T4 elsewhere in the
  62  * priority order, you will need to roll your own function.
  63  */
  64 static inline unsigned int mii_nway_result (unsigned int negotiated)
  65 {
  66         unsigned int ret;
  67
  68         if (negotiated & LPA_100FULL)
  69                 ret = LPA_100FULL;
  70         else if (negotiated & LPA_100BASE4)
  71                 ret = LPA_100BASE4;
  72         else if (negotiated & LPA_100HALF)
  73                 ret = LPA_100HALF;
  74         else if (negotiated & LPA_10FULL)
  75                 ret = LPA_10FULL;
  76         else
  77                 ret = LPA_10HALF;
  78
  79         return ret;
  80 }
  81
  82 /**
  83  * mii_duplex
  84  * @duplex_lock: Non-zero if duplex is locked at full
  85  * @negotiated: value of MII ANAR and'd with ANLPAR
  86  *
  87  * A small helper function for a common case.  Returns one
  88  * if the media is operating or locked at full duplex, and
  89  * returns zero otherwise.
  90  */
  91 static inline unsigned int mii_duplex (unsigned int duplex_lock,
  92                                        unsigned int negotiated)
  93 {
  94         if (duplex_lock)
  95                 return 1;
  96         if (mii_nway_result(negotiated) & LPA_DUPLEX)
  97                 return 1;
  98         return 0;
  99 }
 100
 101 /**
 102  * ethtool_adv_to_mii_adv_t
 103  * @ethadv: the ethtool advertisement settings
 104  *
 105  * A small helper function that translates ethtool advertisement
 106  * settings to phy autonegotiation advertisements for the
 107  * MII_ADVERTISE register.
 108  */
 109 static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv)
 110 {
 111         u32 result = 0;
 112
 113         if (ethadv & ADVERTISED_10baseT_Half)
 114                 result |= ADVERTISE_10HALF;
 115         if (ethadv & ADVERTISED_10baseT_Full)
 116                 result |= ADVERTISE_10FULL;
 117         if (ethadv & ADVERTISED_100baseT_Half)
 118                 result |= ADVERTISE_100HALF;
 119         if (ethadv & ADVERTISED_100baseT_Full)
 120                 result |= ADVERTISE_100FULL;
 121         if (ethadv & ADVERTISED_Pause)
 122                 result |= ADVERTISE_PAUSE_CAP;
 123         if (ethadv & ADVERTISED_Asym_Pause)
 124                 result |= ADVERTISE_PAUSE_ASYM;
 125
 126         return result;
 127 }
 128
 129 /**
 130  * mii_adv_to_ethtool_adv_t
 131  * @adv: value of the MII_ADVERTISE register
 132  *
 133  * A small helper function that translates MII_ADVERTISE bits
 134  * to ethtool advertisement settings.
 135  */
 136 static inline u32 mii_adv_to_ethtool_adv_t(u32 adv)
 137 {
 138         u32 result = 0;
 139
 140         if (adv & ADVERTISE_10HALF)
 141                 result |= ADVERTISED_10baseT_Half;
 142         if (adv & ADVERTISE_10FULL)
 143                 result |= ADVERTISED_10baseT_Full;
 144         if (adv & ADVERTISE_100HALF)
 145                 result |= ADVERTISED_100baseT_Half;
 146         if (adv & ADVERTISE_100FULL)
 147                 result |= ADVERTISED_100baseT_Full;
 148         if (adv & ADVERTISE_PAUSE_CAP)
 149                 result |= ADVERTISED_Pause;
 150         if (adv & ADVERTISE_PAUSE_ASYM)
 151                 result |= ADVERTISED_Asym_Pause;
 152
 153         return result;
 154 }
 155
 156 /**
 157  * ethtool_adv_to_mii_ctrl1000_t
 158  * @ethadv: the ethtool advertisement settings
 159  *
 160  * A small helper function that translates ethtool advertisement
 161  * settings to phy autonegotiation advertisements for the
 162  * MII_CTRL1000 register when in 1000T mode.
 163  */
 164 static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv)
 165 {
 166         u32 result = 0;
 167
 168         if (ethadv & ADVERTISED_1000baseT_Half)
 169                 result |= ADVERTISE_1000HALF;
 170         if (ethadv & ADVERTISED_1000baseT_Full)
 171                 result |= ADVERTISE_1000FULL;
 172
 173         return result;
 174 }
 175
 176 /**
 177  * mii_ctrl1000_to_ethtool_adv_t
 178  * @adv: value of the MII_CTRL1000 register
 179  *
 180  * A small helper function that translates MII_CTRL1000
 181  * bits, when in 1000Base-T mode, to ethtool
 182  * advertisement settings.
 183  */
 184 static inline u32 mii_ctrl1000_to_ethtool_adv_t(u32 adv)
 185 {
 186         u32 result = 0;
 187
 188         if (adv & ADVERTISE_1000HALF)
 189                 result |= ADVERTISED_1000baseT_Half;
 190         if (adv & ADVERTISE_1000FULL)
 191                 result |= ADVERTISED_1000baseT_Full;
 192
 193         return result;
 194 }
 195
 196 /**
 197  * mii_lpa_to_ethtool_lpa_t
 198  * @adv: value of the MII_LPA register
 199  *
 200  * A small helper function that translates MII_LPA
 201  * bits, when in 1000Base-T mode, to ethtool
 202  * LP advertisement settings.
 203  */
 204 static inline u32 mii_lpa_to_ethtool_lpa_t(u32 lpa)
 205 {
 206         u32 result = 0;
 207
 208         if (lpa & LPA_LPACK)
 209                 result |= ADVERTISED_Autoneg;
 210
 211         return result | mii_adv_to_ethtool_adv_t(lpa);
 212 }
 213
 214 /**
 215  * mii_stat1000_to_ethtool_lpa_t
 216  * @adv: value of the MII_STAT1000 register
 217  *
 218  * A small helper function that translates MII_STAT1000
 219  * bits, when in 1000Base-T mode, to ethtool
 220  * advertisement settings.
 221  */
 222 static inline u32 mii_stat1000_to_ethtool_lpa_t(u32 lpa)
 223 {
 224         u32 result = 0;
 225
 226         if (lpa & LPA_1000HALF)
 227                 result |= ADVERTISED_1000baseT_Half;
 228         if (lpa & LPA_1000FULL)
 229                 result |= ADVERTISED_1000baseT_Full;
 230
 231         return result;
 232 }
 233
 234 /**
 235  * ethtool_adv_to_mii_adv_x
 236  * @ethadv: the ethtool advertisement settings
 237  *
 238  * A small helper function that translates ethtool advertisement
 239  * settings to phy autonegotiation advertisements for the
 240  * MII_CTRL1000 register when in 1000Base-X mode.
 241  */
 242 static inline u32 ethtool_adv_to_mii_adv_x(u32 ethadv)
 243 {
 244         u32 result = 0;
 245
 246         if (ethadv & ADVERTISED_1000baseT_Half)
 247                 result |= ADVERTISE_1000XHALF;
 248         if (ethadv & ADVERTISED_1000baseT_Full)
 249                 result |= ADVERTISE_1000XFULL;
 250         if (ethadv & ADVERTISED_Pause)
 251                 result |= ADVERTISE_1000XPAUSE;
 252         if (ethadv & ADVERTISED_Asym_Pause)
 253                 result |= ADVERTISE_1000XPSE_ASYM;
 254
 255         return result;
 256 }
 257
 258 /**
 259  * mii_adv_to_ethtool_adv_x
 260  * @adv: value of the MII_CTRL1000 register
 261  *
 262  * A small helper function that translates MII_CTRL1000
 263  * bits, when in 1000Base-X mode, to ethtool
 264  * advertisement settings.
 265  */
 266 static inline u32 mii_adv_to_ethtool_adv_x(u32 adv)
 267 {
 268         u32 result = 0;
 269
 270         if (adv & ADVERTISE_1000XHALF)
 271                 result |= ADVERTISED_1000baseT_Half;
 272         if (adv & ADVERTISE_1000XFULL)
 273                 result |= ADVERTISED_1000baseT_Full;
 274         if (adv & ADVERTISE_1000XPAUSE)
 275                 result |= ADVERTISED_Pause;
 276         if (adv & ADVERTISE_1000XPSE_ASYM)
 277                 result |= ADVERTISED_Asym_Pause;
 278
 279         return result;
 280 }
 281
 282 /**
 283  * mii_lpa_to_ethtool_lpa_x
 284  * @adv: value of the MII_LPA register
 285  *
 286  * A small helper function that translates MII_LPA
 287  * bits, when in 1000Base-X mode, to ethtool
 288  * LP advertisement settings.
 289  */
 290 static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa)
 291 {
 292         u32 result = 0;
 293
 294         if (lpa & LPA_LPACK)
 295                 result |= ADVERTISED_Autoneg;
 296
 297         return result | mii_adv_to_ethtool_adv_x(lpa);
 298 }
 299
 300 /**
 301  * mii_advertise_flowctrl - get flow control advertisement flags
 302  * @cap: Flow control capabilities (FLOW_CTRL_RX, FLOW_CTRL_TX or both)
 303  */
 304 static inline u16 mii_advertise_flowctrl(int cap)
 305 {
 306         u16 adv = 0;
 307
 308         if (cap & FLOW_CTRL_RX)
 309                 adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
 310         if (cap & FLOW_CTRL_TX)
 311                 adv ^= ADVERTISE_PAUSE_ASYM;
 312
 313         return adv;
 314 }
 315
 316 /**
 317  * mii_resolve_flowctrl_fdx
 318  * @lcladv: value of MII ADVERTISE register
 319  * @rmtadv: value of MII LPA register
 320  *
 321  * Resolve full duplex flow control as per IEEE 802.3-2005 table 28B-3
 322  */
 323 static inline u8 mii_resolve_flowctrl_fdx(u16 lcladv, u16 rmtadv)
 324 {
 325         u8 cap = 0;
 326
 327         if (lcladv & rmtadv & ADVERTISE_PAUSE_CAP) {
 328                 cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
 329         } else if (lcladv & rmtadv & ADVERTISE_PAUSE_ASYM) {
 330                 if (lcladv & ADVERTISE_PAUSE_CAP)
 331                         cap = FLOW_CTRL_RX;
 332                 else if (rmtadv & ADVERTISE_PAUSE_CAP)
 333                         cap = FLOW_CTRL_TX;
 334         }
 335
 336         return cap;
 337 }
 338
 339 #endif /* __LINUX_MII_H__ */