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 
if_mii(struct ifreq * rq)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  */
mii_nway_result(unsigned int negotiated)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  */
mii_duplex(unsigned int duplex_lock,unsigned int negotiated)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  */
ethtool_adv_to_mii_adv_t(u32 ethadv)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  */
linkmode_adv_to_mii_adv_t(unsigned long * advertising)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  */
mii_adv_to_ethtool_adv_t(u32 adv)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  */
ethtool_adv_to_mii_ctrl1000_t(u32 ethadv)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  */
linkmode_adv_to_mii_ctrl1000_t(unsigned long * advertising)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  */
mii_ctrl1000_to_ethtool_adv_t(u32 adv)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  */
mii_lpa_to_ethtool_lpa_t(u32 lpa)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  */
mii_stat1000_to_ethtool_lpa_t(u32 lpa)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  */
mii_stat1000_mod_linkmode_lpa_t(unsigned long * advertising,u32 lpa)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  */
ethtool_adv_to_mii_adv_x(u32 ethadv)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  */
mii_adv_to_ethtool_adv_x(u32 adv)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  */
mii_adv_mod_linkmode_adv_t(unsigned long * advertising,u32 adv)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  */
mii_adv_to_linkmode_adv_t(unsigned long * advertising,u32 adv)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  */
mii_lpa_to_linkmode_lpa_t(unsigned long * lp_advertising,u32 lpa)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  */
mii_lpa_mod_linkmode_lpa_t(unsigned long * lp_advertising,u32 lpa)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 
mii_ctrl1000_mod_linkmode_adv_t(unsigned long * advertising,u32 ctrl1000)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  */
linkmode_adv_to_lcl_adv_t(unsigned long * advertising)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  */
mii_lpa_mod_linkmode_x(unsigned long * linkmodes,u16 lpa,int fd_bit)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  */
linkmode_adv_to_mii_adv_x(const unsigned long * linkmodes,int fd_bit)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  */
mii_advertise_flowctrl(int cap)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  */
mii_resolve_flowctrl_fdx(u16 lcladv,u16 rmtadv)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  */
mii_bmcr_encode_fixed(int speed,int duplex)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__ */
584