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(nr: ETHTOOL_LINK_MODE_10baseT_Half_BIT, addr: advertising)) |
148 | result |= ADVERTISE_10HALF; |
149 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_10baseT_Full_BIT, addr: advertising)) |
150 | result |= ADVERTISE_10FULL; |
151 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_100baseT_Half_BIT, addr: advertising)) |
152 | result |= ADVERTISE_100HALF; |
153 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_100baseT_Full_BIT, addr: advertising)) |
154 | result |= ADVERTISE_100FULL; |
155 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_Pause_BIT, addr: advertising)) |
156 | result |= ADVERTISE_PAUSE_CAP; |
157 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_Asym_Pause_BIT, addr: 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(nr: ETHTOOL_LINK_MODE_1000baseT_Half_BIT, |
223 | addr: advertising)) |
224 | result |= ADVERTISE_1000HALF; |
225 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_1000baseT_Full_BIT, |
226 | addr: 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(adv: 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(nr: ETHTOOL_LINK_MODE_1000baseT_Half_BIT, |
303 | addr: advertising, set: lpa & LPA_1000HALF); |
304 | |
305 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_1000baseT_Full_BIT, |
306 | addr: advertising, set: 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(nr: ETHTOOL_LINK_MODE_10baseT_Half_BIT, |
369 | addr: advertising, set: adv & ADVERTISE_10HALF); |
370 | |
371 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_10baseT_Full_BIT, |
372 | addr: advertising, set: adv & ADVERTISE_10FULL); |
373 | |
374 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_100baseT_Half_BIT, |
375 | addr: advertising, set: adv & ADVERTISE_100HALF); |
376 | |
377 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_100baseT_Full_BIT, |
378 | addr: advertising, set: adv & ADVERTISE_100FULL); |
379 | |
380 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_Pause_BIT, addr: advertising, |
381 | set: adv & ADVERTISE_PAUSE_CAP); |
382 | |
383 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_Asym_Pause_BIT, |
384 | addr: advertising, set: 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(dst: 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(advertising: lp_advertising, adv: lpa); |
416 | |
417 | if (lpa & LPA_LPACK) |
418 | linkmode_set_bit(nr: ETHTOOL_LINK_MODE_Autoneg_BIT, |
419 | addr: 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(advertising: lp_advertising, adv: lpa); |
435 | |
436 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_Autoneg_BIT, |
437 | addr: lp_advertising, set: 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(nr: ETHTOOL_LINK_MODE_1000baseT_Half_BIT, addr: advertising, |
444 | set: ctrl1000 & ADVERTISE_1000HALF); |
445 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_1000baseT_Full_BIT, addr: advertising, |
446 | set: 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(nr: ETHTOOL_LINK_MODE_Pause_BIT, |
461 | addr: advertising)) |
462 | lcl_adv |= ADVERTISE_PAUSE_CAP; |
463 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_Asym_Pause_BIT, |
464 | addr: 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(nr: ETHTOOL_LINK_MODE_Autoneg_BIT, addr: linkmodes, |
480 | set: lpa & LPA_LPACK); |
481 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_Pause_BIT, addr: linkmodes, |
482 | set: lpa & LPA_1000XPAUSE); |
483 | linkmode_mod_bit(nr: ETHTOOL_LINK_MODE_Asym_Pause_BIT, addr: linkmodes, |
484 | set: lpa & LPA_1000XPAUSE_ASYM); |
485 | linkmode_mod_bit(nr: fd_bit, addr: linkmodes, |
486 | set: 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(nr: fd_bit, addr: linkmodes)) |
500 | adv |= ADVERTISE_1000XFULL; |
501 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_Pause_BIT, addr: linkmodes)) |
502 | adv |= ADVERTISE_1000XPAUSE; |
503 | if (linkmode_test_bit(nr: ETHTOOL_LINK_MODE_Asym_Pause_BIT, addr: 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__ */ |
584 | |