GNU Linux-libre 6.9.2-gnu
[releases.git] / 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
16 struct ethtool_cmd;
17
18 struct 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
33 extern int mii_link_ok (struct mii_if_info *mii);
34 extern int mii_nway_restart (struct mii_if_info *mii);
35 extern void mii_ethtool_gset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
36 extern void mii_ethtool_get_link_ksettings(
37         struct mii_if_info *mii, struct ethtool_link_ksettings *cmd);
38 extern int mii_ethtool_sset(struct mii_if_info *mii, struct ethtool_cmd *ecmd);
39 extern int mii_ethtool_set_link_ksettings(
40         struct mii_if_info *mii, const struct ethtool_link_ksettings *cmd);
41 extern int mii_check_gmii_support(struct mii_if_info *mii);
42 extern void mii_check_link (struct mii_if_info *mii);
43 extern unsigned int mii_check_media (struct mii_if_info *mii,
44                                      unsigned int ok_to_print,
45                                      unsigned int init_media);
46 extern 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
51 static 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  */
70 static 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  */
97 static 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  */
115 static 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  */
143 static 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  */
170 static 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  */
198 static 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  */
218 static 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  */
240 static 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  */
260 static 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  */
278 static 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  */
299 static 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  */
317 static 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  */
341 static 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  */
365 static 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  */
396 static 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  */
412 static 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  */
431 static 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
440 static 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  */
456 static 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  */
476 static 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  */
494 static 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  */
513 static 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  */
532 static 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 /**
549  * mii_bmcr_encode_fixed - encode fixed speed/duplex settings to a BMCR value
550  * @speed: a SPEED_* value
551  * @duplex: a DUPLEX_* value
552  *
553  * Encode the speed and duplex to a BMCR value. 2500, 1000, 100 and 10 Mbps are
554  * supported. 2500Mbps is encoded to 1000Mbps. Other speeds are encoded as 10
555  * Mbps. Unknown duplex values are encoded to half-duplex.
556  */
557 static inline u16 mii_bmcr_encode_fixed(int speed, int duplex)
558 {
559         u16 bmcr;
560
561         switch (speed) {
562         case SPEED_2500:
563         case SPEED_1000:
564                 bmcr = BMCR_SPEED1000;
565                 break;
566
567         case SPEED_100:
568                 bmcr = BMCR_SPEED100;
569                 break;
570
571         case SPEED_10:
572         default:
573                 bmcr = BMCR_SPEED10;
574                 break;
575         }
576
577         if (duplex == DUPLEX_FULL)
578                 bmcr |= BMCR_FULLDPLX;
579
580         return bmcr;
581 }
582
583 #endif /* __LINUX_MII_H__ */