Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/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__ */
340 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us