1 // SPDX-License-Identifier: GPL-2.0
3 * phylink models the MAC to optional PHY connection, supporting
4 * technologies such as SFP cages where the PHY is hot-pluggable.
6 * Copyright (C) 2015 Russell King
8 #include <linux/acpi.h>
9 #include <linux/ethtool.h>
10 #include <linux/export.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/netdevice.h>
14 #include <linux/of_mdio.h>
15 #include <linux/phy.h>
16 #include <linux/phy_fixed.h>
17 #include <linux/phylink.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/spinlock.h>
20 #include <linux/timer.h>
21 #include <linux/workqueue.h>
26 #define SUPPORTED_INTERFACES \
27 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \
28 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane)
29 #define ADVERTISED_INTERFACES \
30 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \
31 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane)
34 PHYLINK_DISABLE_STOPPED,
36 PHYLINK_DISABLE_MAC_WOL,
44 * struct phylink - internal data type for phylink
48 struct net_device *netdev;
49 const struct phylink_mac_ops *mac_ops;
50 struct phylink_config *config;
51 struct phylink_pcs *pcs;
53 unsigned int old_link_state:1;
55 unsigned long phylink_disable_state; /* bitmask of disables */
56 struct phy_device *phydev;
57 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */
58 u8 cfg_link_an_mode; /* MLO_AN_xxx */
60 u8 link_port; /* The current non-phy ethtool port */
61 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
63 /* The link configuration settings */
64 struct phylink_link_state link_config;
66 /* The current settings */
67 phy_interface_t cur_interface;
69 struct gpio_desc *link_gpio;
70 unsigned int link_irq;
71 struct timer_list link_poll;
72 void (*get_fixed_state)(struct net_device *dev,
73 struct phylink_link_state *s);
75 struct mutex state_mutex;
76 struct phylink_link_state phy_state;
77 struct work_struct resolve;
78 unsigned int pcs_neg_mode;
79 unsigned int pcs_state;
81 bool mac_link_dropped;
82 bool using_mac_select_pcs;
84 struct sfp_bus *sfp_bus;
85 bool sfp_may_have_phy;
86 DECLARE_PHY_INTERFACE_MASK(sfp_interfaces);
87 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support);
91 #define phylink_printk(level, pl, fmt, ...) \
93 if ((pl)->config->type == PHYLINK_NETDEV) \
94 netdev_printk(level, (pl)->netdev, fmt, ##__VA_ARGS__); \
95 else if ((pl)->config->type == PHYLINK_DEV) \
96 dev_printk(level, (pl)->dev, fmt, ##__VA_ARGS__); \
99 #define phylink_err(pl, fmt, ...) \
100 phylink_printk(KERN_ERR, pl, fmt, ##__VA_ARGS__)
101 #define phylink_warn(pl, fmt, ...) \
102 phylink_printk(KERN_WARNING, pl, fmt, ##__VA_ARGS__)
103 #define phylink_info(pl, fmt, ...) \
104 phylink_printk(KERN_INFO, pl, fmt, ##__VA_ARGS__)
105 #if defined(CONFIG_DYNAMIC_DEBUG)
106 #define phylink_dbg(pl, fmt, ...) \
108 if ((pl)->config->type == PHYLINK_NETDEV) \
109 netdev_dbg((pl)->netdev, fmt, ##__VA_ARGS__); \
110 else if ((pl)->config->type == PHYLINK_DEV) \
111 dev_dbg((pl)->dev, fmt, ##__VA_ARGS__); \
114 #define phylink_dbg(pl, fmt, ...) \
115 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__)
117 #define phylink_dbg(pl, fmt, ...) \
120 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__); \
125 * phylink_set_port_modes() - set the port type modes in the ethtool mask
126 * @mask: ethtool link mode mask
128 * Sets all the port type modes in the ethtool mask. MAC drivers should
129 * use this in their 'validate' callback.
131 void phylink_set_port_modes(unsigned long *mask)
133 phylink_set(mask, TP);
134 phylink_set(mask, AUI);
135 phylink_set(mask, MII);
136 phylink_set(mask, FIBRE);
137 phylink_set(mask, BNC);
138 phylink_set(mask, Backplane);
140 EXPORT_SYMBOL_GPL(phylink_set_port_modes);
142 static int phylink_is_empty_linkmode(const unsigned long *linkmode)
144 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, };
146 phylink_set_port_modes(tmp);
147 phylink_set(tmp, Autoneg);
148 phylink_set(tmp, Pause);
149 phylink_set(tmp, Asym_Pause);
151 return linkmode_subset(linkmode, tmp);
154 static const char *phylink_an_mode_str(unsigned int mode)
156 static const char *modestr[] = {
157 [MLO_AN_PHY] = "phy",
158 [MLO_AN_FIXED] = "fixed",
159 [MLO_AN_INBAND] = "inband",
162 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown";
165 static unsigned int phylink_interface_signal_rate(phy_interface_t interface)
168 case PHY_INTERFACE_MODE_SGMII:
169 case PHY_INTERFACE_MODE_1000BASEX: /* 1.25Mbd */
171 case PHY_INTERFACE_MODE_2500BASEX: /* 3.125Mbd */
173 case PHY_INTERFACE_MODE_5GBASER: /* 5.15625Mbd */
175 case PHY_INTERFACE_MODE_10GBASER: /* 10.3125Mbd */
183 * phylink_interface_max_speed() - get the maximum speed of a phy interface
184 * @interface: phy interface mode defined by &typedef phy_interface_t
186 * Determine the maximum speed of a phy interface. This is intended to help
187 * determine the correct speed to pass to the MAC when the phy is performing
190 * Return: The maximum speed of @interface
192 static int phylink_interface_max_speed(phy_interface_t interface)
195 case PHY_INTERFACE_MODE_100BASEX:
196 case PHY_INTERFACE_MODE_REVRMII:
197 case PHY_INTERFACE_MODE_RMII:
198 case PHY_INTERFACE_MODE_SMII:
199 case PHY_INTERFACE_MODE_REVMII:
200 case PHY_INTERFACE_MODE_MII:
203 case PHY_INTERFACE_MODE_TBI:
204 case PHY_INTERFACE_MODE_MOCA:
205 case PHY_INTERFACE_MODE_RTBI:
206 case PHY_INTERFACE_MODE_1000BASEX:
207 case PHY_INTERFACE_MODE_1000BASEKX:
208 case PHY_INTERFACE_MODE_TRGMII:
209 case PHY_INTERFACE_MODE_RGMII_TXID:
210 case PHY_INTERFACE_MODE_RGMII_RXID:
211 case PHY_INTERFACE_MODE_RGMII_ID:
212 case PHY_INTERFACE_MODE_RGMII:
213 case PHY_INTERFACE_MODE_QSGMII:
214 case PHY_INTERFACE_MODE_QUSGMII:
215 case PHY_INTERFACE_MODE_SGMII:
216 case PHY_INTERFACE_MODE_GMII:
219 case PHY_INTERFACE_MODE_2500BASEX:
222 case PHY_INTERFACE_MODE_5GBASER:
225 case PHY_INTERFACE_MODE_XGMII:
226 case PHY_INTERFACE_MODE_RXAUI:
227 case PHY_INTERFACE_MODE_XAUI:
228 case PHY_INTERFACE_MODE_10GBASER:
229 case PHY_INTERFACE_MODE_10GKR:
230 case PHY_INTERFACE_MODE_USXGMII:
233 case PHY_INTERFACE_MODE_25GBASER:
236 case PHY_INTERFACE_MODE_XLGMII:
239 case PHY_INTERFACE_MODE_INTERNAL:
240 case PHY_INTERFACE_MODE_NA:
241 case PHY_INTERFACE_MODE_MAX:
242 /* No idea! Garbage in, unknown out */
243 return SPEED_UNKNOWN;
246 /* If we get here, someone forgot to add an interface mode above */
248 return SPEED_UNKNOWN;
252 * phylink_caps_to_linkmodes() - Convert capabilities to ethtool link modes
253 * @linkmodes: ethtool linkmode mask (must be already initialised)
254 * @caps: bitmask of MAC capabilities
256 * Set all possible pause, speed and duplex linkmodes in @linkmodes that are
257 * supported by the @caps. @linkmodes must have been initialised previously.
259 void phylink_caps_to_linkmodes(unsigned long *linkmodes, unsigned long caps)
261 if (caps & MAC_SYM_PAUSE)
262 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT, linkmodes);
264 if (caps & MAC_ASYM_PAUSE)
265 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, linkmodes);
267 if (caps & MAC_10HD) {
268 __set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, linkmodes);
269 __set_bit(ETHTOOL_LINK_MODE_10baseT1S_Half_BIT, linkmodes);
270 __set_bit(ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT, linkmodes);
273 if (caps & MAC_10FD) {
274 __set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, linkmodes);
275 __set_bit(ETHTOOL_LINK_MODE_10baseT1L_Full_BIT, linkmodes);
276 __set_bit(ETHTOOL_LINK_MODE_10baseT1S_Full_BIT, linkmodes);
279 if (caps & MAC_100HD) {
280 __set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, linkmodes);
281 __set_bit(ETHTOOL_LINK_MODE_100baseFX_Half_BIT, linkmodes);
284 if (caps & MAC_100FD) {
285 __set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, linkmodes);
286 __set_bit(ETHTOOL_LINK_MODE_100baseT1_Full_BIT, linkmodes);
287 __set_bit(ETHTOOL_LINK_MODE_100baseFX_Full_BIT, linkmodes);
290 if (caps & MAC_1000HD)
291 __set_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, linkmodes);
293 if (caps & MAC_1000FD) {
294 __set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, linkmodes);
295 __set_bit(ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, linkmodes);
296 __set_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, linkmodes);
297 __set_bit(ETHTOOL_LINK_MODE_1000baseT1_Full_BIT, linkmodes);
300 if (caps & MAC_2500FD) {
301 __set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, linkmodes);
302 __set_bit(ETHTOOL_LINK_MODE_2500baseX_Full_BIT, linkmodes);
305 if (caps & MAC_5000FD)
306 __set_bit(ETHTOOL_LINK_MODE_5000baseT_Full_BIT, linkmodes);
308 if (caps & MAC_10000FD) {
309 __set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, linkmodes);
310 __set_bit(ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, linkmodes);
311 __set_bit(ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, linkmodes);
312 __set_bit(ETHTOOL_LINK_MODE_10000baseR_FEC_BIT, linkmodes);
313 __set_bit(ETHTOOL_LINK_MODE_10000baseCR_Full_BIT, linkmodes);
314 __set_bit(ETHTOOL_LINK_MODE_10000baseSR_Full_BIT, linkmodes);
315 __set_bit(ETHTOOL_LINK_MODE_10000baseLR_Full_BIT, linkmodes);
316 __set_bit(ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT, linkmodes);
317 __set_bit(ETHTOOL_LINK_MODE_10000baseER_Full_BIT, linkmodes);
320 if (caps & MAC_25000FD) {
321 __set_bit(ETHTOOL_LINK_MODE_25000baseCR_Full_BIT, linkmodes);
322 __set_bit(ETHTOOL_LINK_MODE_25000baseKR_Full_BIT, linkmodes);
323 __set_bit(ETHTOOL_LINK_MODE_25000baseSR_Full_BIT, linkmodes);
326 if (caps & MAC_40000FD) {
327 __set_bit(ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, linkmodes);
328 __set_bit(ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, linkmodes);
329 __set_bit(ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT, linkmodes);
330 __set_bit(ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT, linkmodes);
333 if (caps & MAC_50000FD) {
334 __set_bit(ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT, linkmodes);
335 __set_bit(ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT, linkmodes);
336 __set_bit(ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT, linkmodes);
337 __set_bit(ETHTOOL_LINK_MODE_50000baseKR_Full_BIT, linkmodes);
338 __set_bit(ETHTOOL_LINK_MODE_50000baseSR_Full_BIT, linkmodes);
339 __set_bit(ETHTOOL_LINK_MODE_50000baseCR_Full_BIT, linkmodes);
340 __set_bit(ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT,
342 __set_bit(ETHTOOL_LINK_MODE_50000baseDR_Full_BIT, linkmodes);
345 if (caps & MAC_56000FD) {
346 __set_bit(ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT, linkmodes);
347 __set_bit(ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT, linkmodes);
348 __set_bit(ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT, linkmodes);
349 __set_bit(ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT, linkmodes);
352 if (caps & MAC_100000FD) {
353 __set_bit(ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, linkmodes);
354 __set_bit(ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT, linkmodes);
355 __set_bit(ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, linkmodes);
356 __set_bit(ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT,
358 __set_bit(ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT, linkmodes);
359 __set_bit(ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT, linkmodes);
360 __set_bit(ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT, linkmodes);
361 __set_bit(ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT,
363 __set_bit(ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT, linkmodes);
364 __set_bit(ETHTOOL_LINK_MODE_100000baseKR_Full_BIT, linkmodes);
365 __set_bit(ETHTOOL_LINK_MODE_100000baseSR_Full_BIT, linkmodes);
366 __set_bit(ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT,
368 __set_bit(ETHTOOL_LINK_MODE_100000baseCR_Full_BIT, linkmodes);
369 __set_bit(ETHTOOL_LINK_MODE_100000baseDR_Full_BIT, linkmodes);
372 if (caps & MAC_200000FD) {
373 __set_bit(ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT, linkmodes);
374 __set_bit(ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT, linkmodes);
375 __set_bit(ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT,
377 __set_bit(ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT, linkmodes);
378 __set_bit(ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT, linkmodes);
379 __set_bit(ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT, linkmodes);
380 __set_bit(ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT, linkmodes);
381 __set_bit(ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT,
383 __set_bit(ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT, linkmodes);
384 __set_bit(ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT, linkmodes);
387 if (caps & MAC_400000FD) {
388 __set_bit(ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT, linkmodes);
389 __set_bit(ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT, linkmodes);
390 __set_bit(ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT,
392 __set_bit(ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT, linkmodes);
393 __set_bit(ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT, linkmodes);
394 __set_bit(ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT, linkmodes);
395 __set_bit(ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT, linkmodes);
396 __set_bit(ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT,
398 __set_bit(ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT, linkmodes);
399 __set_bit(ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT, linkmodes);
402 EXPORT_SYMBOL_GPL(phylink_caps_to_linkmodes);
408 } phylink_caps_params[] = {
409 { MAC_400000FD, SPEED_400000, DUPLEX_FULL },
410 { MAC_200000FD, SPEED_200000, DUPLEX_FULL },
411 { MAC_100000FD, SPEED_100000, DUPLEX_FULL },
412 { MAC_56000FD, SPEED_56000, DUPLEX_FULL },
413 { MAC_50000FD, SPEED_50000, DUPLEX_FULL },
414 { MAC_40000FD, SPEED_40000, DUPLEX_FULL },
415 { MAC_25000FD, SPEED_25000, DUPLEX_FULL },
416 { MAC_20000FD, SPEED_20000, DUPLEX_FULL },
417 { MAC_10000FD, SPEED_10000, DUPLEX_FULL },
418 { MAC_5000FD, SPEED_5000, DUPLEX_FULL },
419 { MAC_2500FD, SPEED_2500, DUPLEX_FULL },
420 { MAC_1000FD, SPEED_1000, DUPLEX_FULL },
421 { MAC_1000HD, SPEED_1000, DUPLEX_HALF },
422 { MAC_100FD, SPEED_100, DUPLEX_FULL },
423 { MAC_100HD, SPEED_100, DUPLEX_HALF },
424 { MAC_10FD, SPEED_10, DUPLEX_FULL },
425 { MAC_10HD, SPEED_10, DUPLEX_HALF },
429 * phylink_cap_from_speed_duplex - Get mac capability from speed/duplex
430 * @speed: the speed to search for
431 * @duplex: the duplex to search for
433 * Find the mac capability for a given speed and duplex.
435 * Return: A mask with the mac capability patching @speed and @duplex, or 0 if
436 * there were no matches.
438 static unsigned long phylink_cap_from_speed_duplex(int speed,
443 for (i = 0; i < ARRAY_SIZE(phylink_caps_params); i++) {
444 if (speed == phylink_caps_params[i].speed &&
445 duplex == phylink_caps_params[i].duplex)
446 return phylink_caps_params[i].mask;
453 * phylink_get_capabilities() - get capabilities for a given MAC
454 * @interface: phy interface mode defined by &typedef phy_interface_t
455 * @mac_capabilities: bitmask of MAC capabilities
456 * @rate_matching: type of rate matching being performed
458 * Get the MAC capabilities that are supported by the @interface mode and
461 unsigned long phylink_get_capabilities(phy_interface_t interface,
462 unsigned long mac_capabilities,
465 int max_speed = phylink_interface_max_speed(interface);
466 unsigned long caps = MAC_SYM_PAUSE | MAC_ASYM_PAUSE;
467 unsigned long matched_caps = 0;
470 case PHY_INTERFACE_MODE_USXGMII:
471 caps |= MAC_10000FD | MAC_5000FD | MAC_2500FD;
474 case PHY_INTERFACE_MODE_RGMII_TXID:
475 case PHY_INTERFACE_MODE_RGMII_RXID:
476 case PHY_INTERFACE_MODE_RGMII_ID:
477 case PHY_INTERFACE_MODE_RGMII:
478 case PHY_INTERFACE_MODE_QSGMII:
479 case PHY_INTERFACE_MODE_QUSGMII:
480 case PHY_INTERFACE_MODE_SGMII:
481 case PHY_INTERFACE_MODE_GMII:
482 caps |= MAC_1000HD | MAC_1000FD;
485 case PHY_INTERFACE_MODE_REVRMII:
486 case PHY_INTERFACE_MODE_RMII:
487 case PHY_INTERFACE_MODE_SMII:
488 case PHY_INTERFACE_MODE_REVMII:
489 case PHY_INTERFACE_MODE_MII:
490 caps |= MAC_10HD | MAC_10FD;
493 case PHY_INTERFACE_MODE_100BASEX:
494 caps |= MAC_100HD | MAC_100FD;
497 case PHY_INTERFACE_MODE_TBI:
498 case PHY_INTERFACE_MODE_MOCA:
499 case PHY_INTERFACE_MODE_RTBI:
500 case PHY_INTERFACE_MODE_1000BASEX:
503 case PHY_INTERFACE_MODE_1000BASEKX:
504 case PHY_INTERFACE_MODE_TRGMII:
508 case PHY_INTERFACE_MODE_2500BASEX:
512 case PHY_INTERFACE_MODE_5GBASER:
516 case PHY_INTERFACE_MODE_XGMII:
517 case PHY_INTERFACE_MODE_RXAUI:
518 case PHY_INTERFACE_MODE_XAUI:
519 case PHY_INTERFACE_MODE_10GBASER:
520 case PHY_INTERFACE_MODE_10GKR:
524 case PHY_INTERFACE_MODE_25GBASER:
528 case PHY_INTERFACE_MODE_XLGMII:
532 case PHY_INTERFACE_MODE_INTERNAL:
536 case PHY_INTERFACE_MODE_NA:
537 case PHY_INTERFACE_MODE_MAX:
541 switch (rate_matching) {
542 case RATE_MATCH_OPEN_LOOP:
545 case RATE_MATCH_NONE:
548 case RATE_MATCH_PAUSE: {
549 /* The MAC must support asymmetric pause towards the local
550 * device for this. We could allow just symmetric pause, but
551 * then we might have to renegotiate if the link partner
552 * doesn't support pause. This is because there's no way to
553 * accept pause frames without transmitting them if we only
554 * support symmetric pause.
556 if (!(mac_capabilities & MAC_SYM_PAUSE) ||
557 !(mac_capabilities & MAC_ASYM_PAUSE))
560 /* We can't adapt if the MAC doesn't support the interface's
561 * max speed at full duplex.
563 if (mac_capabilities &
564 phylink_cap_from_speed_duplex(max_speed, DUPLEX_FULL)) {
565 /* Although a duplex-matching phy might exist, we
566 * conservatively remove these modes because the MAC
567 * will not be aware of the half-duplex nature of the
570 matched_caps = GENMASK(__fls(caps), __fls(MAC_10HD));
571 matched_caps &= ~(MAC_1000HD | MAC_100HD | MAC_10HD);
576 /* The MAC must support half duplex at the interface's max
579 if (mac_capabilities &
580 phylink_cap_from_speed_duplex(max_speed, DUPLEX_HALF)) {
581 matched_caps = GENMASK(__fls(caps), __fls(MAC_10HD));
582 matched_caps &= mac_capabilities;
587 return (caps & mac_capabilities) | matched_caps;
589 EXPORT_SYMBOL_GPL(phylink_get_capabilities);
592 * phylink_validate_mask_caps() - Restrict link modes based on caps
593 * @supported: ethtool bitmask for supported link modes.
594 * @state: pointer to a &struct phylink_link_state.
595 * @mac_capabilities: bitmask of MAC capabilities
597 * Calculate the supported link modes based on @mac_capabilities, and restrict
598 * @supported and @state based on that. Use this function if your capabiliies
599 * aren't constant, such as if they vary depending on the interface.
601 void phylink_validate_mask_caps(unsigned long *supported,
602 struct phylink_link_state *state,
603 unsigned long mac_capabilities)
605 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
608 phylink_set_port_modes(mask);
609 phylink_set(mask, Autoneg);
610 caps = phylink_get_capabilities(state->interface, mac_capabilities,
611 state->rate_matching);
612 phylink_caps_to_linkmodes(mask, caps);
614 linkmode_and(supported, supported, mask);
615 linkmode_and(state->advertising, state->advertising, mask);
617 EXPORT_SYMBOL_GPL(phylink_validate_mask_caps);
620 * phylink_generic_validate() - generic validate() callback implementation
621 * @config: a pointer to a &struct phylink_config.
622 * @supported: ethtool bitmask for supported link modes.
623 * @state: a pointer to a &struct phylink_link_state.
625 * Generic implementation of the validate() callback that MAC drivers can
626 * use when they pass the range of supported interfaces and MAC capabilities.
628 void phylink_generic_validate(struct phylink_config *config,
629 unsigned long *supported,
630 struct phylink_link_state *state)
632 phylink_validate_mask_caps(supported, state, config->mac_capabilities);
634 EXPORT_SYMBOL_GPL(phylink_generic_validate);
636 static int phylink_validate_mac_and_pcs(struct phylink *pl,
637 unsigned long *supported,
638 struct phylink_link_state *state)
640 struct phylink_pcs *pcs;
643 /* Get the PCS for this interface mode */
644 if (pl->using_mac_select_pcs) {
645 pcs = pl->mac_ops->mac_select_pcs(pl->config, state->interface);
653 /* The PCS, if present, must be setup before phylink_create()
654 * has been called. If the ops is not initialised, print an
655 * error and backtrace rather than oopsing the kernel.
658 phylink_err(pl, "interface %s: uninitialised PCS\n",
659 phy_modes(state->interface));
664 /* Validate the link parameters with the PCS */
665 if (pcs->ops->pcs_validate) {
666 ret = pcs->ops->pcs_validate(pcs, supported, state);
667 if (ret < 0 || phylink_is_empty_linkmode(supported))
670 /* Ensure the advertising mask is a subset of the
673 linkmode_and(state->advertising, state->advertising,
678 /* Then validate the link parameters with the MAC */
679 if (pl->mac_ops->validate)
680 pl->mac_ops->validate(pl->config, supported, state);
682 phylink_generic_validate(pl->config, supported, state);
684 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0;
687 static int phylink_validate_mask(struct phylink *pl, unsigned long *supported,
688 struct phylink_link_state *state,
689 const unsigned long *interfaces)
691 __ETHTOOL_DECLARE_LINK_MODE_MASK(all_adv) = { 0, };
692 __ETHTOOL_DECLARE_LINK_MODE_MASK(all_s) = { 0, };
693 __ETHTOOL_DECLARE_LINK_MODE_MASK(s);
694 struct phylink_link_state t;
697 for (intf = 0; intf < PHY_INTERFACE_MODE_MAX; intf++) {
698 if (test_bit(intf, interfaces)) {
699 linkmode_copy(s, supported);
703 if (!phylink_validate_mac_and_pcs(pl, s, &t)) {
704 linkmode_or(all_s, all_s, s);
705 linkmode_or(all_adv, all_adv, t.advertising);
710 linkmode_copy(supported, all_s);
711 linkmode_copy(state->advertising, all_adv);
713 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0;
716 static int phylink_validate(struct phylink *pl, unsigned long *supported,
717 struct phylink_link_state *state)
719 const unsigned long *interfaces = pl->config->supported_interfaces;
721 if (state->interface == PHY_INTERFACE_MODE_NA)
722 return phylink_validate_mask(pl, supported, state, interfaces);
724 if (!test_bit(state->interface, interfaces))
727 return phylink_validate_mac_and_pcs(pl, supported, state);
730 static int phylink_parse_fixedlink(struct phylink *pl,
731 const struct fwnode_handle *fwnode)
733 struct fwnode_handle *fixed_node;
734 bool pause, asym_pause, autoneg;
735 const struct phy_setting *s;
736 struct gpio_desc *desc;
740 fixed_node = fwnode_get_named_child_node(fwnode, "fixed-link");
742 ret = fwnode_property_read_u32(fixed_node, "speed", &speed);
744 pl->link_config.speed = speed;
745 pl->link_config.duplex = DUPLEX_HALF;
747 if (fwnode_property_read_bool(fixed_node, "full-duplex"))
748 pl->link_config.duplex = DUPLEX_FULL;
750 /* We treat the "pause" and "asym-pause" terminology as
751 * defining the link partner's ability.
753 if (fwnode_property_read_bool(fixed_node, "pause"))
754 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
755 pl->link_config.lp_advertising);
756 if (fwnode_property_read_bool(fixed_node, "asym-pause"))
757 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
758 pl->link_config.lp_advertising);
761 desc = fwnode_gpiod_get_index(fixed_node, "link", 0,
765 pl->link_gpio = desc;
766 else if (desc == ERR_PTR(-EPROBE_DEFER))
769 fwnode_handle_put(fixed_node);
776 ret = fwnode_property_read_u32_array(fwnode, "fixed-link",
778 if (ret != ARRAY_SIZE(prop)) {
779 phylink_err(pl, "broken fixed-link?\n");
783 ret = fwnode_property_read_u32_array(fwnode, "fixed-link",
784 prop, ARRAY_SIZE(prop));
786 pl->link_config.duplex = prop[1] ?
787 DUPLEX_FULL : DUPLEX_HALF;
788 pl->link_config.speed = prop[2];
790 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
791 pl->link_config.lp_advertising);
793 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
794 pl->link_config.lp_advertising);
798 if (pl->link_config.speed > SPEED_1000 &&
799 pl->link_config.duplex != DUPLEX_FULL)
800 phylink_warn(pl, "fixed link specifies half duplex for %dMbps link?\n",
801 pl->link_config.speed);
803 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
804 linkmode_copy(pl->link_config.advertising, pl->supported);
805 phylink_validate(pl, pl->supported, &pl->link_config);
807 pause = phylink_test(pl->supported, Pause);
808 asym_pause = phylink_test(pl->supported, Asym_Pause);
809 autoneg = phylink_test(pl->supported, Autoneg);
810 s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex,
811 pl->supported, true);
812 linkmode_zero(pl->supported);
813 phylink_set(pl->supported, MII);
816 phylink_set(pl->supported, Pause);
819 phylink_set(pl->supported, Asym_Pause);
822 phylink_set(pl->supported, Autoneg);
825 __set_bit(s->bit, pl->supported);
826 __set_bit(s->bit, pl->link_config.lp_advertising);
828 phylink_warn(pl, "fixed link %s duplex %dMbps not recognised\n",
829 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half",
830 pl->link_config.speed);
833 linkmode_and(pl->link_config.advertising, pl->link_config.advertising,
836 pl->link_config.link = 1;
837 pl->link_config.an_complete = 1;
842 static int phylink_parse_mode(struct phylink *pl,
843 const struct fwnode_handle *fwnode)
845 struct fwnode_handle *dn;
848 dn = fwnode_get_named_child_node(fwnode, "fixed-link");
849 if (dn || fwnode_property_present(fwnode, "fixed-link"))
850 pl->cfg_link_an_mode = MLO_AN_FIXED;
851 fwnode_handle_put(dn);
853 if ((fwnode_property_read_string(fwnode, "managed", &managed) == 0 &&
854 strcmp(managed, "in-band-status") == 0) ||
855 pl->config->ovr_an_inband) {
856 if (pl->cfg_link_an_mode == MLO_AN_FIXED) {
858 "can't use both fixed-link and in-band-status\n");
862 linkmode_zero(pl->supported);
863 phylink_set(pl->supported, MII);
864 phylink_set(pl->supported, Autoneg);
865 phylink_set(pl->supported, Asym_Pause);
866 phylink_set(pl->supported, Pause);
867 pl->cfg_link_an_mode = MLO_AN_INBAND;
869 switch (pl->link_config.interface) {
870 case PHY_INTERFACE_MODE_SGMII:
871 case PHY_INTERFACE_MODE_QSGMII:
872 case PHY_INTERFACE_MODE_QUSGMII:
873 case PHY_INTERFACE_MODE_RGMII:
874 case PHY_INTERFACE_MODE_RGMII_ID:
875 case PHY_INTERFACE_MODE_RGMII_RXID:
876 case PHY_INTERFACE_MODE_RGMII_TXID:
877 case PHY_INTERFACE_MODE_RTBI:
878 phylink_set(pl->supported, 10baseT_Half);
879 phylink_set(pl->supported, 10baseT_Full);
880 phylink_set(pl->supported, 100baseT_Half);
881 phylink_set(pl->supported, 100baseT_Full);
882 phylink_set(pl->supported, 1000baseT_Half);
883 phylink_set(pl->supported, 1000baseT_Full);
886 case PHY_INTERFACE_MODE_1000BASEX:
887 phylink_set(pl->supported, 1000baseX_Full);
890 case PHY_INTERFACE_MODE_2500BASEX:
891 phylink_set(pl->supported, 2500baseX_Full);
894 case PHY_INTERFACE_MODE_5GBASER:
895 phylink_set(pl->supported, 5000baseT_Full);
898 case PHY_INTERFACE_MODE_25GBASER:
899 phylink_set(pl->supported, 25000baseCR_Full);
900 phylink_set(pl->supported, 25000baseKR_Full);
901 phylink_set(pl->supported, 25000baseSR_Full);
903 case PHY_INTERFACE_MODE_USXGMII:
904 case PHY_INTERFACE_MODE_10GKR:
905 case PHY_INTERFACE_MODE_10GBASER:
906 phylink_set(pl->supported, 10baseT_Half);
907 phylink_set(pl->supported, 10baseT_Full);
908 phylink_set(pl->supported, 100baseT_Half);
909 phylink_set(pl->supported, 100baseT_Full);
910 phylink_set(pl->supported, 1000baseT_Half);
911 phylink_set(pl->supported, 1000baseT_Full);
912 phylink_set(pl->supported, 1000baseX_Full);
913 phylink_set(pl->supported, 1000baseKX_Full);
914 phylink_set(pl->supported, 2500baseT_Full);
915 phylink_set(pl->supported, 2500baseX_Full);
916 phylink_set(pl->supported, 5000baseT_Full);
917 phylink_set(pl->supported, 10000baseT_Full);
918 phylink_set(pl->supported, 10000baseKR_Full);
919 phylink_set(pl->supported, 10000baseKX4_Full);
920 phylink_set(pl->supported, 10000baseCR_Full);
921 phylink_set(pl->supported, 10000baseSR_Full);
922 phylink_set(pl->supported, 10000baseLR_Full);
923 phylink_set(pl->supported, 10000baseLRM_Full);
924 phylink_set(pl->supported, 10000baseER_Full);
927 case PHY_INTERFACE_MODE_XLGMII:
928 phylink_set(pl->supported, 25000baseCR_Full);
929 phylink_set(pl->supported, 25000baseKR_Full);
930 phylink_set(pl->supported, 25000baseSR_Full);
931 phylink_set(pl->supported, 40000baseKR4_Full);
932 phylink_set(pl->supported, 40000baseCR4_Full);
933 phylink_set(pl->supported, 40000baseSR4_Full);
934 phylink_set(pl->supported, 40000baseLR4_Full);
935 phylink_set(pl->supported, 50000baseCR2_Full);
936 phylink_set(pl->supported, 50000baseKR2_Full);
937 phylink_set(pl->supported, 50000baseSR2_Full);
938 phylink_set(pl->supported, 50000baseKR_Full);
939 phylink_set(pl->supported, 50000baseSR_Full);
940 phylink_set(pl->supported, 50000baseCR_Full);
941 phylink_set(pl->supported, 50000baseLR_ER_FR_Full);
942 phylink_set(pl->supported, 50000baseDR_Full);
943 phylink_set(pl->supported, 100000baseKR4_Full);
944 phylink_set(pl->supported, 100000baseSR4_Full);
945 phylink_set(pl->supported, 100000baseCR4_Full);
946 phylink_set(pl->supported, 100000baseLR4_ER4_Full);
947 phylink_set(pl->supported, 100000baseKR2_Full);
948 phylink_set(pl->supported, 100000baseSR2_Full);
949 phylink_set(pl->supported, 100000baseCR2_Full);
950 phylink_set(pl->supported, 100000baseLR2_ER2_FR2_Full);
951 phylink_set(pl->supported, 100000baseDR2_Full);
956 "incorrect link mode %s for in-band status\n",
957 phy_modes(pl->link_config.interface));
961 linkmode_copy(pl->link_config.advertising, pl->supported);
963 if (phylink_validate(pl, pl->supported, &pl->link_config)) {
965 "failed to validate link configuration for in-band status\n");
973 static void phylink_apply_manual_flow(struct phylink *pl,
974 struct phylink_link_state *state)
976 /* If autoneg is disabled, pause AN is also disabled */
977 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
979 state->pause &= ~MLO_PAUSE_AN;
981 /* Manual configuration of pause modes */
982 if (!(pl->link_config.pause & MLO_PAUSE_AN))
983 state->pause = pl->link_config.pause;
986 static void phylink_resolve_an_pause(struct phylink_link_state *state)
988 bool tx_pause, rx_pause;
990 if (state->duplex == DUPLEX_FULL) {
991 linkmode_resolve_pause(state->advertising,
992 state->lp_advertising,
993 &tx_pause, &rx_pause);
995 state->pause |= MLO_PAUSE_TX;
997 state->pause |= MLO_PAUSE_RX;
1001 static void phylink_pcs_disable(struct phylink_pcs *pcs)
1003 if (pcs && pcs->ops->pcs_disable)
1004 pcs->ops->pcs_disable(pcs);
1007 static int phylink_pcs_enable(struct phylink_pcs *pcs)
1011 if (pcs && pcs->ops->pcs_enable)
1012 err = pcs->ops->pcs_enable(pcs);
1017 static int phylink_pcs_config(struct phylink_pcs *pcs, unsigned int neg_mode,
1018 const struct phylink_link_state *state,
1019 bool permit_pause_to_mac)
1024 return pcs->ops->pcs_config(pcs, neg_mode, state->interface,
1025 state->advertising, permit_pause_to_mac);
1028 static void phylink_pcs_link_up(struct phylink_pcs *pcs, unsigned int neg_mode,
1029 phy_interface_t interface, int speed,
1032 if (pcs && pcs->ops->pcs_link_up)
1033 pcs->ops->pcs_link_up(pcs, neg_mode, interface, speed, duplex);
1036 static void phylink_pcs_poll_stop(struct phylink *pl)
1038 if (pl->cfg_link_an_mode == MLO_AN_INBAND)
1039 del_timer(&pl->link_poll);
1042 static void phylink_pcs_poll_start(struct phylink *pl)
1044 if (pl->pcs && pl->pcs->poll && pl->cfg_link_an_mode == MLO_AN_INBAND)
1045 mod_timer(&pl->link_poll, jiffies + HZ);
1048 static void phylink_mac_config(struct phylink *pl,
1049 const struct phylink_link_state *state)
1052 "%s: mode=%s/%s/%s/%s/%s adv=%*pb pause=%02x link=%u\n",
1053 __func__, phylink_an_mode_str(pl->cur_link_an_mode),
1054 phy_modes(state->interface),
1055 phy_speed_to_str(state->speed),
1056 phy_duplex_to_str(state->duplex),
1057 phy_rate_matching_to_str(state->rate_matching),
1058 __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising,
1059 state->pause, state->link);
1061 pl->mac_ops->mac_config(pl->config, pl->cur_link_an_mode, state);
1064 static void phylink_mac_pcs_an_restart(struct phylink *pl)
1066 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1067 pl->link_config.advertising) &&
1068 phy_interface_mode_is_8023z(pl->link_config.interface) &&
1069 phylink_autoneg_inband(pl->cur_link_an_mode)) {
1071 pl->pcs->ops->pcs_an_restart(pl->pcs);
1072 else if (pl->config->legacy_pre_march2020)
1073 pl->mac_ops->mac_an_restart(pl->config);
1077 static void phylink_major_config(struct phylink *pl, bool restart,
1078 const struct phylink_link_state *state)
1080 struct phylink_pcs *pcs = NULL;
1081 bool pcs_changed = false;
1082 unsigned int rate_kbd;
1083 unsigned int neg_mode;
1086 phylink_dbg(pl, "major config %s\n", phy_modes(state->interface));
1088 pl->pcs_neg_mode = phylink_pcs_neg_mode(pl->cur_link_an_mode,
1090 state->advertising);
1092 if (pl->using_mac_select_pcs) {
1093 pcs = pl->mac_ops->mac_select_pcs(pl->config, state->interface);
1096 "mac_select_pcs unexpectedly failed: %pe\n",
1101 pcs_changed = pcs && pl->pcs != pcs;
1104 phylink_pcs_poll_stop(pl);
1106 if (pl->mac_ops->mac_prepare) {
1107 err = pl->mac_ops->mac_prepare(pl->config, pl->cur_link_an_mode,
1110 phylink_err(pl, "mac_prepare failed: %pe\n",
1116 /* If we have a new PCS, switch to the new PCS after preparing the MAC
1120 phylink_pcs_disable(pl->pcs);
1125 phylink_mac_config(pl, state);
1127 if (pl->pcs_state == PCS_STATE_STARTING || pcs_changed)
1128 phylink_pcs_enable(pl->pcs);
1130 neg_mode = pl->cur_link_an_mode;
1131 if (pl->pcs && pl->pcs->neg_mode)
1132 neg_mode = pl->pcs_neg_mode;
1134 err = phylink_pcs_config(pl->pcs, neg_mode, state,
1135 !!(pl->link_config.pause & MLO_PAUSE_AN));
1137 phylink_err(pl, "pcs_config failed: %pe\n",
1143 phylink_mac_pcs_an_restart(pl);
1145 if (pl->mac_ops->mac_finish) {
1146 err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,
1149 phylink_err(pl, "mac_finish failed: %pe\n",
1154 rate_kbd = phylink_interface_signal_rate(state->interface);
1156 sfp_upstream_set_signal_rate(pl->sfp_bus, rate_kbd);
1159 phylink_pcs_poll_start(pl);
1163 * Reconfigure for a change of inband advertisement.
1164 * If we have a separate PCS, we only need to call its pcs_config() method,
1165 * and then restart AN if it indicates something changed. Otherwise, we do
1166 * the full MAC reconfiguration.
1168 static int phylink_change_inband_advert(struct phylink *pl)
1170 unsigned int neg_mode;
1173 if (test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state))
1176 if (!pl->pcs && pl->config->legacy_pre_march2020) {
1178 phylink_mac_config(pl, &pl->link_config);
1179 phylink_mac_pcs_an_restart(pl);
1183 phylink_dbg(pl, "%s: mode=%s/%s adv=%*pb pause=%02x\n", __func__,
1184 phylink_an_mode_str(pl->cur_link_an_mode),
1185 phy_modes(pl->link_config.interface),
1186 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->link_config.advertising,
1187 pl->link_config.pause);
1189 /* Recompute the PCS neg mode */
1190 pl->pcs_neg_mode = phylink_pcs_neg_mode(pl->cur_link_an_mode,
1191 pl->link_config.interface,
1192 pl->link_config.advertising);
1194 neg_mode = pl->cur_link_an_mode;
1195 if (pl->pcs->neg_mode)
1196 neg_mode = pl->pcs_neg_mode;
1198 /* Modern PCS-based method; update the advert at the PCS, and
1199 * restart negotiation if the pcs_config() helper indicates that
1200 * the programmed advertisement has changed.
1202 ret = phylink_pcs_config(pl->pcs, neg_mode, &pl->link_config,
1203 !!(pl->link_config.pause & MLO_PAUSE_AN));
1208 phylink_mac_pcs_an_restart(pl);
1213 static void phylink_mac_pcs_get_state(struct phylink *pl,
1214 struct phylink_link_state *state)
1216 linkmode_copy(state->advertising, pl->link_config.advertising);
1217 linkmode_zero(state->lp_advertising);
1218 state->interface = pl->link_config.interface;
1219 state->rate_matching = pl->link_config.rate_matching;
1220 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
1221 state->advertising)) {
1222 state->speed = SPEED_UNKNOWN;
1223 state->duplex = DUPLEX_UNKNOWN;
1224 state->pause = MLO_PAUSE_NONE;
1226 state->speed = pl->link_config.speed;
1227 state->duplex = pl->link_config.duplex;
1228 state->pause = pl->link_config.pause;
1230 state->an_complete = 0;
1234 pl->pcs->ops->pcs_get_state(pl->pcs, state);
1235 else if (pl->mac_ops->mac_pcs_get_state &&
1236 pl->config->legacy_pre_march2020)
1237 pl->mac_ops->mac_pcs_get_state(pl->config, state);
1242 /* The fixed state is... fixed except for the link state,
1243 * which may be determined by a GPIO or a callback.
1245 static void phylink_get_fixed_state(struct phylink *pl,
1246 struct phylink_link_state *state)
1248 *state = pl->link_config;
1249 if (pl->config->get_fixed_state)
1250 pl->config->get_fixed_state(pl->config, state);
1251 else if (pl->link_gpio)
1252 state->link = !!gpiod_get_value_cansleep(pl->link_gpio);
1254 state->pause = MLO_PAUSE_NONE;
1255 phylink_resolve_an_pause(state);
1258 static void phylink_mac_initial_config(struct phylink *pl, bool force_restart)
1260 struct phylink_link_state link_state;
1262 switch (pl->cur_link_an_mode) {
1264 link_state = pl->phy_state;
1268 phylink_get_fixed_state(pl, &link_state);
1272 link_state = pl->link_config;
1273 if (link_state.interface == PHY_INTERFACE_MODE_SGMII)
1274 link_state.pause = MLO_PAUSE_NONE;
1277 default: /* can't happen */
1281 link_state.link = false;
1283 phylink_apply_manual_flow(pl, &link_state);
1284 phylink_major_config(pl, force_restart, &link_state);
1287 static const char *phylink_pause_to_str(int pause)
1289 switch (pause & MLO_PAUSE_TXRX_MASK) {
1290 case MLO_PAUSE_TX | MLO_PAUSE_RX:
1301 static void phylink_link_up(struct phylink *pl,
1302 struct phylink_link_state link_state)
1304 struct net_device *ndev = pl->netdev;
1305 unsigned int neg_mode;
1309 speed = link_state.speed;
1310 duplex = link_state.duplex;
1311 rx_pause = !!(link_state.pause & MLO_PAUSE_RX);
1313 switch (link_state.rate_matching) {
1314 case RATE_MATCH_PAUSE:
1315 /* The PHY is doing rate matchion from the media rate (in
1316 * the link_state) to the interface speed, and will send
1317 * pause frames to the MAC to limit its transmission speed.
1319 speed = phylink_interface_max_speed(link_state.interface);
1320 duplex = DUPLEX_FULL;
1324 case RATE_MATCH_CRS:
1325 /* The PHY is doing rate matchion from the media rate (in
1326 * the link_state) to the interface speed, and will cause
1327 * collisions to the MAC to limit its transmission speed.
1329 speed = phylink_interface_max_speed(link_state.interface);
1330 duplex = DUPLEX_HALF;
1334 pl->cur_interface = link_state.interface;
1336 neg_mode = pl->cur_link_an_mode;
1337 if (pl->pcs && pl->pcs->neg_mode)
1338 neg_mode = pl->pcs_neg_mode;
1340 phylink_pcs_link_up(pl->pcs, neg_mode, pl->cur_interface, speed,
1343 pl->mac_ops->mac_link_up(pl->config, pl->phydev, pl->cur_link_an_mode,
1344 pl->cur_interface, speed, duplex,
1345 !!(link_state.pause & MLO_PAUSE_TX), rx_pause);
1348 netif_carrier_on(ndev);
1351 "Link is Up - %s/%s - flow control %s\n",
1352 phy_speed_to_str(link_state.speed),
1353 phy_duplex_to_str(link_state.duplex),
1354 phylink_pause_to_str(link_state.pause));
1357 static void phylink_link_down(struct phylink *pl)
1359 struct net_device *ndev = pl->netdev;
1362 netif_carrier_off(ndev);
1363 pl->mac_ops->mac_link_down(pl->config, pl->cur_link_an_mode,
1365 phylink_info(pl, "Link is Down\n");
1368 static void phylink_resolve(struct work_struct *w)
1370 struct phylink *pl = container_of(w, struct phylink, resolve);
1371 struct phylink_link_state link_state;
1372 struct net_device *ndev = pl->netdev;
1373 bool mac_config = false;
1374 bool retrigger = false;
1375 bool cur_link_state;
1377 mutex_lock(&pl->state_mutex);
1379 cur_link_state = netif_carrier_ok(ndev);
1381 cur_link_state = pl->old_link_state;
1383 if (pl->phylink_disable_state) {
1384 pl->mac_link_dropped = false;
1385 link_state.link = false;
1386 } else if (pl->mac_link_dropped) {
1387 link_state.link = false;
1390 switch (pl->cur_link_an_mode) {
1392 link_state = pl->phy_state;
1393 phylink_apply_manual_flow(pl, &link_state);
1394 mac_config = link_state.link;
1398 phylink_get_fixed_state(pl, &link_state);
1399 mac_config = link_state.link;
1403 phylink_mac_pcs_get_state(pl, &link_state);
1405 /* The PCS may have a latching link-fail indicator.
1406 * If the link was up, bring the link down and
1407 * re-trigger the resolve. Otherwise, re-read the
1408 * PCS state to get the current status of the link.
1410 if (!link_state.link) {
1414 phylink_mac_pcs_get_state(pl,
1418 /* If we have a phy, the "up" state is the union of
1419 * both the PHY and the MAC
1422 link_state.link &= pl->phy_state.link;
1424 /* Only update if the PHY link is up */
1425 if (pl->phydev && pl->phy_state.link) {
1426 /* If the interface has changed, force a
1427 * link down event if the link isn't already
1428 * down, and re-resolve.
1430 if (link_state.interface !=
1431 pl->phy_state.interface) {
1433 link_state.link = false;
1435 link_state.interface = pl->phy_state.interface;
1437 /* If we are doing rate matching, then the
1438 * link speed/duplex comes from the PHY
1440 if (pl->phy_state.rate_matching) {
1441 link_state.rate_matching =
1442 pl->phy_state.rate_matching;
1443 link_state.speed = pl->phy_state.speed;
1445 pl->phy_state.duplex;
1448 /* If we have a PHY, we need to update with
1449 * the PHY flow control bits.
1451 link_state.pause = pl->phy_state.pause;
1454 phylink_apply_manual_flow(pl, &link_state);
1460 if (link_state.interface != pl->link_config.interface) {
1461 /* The interface has changed, force the link down and
1464 if (cur_link_state) {
1465 phylink_link_down(pl);
1466 cur_link_state = false;
1468 phylink_major_config(pl, false, &link_state);
1469 pl->link_config.interface = link_state.interface;
1470 } else if (!pl->pcs && pl->config->legacy_pre_march2020) {
1471 /* The interface remains unchanged, only the speed,
1472 * duplex or pause settings have changed. Call the
1473 * old mac_config() method to configure the MAC/PCS
1474 * only if we do not have a legacy MAC driver.
1476 phylink_mac_config(pl, &link_state);
1480 if (link_state.link != cur_link_state) {
1481 pl->old_link_state = link_state.link;
1482 if (!link_state.link)
1483 phylink_link_down(pl);
1485 phylink_link_up(pl, link_state);
1487 if (!link_state.link && retrigger) {
1488 pl->mac_link_dropped = false;
1489 queue_work(system_power_efficient_wq, &pl->resolve);
1491 mutex_unlock(&pl->state_mutex);
1494 static void phylink_run_resolve(struct phylink *pl)
1496 if (!pl->phylink_disable_state)
1497 queue_work(system_power_efficient_wq, &pl->resolve);
1500 static void phylink_run_resolve_and_disable(struct phylink *pl, int bit)
1502 unsigned long state = pl->phylink_disable_state;
1504 set_bit(bit, &pl->phylink_disable_state);
1506 queue_work(system_power_efficient_wq, &pl->resolve);
1507 flush_work(&pl->resolve);
1511 static void phylink_enable_and_run_resolve(struct phylink *pl, int bit)
1513 clear_bit(bit, &pl->phylink_disable_state);
1514 phylink_run_resolve(pl);
1517 static void phylink_fixed_poll(struct timer_list *t)
1519 struct phylink *pl = container_of(t, struct phylink, link_poll);
1521 mod_timer(t, jiffies + HZ);
1523 phylink_run_resolve(pl);
1526 static const struct sfp_upstream_ops sfp_phylink_ops;
1528 static int phylink_register_sfp(struct phylink *pl,
1529 const struct fwnode_handle *fwnode)
1531 struct sfp_bus *bus;
1537 bus = sfp_bus_find_fwnode(fwnode);
1539 phylink_err(pl, "unable to attach SFP bus: %pe\n", bus);
1540 return PTR_ERR(bus);
1545 ret = sfp_bus_add_upstream(bus, pl, &sfp_phylink_ops);
1552 * phylink_create() - create a phylink instance
1553 * @config: a pointer to the target &struct phylink_config
1554 * @fwnode: a pointer to a &struct fwnode_handle describing the network
1556 * @iface: the desired link mode defined by &typedef phy_interface_t
1557 * @mac_ops: a pointer to a &struct phylink_mac_ops for the MAC.
1559 * Create a new phylink instance, and parse the link parameters found in @np.
1560 * This will parse in-band modes, fixed-link or SFP configuration.
1562 * Note: the rtnl lock must not be held when calling this function.
1564 * Returns a pointer to a &struct phylink, or an error-pointer value. Users
1565 * must use IS_ERR() to check for errors from this function.
1567 struct phylink *phylink_create(struct phylink_config *config,
1568 const struct fwnode_handle *fwnode,
1569 phy_interface_t iface,
1570 const struct phylink_mac_ops *mac_ops)
1572 bool using_mac_select_pcs = false;
1576 /* Validate the supplied configuration */
1577 if (phy_interface_empty(config->supported_interfaces)) {
1578 dev_err(config->dev,
1579 "phylink: error: empty supported_interfaces\n");
1580 return ERR_PTR(-EINVAL);
1583 if (mac_ops->mac_select_pcs &&
1584 mac_ops->mac_select_pcs(config, PHY_INTERFACE_MODE_NA) !=
1585 ERR_PTR(-EOPNOTSUPP))
1586 using_mac_select_pcs = true;
1588 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
1590 return ERR_PTR(-ENOMEM);
1592 mutex_init(&pl->state_mutex);
1593 INIT_WORK(&pl->resolve, phylink_resolve);
1595 pl->config = config;
1596 if (config->type == PHYLINK_NETDEV) {
1597 pl->netdev = to_net_dev(config->dev);
1598 } else if (config->type == PHYLINK_DEV) {
1599 pl->dev = config->dev;
1602 return ERR_PTR(-EINVAL);
1605 pl->using_mac_select_pcs = using_mac_select_pcs;
1606 pl->phy_state.interface = iface;
1607 pl->link_interface = iface;
1608 if (iface == PHY_INTERFACE_MODE_MOCA)
1609 pl->link_port = PORT_BNC;
1611 pl->link_port = PORT_MII;
1612 pl->link_config.interface = iface;
1613 pl->link_config.pause = MLO_PAUSE_AN;
1614 pl->link_config.speed = SPEED_UNKNOWN;
1615 pl->link_config.duplex = DUPLEX_UNKNOWN;
1616 pl->pcs_state = PCS_STATE_DOWN;
1617 pl->mac_ops = mac_ops;
1618 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
1619 timer_setup(&pl->link_poll, phylink_fixed_poll, 0);
1621 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
1622 linkmode_copy(pl->link_config.advertising, pl->supported);
1623 phylink_validate(pl, pl->supported, &pl->link_config);
1625 ret = phylink_parse_mode(pl, fwnode);
1628 return ERR_PTR(ret);
1631 if (pl->cfg_link_an_mode == MLO_AN_FIXED) {
1632 ret = phylink_parse_fixedlink(pl, fwnode);
1635 return ERR_PTR(ret);
1639 pl->cur_link_an_mode = pl->cfg_link_an_mode;
1641 ret = phylink_register_sfp(pl, fwnode);
1644 return ERR_PTR(ret);
1649 EXPORT_SYMBOL_GPL(phylink_create);
1652 * phylink_destroy() - cleanup and destroy the phylink instance
1653 * @pl: a pointer to a &struct phylink returned from phylink_create()
1655 * Destroy a phylink instance. Any PHY that has been attached must have been
1656 * cleaned up via phylink_disconnect_phy() prior to calling this function.
1658 * Note: the rtnl lock must not be held when calling this function.
1660 void phylink_destroy(struct phylink *pl)
1662 sfp_bus_del_upstream(pl->sfp_bus);
1664 gpiod_put(pl->link_gpio);
1666 cancel_work_sync(&pl->resolve);
1669 EXPORT_SYMBOL_GPL(phylink_destroy);
1672 * phylink_expects_phy() - Determine if phylink expects a phy to be attached
1673 * @pl: a pointer to a &struct phylink returned from phylink_create()
1675 * When using fixed-link mode, or in-band mode with 1000base-X or 2500base-X,
1678 * Returns true if phylink will be expecting a PHY.
1680 bool phylink_expects_phy(struct phylink *pl)
1682 if (pl->cfg_link_an_mode == MLO_AN_FIXED ||
1683 (pl->cfg_link_an_mode == MLO_AN_INBAND &&
1684 phy_interface_mode_is_8023z(pl->link_config.interface)))
1688 EXPORT_SYMBOL_GPL(phylink_expects_phy);
1690 static void phylink_phy_change(struct phy_device *phydev, bool up)
1692 struct phylink *pl = phydev->phylink;
1693 bool tx_pause, rx_pause;
1695 phy_get_pause(phydev, &tx_pause, &rx_pause);
1697 mutex_lock(&pl->state_mutex);
1698 pl->phy_state.speed = phydev->speed;
1699 pl->phy_state.duplex = phydev->duplex;
1700 pl->phy_state.rate_matching = phydev->rate_matching;
1701 pl->phy_state.pause = MLO_PAUSE_NONE;
1703 pl->phy_state.pause |= MLO_PAUSE_TX;
1705 pl->phy_state.pause |= MLO_PAUSE_RX;
1706 pl->phy_state.interface = phydev->interface;
1707 pl->phy_state.link = up;
1708 mutex_unlock(&pl->state_mutex);
1710 phylink_run_resolve(pl);
1712 phylink_dbg(pl, "phy link %s %s/%s/%s/%s/%s\n", up ? "up" : "down",
1713 phy_modes(phydev->interface),
1714 phy_speed_to_str(phydev->speed),
1715 phy_duplex_to_str(phydev->duplex),
1716 phy_rate_matching_to_str(phydev->rate_matching),
1717 phylink_pause_to_str(pl->phy_state.pause));
1720 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy,
1721 phy_interface_t interface)
1723 struct phylink_link_state config;
1724 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
1729 * This is the new way of dealing with flow control for PHYs,
1730 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
1731 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
1732 * using our validate call to the MAC, we rely upon the MAC
1733 * clearing the bits from both supported and advertising fields.
1735 phy_support_asym_pause(phy);
1737 memset(&config, 0, sizeof(config));
1738 linkmode_copy(supported, phy->supported);
1739 linkmode_copy(config.advertising, phy->advertising);
1741 /* Check whether we would use rate matching for the proposed interface
1744 config.rate_matching = phy_get_rate_matching(phy, interface);
1746 /* Clause 45 PHYs may switch their Serdes lane between, e.g. 10GBASE-R,
1747 * 5GBASE-R, 2500BASE-X and SGMII if they are not using rate matching.
1748 * For some interface modes (e.g. RXAUI, XAUI and USXGMII) switching
1749 * their Serdes is either unnecessary or not reasonable.
1751 * For these which switch interface modes, we really need to know which
1752 * interface modes the PHY supports to properly work out which ethtool
1753 * linkmodes can be supported. For now, as a work-around, we validate
1754 * against all interface modes, which may lead to more ethtool link
1755 * modes being advertised than are actually supported.
1757 if (phy->is_c45 && config.rate_matching == RATE_MATCH_NONE &&
1758 interface != PHY_INTERFACE_MODE_RXAUI &&
1759 interface != PHY_INTERFACE_MODE_XAUI &&
1760 interface != PHY_INTERFACE_MODE_USXGMII)
1761 config.interface = PHY_INTERFACE_MODE_NA;
1763 config.interface = interface;
1765 ret = phylink_validate(pl, supported, &config);
1767 phylink_warn(pl, "validation of %s with support %*pb and advertisement %*pb failed: %pe\n",
1768 phy_modes(config.interface),
1769 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->supported,
1770 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising,
1776 phy->phy_link_change = phylink_phy_change;
1778 irq_str = phy_attached_info_irq(phy);
1780 "PHY [%s] driver [%s] (irq=%s)\n",
1781 dev_name(&phy->mdio.dev), phy->drv->name, irq_str);
1784 mutex_lock(&phy->lock);
1785 mutex_lock(&pl->state_mutex);
1787 pl->phy_state.interface = interface;
1788 pl->phy_state.pause = MLO_PAUSE_NONE;
1789 pl->phy_state.speed = SPEED_UNKNOWN;
1790 pl->phy_state.duplex = DUPLEX_UNKNOWN;
1791 pl->phy_state.rate_matching = RATE_MATCH_NONE;
1792 linkmode_copy(pl->supported, supported);
1793 linkmode_copy(pl->link_config.advertising, config.advertising);
1795 /* Restrict the phy advertisement according to the MAC support. */
1796 linkmode_copy(phy->advertising, config.advertising);
1797 mutex_unlock(&pl->state_mutex);
1798 mutex_unlock(&phy->lock);
1801 "phy: %s setting supported %*pb advertising %*pb\n",
1802 phy_modes(interface),
1803 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported,
1804 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->advertising);
1806 if (phy_interrupt_is_valid(phy))
1807 phy_request_interrupt(phy);
1809 if (pl->config->mac_managed_pm)
1810 phy->mac_managed_pm = true;
1815 static int phylink_attach_phy(struct phylink *pl, struct phy_device *phy,
1816 phy_interface_t interface)
1818 if (WARN_ON(pl->cfg_link_an_mode == MLO_AN_FIXED ||
1819 (pl->cfg_link_an_mode == MLO_AN_INBAND &&
1820 phy_interface_mode_is_8023z(interface) && !pl->sfp_bus)))
1826 return phy_attach_direct(pl->netdev, phy, 0, interface);
1830 * phylink_connect_phy() - connect a PHY to the phylink instance
1831 * @pl: a pointer to a &struct phylink returned from phylink_create()
1832 * @phy: a pointer to a &struct phy_device.
1834 * Connect @phy to the phylink instance specified by @pl by calling
1835 * phy_attach_direct(). Configure the @phy according to the MAC driver's
1836 * capabilities, start the PHYLIB state machine and enable any interrupts
1837 * that the PHY supports.
1839 * This updates the phylink's ethtool supported and advertising link mode
1842 * Returns 0 on success or a negative errno.
1844 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy)
1848 /* Use PHY device/driver interface */
1849 if (pl->link_interface == PHY_INTERFACE_MODE_NA) {
1850 pl->link_interface = phy->interface;
1851 pl->link_config.interface = pl->link_interface;
1854 ret = phylink_attach_phy(pl, phy, pl->link_interface);
1858 ret = phylink_bringup_phy(pl, phy, pl->link_config.interface);
1864 EXPORT_SYMBOL_GPL(phylink_connect_phy);
1867 * phylink_of_phy_connect() - connect the PHY specified in the DT mode.
1868 * @pl: a pointer to a &struct phylink returned from phylink_create()
1869 * @dn: a pointer to a &struct device_node.
1870 * @flags: PHY-specific flags to communicate to the PHY device driver
1872 * Connect the phy specified in the device node @dn to the phylink instance
1873 * specified by @pl. Actions specified in phylink_connect_phy() will be
1876 * Returns 0 on success or a negative errno.
1878 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn,
1881 return phylink_fwnode_phy_connect(pl, of_fwnode_handle(dn), flags);
1883 EXPORT_SYMBOL_GPL(phylink_of_phy_connect);
1886 * phylink_fwnode_phy_connect() - connect the PHY specified in the fwnode.
1887 * @pl: a pointer to a &struct phylink returned from phylink_create()
1888 * @fwnode: a pointer to a &struct fwnode_handle.
1889 * @flags: PHY-specific flags to communicate to the PHY device driver
1891 * Connect the phy specified @fwnode to the phylink instance specified
1894 * Returns 0 on success or a negative errno.
1896 int phylink_fwnode_phy_connect(struct phylink *pl,
1897 const struct fwnode_handle *fwnode,
1900 struct fwnode_handle *phy_fwnode;
1901 struct phy_device *phy_dev;
1904 /* Fixed links and 802.3z are handled without needing a PHY */
1905 if (pl->cfg_link_an_mode == MLO_AN_FIXED ||
1906 (pl->cfg_link_an_mode == MLO_AN_INBAND &&
1907 phy_interface_mode_is_8023z(pl->link_interface)))
1910 phy_fwnode = fwnode_get_phy_node(fwnode);
1911 if (IS_ERR(phy_fwnode)) {
1912 if (pl->cfg_link_an_mode == MLO_AN_PHY)
1917 phy_dev = fwnode_phy_find_device(phy_fwnode);
1918 /* We're done with the phy_node handle */
1919 fwnode_handle_put(phy_fwnode);
1923 /* Use PHY device/driver interface */
1924 if (pl->link_interface == PHY_INTERFACE_MODE_NA) {
1925 pl->link_interface = phy_dev->interface;
1926 pl->link_config.interface = pl->link_interface;
1929 ret = phy_attach_direct(pl->netdev, phy_dev, flags,
1930 pl->link_interface);
1931 phy_device_free(phy_dev);
1935 ret = phylink_bringup_phy(pl, phy_dev, pl->link_config.interface);
1937 phy_detach(phy_dev);
1941 EXPORT_SYMBOL_GPL(phylink_fwnode_phy_connect);
1944 * phylink_disconnect_phy() - disconnect any PHY attached to the phylink
1946 * @pl: a pointer to a &struct phylink returned from phylink_create()
1948 * Disconnect any current PHY from the phylink instance described by @pl.
1950 void phylink_disconnect_phy(struct phylink *pl)
1952 struct phy_device *phy;
1958 mutex_lock(&phy->lock);
1959 mutex_lock(&pl->state_mutex);
1961 mutex_unlock(&pl->state_mutex);
1962 mutex_unlock(&phy->lock);
1963 flush_work(&pl->resolve);
1965 phy_disconnect(phy);
1968 EXPORT_SYMBOL_GPL(phylink_disconnect_phy);
1971 * phylink_mac_change() - notify phylink of a change in MAC state
1972 * @pl: a pointer to a &struct phylink returned from phylink_create()
1973 * @up: indicates whether the link is currently up.
1975 * The MAC driver should call this driver when the state of its link
1976 * changes (eg, link failure, new negotiation results, etc.)
1978 void phylink_mac_change(struct phylink *pl, bool up)
1981 pl->mac_link_dropped = true;
1982 phylink_run_resolve(pl);
1983 phylink_dbg(pl, "mac link %s\n", up ? "up" : "down");
1985 EXPORT_SYMBOL_GPL(phylink_mac_change);
1987 static irqreturn_t phylink_link_handler(int irq, void *data)
1989 struct phylink *pl = data;
1991 phylink_run_resolve(pl);
1997 * phylink_start() - start a phylink instance
1998 * @pl: a pointer to a &struct phylink returned from phylink_create()
2000 * Start the phylink instance specified by @pl, configuring the MAC for the
2001 * desired link mode(s) and negotiation style. This should be called from the
2002 * network device driver's &struct net_device_ops ndo_open() method.
2004 void phylink_start(struct phylink *pl)
2010 phylink_info(pl, "configuring for %s/%s link mode\n",
2011 phylink_an_mode_str(pl->cur_link_an_mode),
2012 phy_modes(pl->link_config.interface));
2014 /* Always set the carrier off */
2016 netif_carrier_off(pl->netdev);
2018 pl->pcs_state = PCS_STATE_STARTING;
2020 /* Apply the link configuration to the MAC when starting. This allows
2021 * a fixed-link to start with the correct parameters, and also
2022 * ensures that we set the appropriate advertisement for Serdes links.
2024 * Restart autonegotiation if using 802.3z to ensure that the link
2025 * parameters are properly negotiated. This is necessary for DSA
2026 * switches using 802.3z negotiation to ensure they see our modes.
2028 phylink_mac_initial_config(pl, true);
2030 pl->pcs_state = PCS_STATE_STARTED;
2032 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_STOPPED);
2034 if (pl->cfg_link_an_mode == MLO_AN_FIXED && pl->link_gpio) {
2035 int irq = gpiod_to_irq(pl->link_gpio);
2038 if (!request_irq(irq, phylink_link_handler,
2039 IRQF_TRIGGER_RISING |
2040 IRQF_TRIGGER_FALLING,
2050 if (pl->cfg_link_an_mode == MLO_AN_FIXED)
2051 poll |= pl->config->poll_fixed_state;
2054 mod_timer(&pl->link_poll, jiffies + HZ);
2056 phy_start(pl->phydev);
2058 sfp_upstream_start(pl->sfp_bus);
2060 EXPORT_SYMBOL_GPL(phylink_start);
2063 * phylink_stop() - stop a phylink instance
2064 * @pl: a pointer to a &struct phylink returned from phylink_create()
2066 * Stop the phylink instance specified by @pl. This should be called from the
2067 * network device driver's &struct net_device_ops ndo_stop() method. The
2068 * network device's carrier state should not be changed prior to calling this
2071 * This will synchronously bring down the link if the link is not already
2072 * down (in other words, it will trigger a mac_link_down() method call.)
2074 void phylink_stop(struct phylink *pl)
2079 sfp_upstream_stop(pl->sfp_bus);
2081 phy_stop(pl->phydev);
2082 del_timer_sync(&pl->link_poll);
2084 free_irq(pl->link_irq, pl);
2088 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED);
2090 pl->pcs_state = PCS_STATE_DOWN;
2092 phylink_pcs_disable(pl->pcs);
2094 EXPORT_SYMBOL_GPL(phylink_stop);
2097 * phylink_suspend() - handle a network device suspend event
2098 * @pl: a pointer to a &struct phylink returned from phylink_create()
2099 * @mac_wol: true if the MAC needs to receive packets for Wake-on-Lan
2101 * Handle a network device suspend event. There are several cases:
2103 * - If Wake-on-Lan is not active, we can bring down the link between
2104 * the MAC and PHY by calling phylink_stop().
2105 * - If Wake-on-Lan is active, and being handled only by the PHY, we
2106 * can also bring down the link between the MAC and PHY.
2107 * - If Wake-on-Lan is active, but being handled by the MAC, the MAC
2108 * still needs to receive packets, so we can not bring the link down.
2110 void phylink_suspend(struct phylink *pl, bool mac_wol)
2114 if (mac_wol && (!pl->netdev || pl->netdev->wol_enabled)) {
2115 /* Wake-on-Lan enabled, MAC handling */
2116 mutex_lock(&pl->state_mutex);
2118 /* Stop the resolver bringing the link up */
2119 __set_bit(PHYLINK_DISABLE_MAC_WOL, &pl->phylink_disable_state);
2121 /* Disable the carrier, to prevent transmit timeouts,
2122 * but one would hope all packets have been sent. This
2123 * also means phylink_resolve() will do nothing.
2126 netif_carrier_off(pl->netdev);
2128 pl->old_link_state = false;
2130 /* We do not call mac_link_down() here as we want the
2131 * link to remain up to receive the WoL packets.
2133 mutex_unlock(&pl->state_mutex);
2138 EXPORT_SYMBOL_GPL(phylink_suspend);
2141 * phylink_resume() - handle a network device resume event
2142 * @pl: a pointer to a &struct phylink returned from phylink_create()
2144 * Undo the effects of phylink_suspend(), returning the link to an
2145 * operational state.
2147 void phylink_resume(struct phylink *pl)
2151 if (test_bit(PHYLINK_DISABLE_MAC_WOL, &pl->phylink_disable_state)) {
2152 /* Wake-on-Lan enabled, MAC handling */
2154 /* Call mac_link_down() so we keep the overall state balanced.
2155 * Do this under the state_mutex lock for consistency. This
2156 * will cause a "Link Down" message to be printed during
2157 * resume, which is harmless - the true link state will be
2158 * printed when we run a resolve.
2160 mutex_lock(&pl->state_mutex);
2161 phylink_link_down(pl);
2162 mutex_unlock(&pl->state_mutex);
2164 /* Re-apply the link parameters so that all the settings get
2165 * restored to the MAC.
2167 phylink_mac_initial_config(pl, true);
2169 /* Re-enable and re-resolve the link parameters */
2170 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_MAC_WOL);
2175 EXPORT_SYMBOL_GPL(phylink_resume);
2178 * phylink_ethtool_get_wol() - get the wake on lan parameters for the PHY
2179 * @pl: a pointer to a &struct phylink returned from phylink_create()
2180 * @wol: a pointer to &struct ethtool_wolinfo to hold the read parameters
2182 * Read the wake on lan parameters from the PHY attached to the phylink
2183 * instance specified by @pl. If no PHY is currently attached, report no
2184 * support for wake on lan.
2186 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
2194 phy_ethtool_get_wol(pl->phydev, wol);
2196 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol);
2199 * phylink_ethtool_set_wol() - set wake on lan parameters
2200 * @pl: a pointer to a &struct phylink returned from phylink_create()
2201 * @wol: a pointer to &struct ethtool_wolinfo for the desired parameters
2203 * Set the wake on lan parameters for the PHY attached to the phylink
2204 * instance specified by @pl. If no PHY is attached, returns %EOPNOTSUPP
2207 * Returns zero on success or negative errno code.
2209 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
2211 int ret = -EOPNOTSUPP;
2216 ret = phy_ethtool_set_wol(pl->phydev, wol);
2220 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol);
2222 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b)
2224 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask);
2226 linkmode_zero(mask);
2227 phylink_set_port_modes(mask);
2229 linkmode_and(dst, dst, mask);
2230 linkmode_or(dst, dst, b);
2233 static void phylink_get_ksettings(const struct phylink_link_state *state,
2234 struct ethtool_link_ksettings *kset)
2236 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising);
2237 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising);
2238 if (kset->base.rate_matching == RATE_MATCH_NONE) {
2239 kset->base.speed = state->speed;
2240 kset->base.duplex = state->duplex;
2242 kset->base.autoneg = linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2243 state->advertising) ?
2244 AUTONEG_ENABLE : AUTONEG_DISABLE;
2248 * phylink_ethtool_ksettings_get() - get the current link settings
2249 * @pl: a pointer to a &struct phylink returned from phylink_create()
2250 * @kset: a pointer to a &struct ethtool_link_ksettings to hold link settings
2252 * Read the current link settings for the phylink instance specified by @pl.
2253 * This will be the link settings read from the MAC, PHY or fixed link
2254 * settings depending on the current negotiation mode.
2256 int phylink_ethtool_ksettings_get(struct phylink *pl,
2257 struct ethtool_link_ksettings *kset)
2259 struct phylink_link_state link_state;
2264 phy_ethtool_ksettings_get(pl->phydev, kset);
2266 kset->base.port = pl->link_port;
2268 linkmode_copy(kset->link_modes.supported, pl->supported);
2270 switch (pl->cur_link_an_mode) {
2272 /* We are using fixed settings. Report these as the
2273 * current link settings - and note that these also
2274 * represent the supported speeds/duplex/pause modes.
2276 phylink_get_fixed_state(pl, &link_state);
2277 phylink_get_ksettings(&link_state, kset);
2281 /* If there is a phy attached, then use the reported
2282 * settings from the phy with no modification.
2287 phylink_mac_pcs_get_state(pl, &link_state);
2289 /* The MAC is reporting the link results from its own PCS
2290 * layer via in-band status. Report these as the current
2293 phylink_get_ksettings(&link_state, kset);
2299 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get);
2302 * phylink_ethtool_ksettings_set() - set the link settings
2303 * @pl: a pointer to a &struct phylink returned from phylink_create()
2304 * @kset: a pointer to a &struct ethtool_link_ksettings for the desired modes
2306 int phylink_ethtool_ksettings_set(struct phylink *pl,
2307 const struct ethtool_link_ksettings *kset)
2309 __ETHTOOL_DECLARE_LINK_MODE_MASK(support);
2310 struct phylink_link_state config;
2311 const struct phy_setting *s;
2316 struct ethtool_link_ksettings phy_kset = *kset;
2318 linkmode_and(phy_kset.link_modes.advertising,
2319 phy_kset.link_modes.advertising,
2322 /* We can rely on phylib for this update; we also do not need
2323 * to update the pl->link_config settings:
2324 * - the configuration returned via ksettings_get() will come
2325 * from phylib whenever a PHY is present.
2326 * - link_config.interface will be updated by the PHY calling
2327 * back via phylink_phy_change() and a subsequent resolve.
2328 * - initial link configuration for PHY mode comes from the
2329 * last phy state updated via phylink_phy_change().
2330 * - other configuration changes (e.g. pause modes) are
2331 * performed directly via phylib.
2332 * - if in in-band mode with a PHY, the link configuration
2333 * is passed on the link from the PHY, and all of
2334 * link_config.{speed,duplex,an_enabled,pause} are not used.
2335 * - the only possible use would be link_config.advertising
2336 * pause modes when in 1000base-X mode with a PHY, but in
2337 * the presence of a PHY, this should not be changed as that
2338 * should be determined from the media side advertisement.
2340 return phy_ethtool_ksettings_set(pl->phydev, &phy_kset);
2343 config = pl->link_config;
2344 /* Mask out unsupported advertisements */
2345 linkmode_and(config.advertising, kset->link_modes.advertising,
2348 /* FIXME: should we reject autoneg if phy/mac does not support it? */
2349 switch (kset->base.autoneg) {
2350 case AUTONEG_DISABLE:
2351 /* Autonegotiation disabled, select a suitable speed and
2354 s = phy_lookup_setting(kset->base.speed, kset->base.duplex,
2355 pl->supported, false);
2359 /* If we have a fixed link, refuse to change link parameters.
2360 * If the link parameters match, accept them but do nothing.
2362 if (pl->cur_link_an_mode == MLO_AN_FIXED) {
2363 if (s->speed != pl->link_config.speed ||
2364 s->duplex != pl->link_config.duplex)
2369 config.speed = s->speed;
2370 config.duplex = s->duplex;
2373 case AUTONEG_ENABLE:
2374 /* If we have a fixed link, allow autonegotiation (since that
2375 * is our default case) but do not allow the advertisement to
2376 * be changed. If the advertisement matches, simply return.
2378 if (pl->cur_link_an_mode == MLO_AN_FIXED) {
2379 if (!linkmode_equal(config.advertising,
2380 pl->link_config.advertising))
2385 config.speed = SPEED_UNKNOWN;
2386 config.duplex = DUPLEX_UNKNOWN;
2393 /* We have ruled out the case with a PHY attached, and the
2394 * fixed-link cases. All that is left are in-band links.
2396 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising,
2397 kset->base.autoneg == AUTONEG_ENABLE);
2399 /* If this link is with an SFP, ensure that changes to advertised modes
2400 * also cause the associated interface to be selected such that the
2401 * link can be configured correctly.
2404 config.interface = sfp_select_interface(pl->sfp_bus,
2405 config.advertising);
2406 if (config.interface == PHY_INTERFACE_MODE_NA) {
2408 "selection of interface failed, advertisement %*pb\n",
2409 __ETHTOOL_LINK_MODE_MASK_NBITS,
2410 config.advertising);
2414 /* Revalidate with the selected interface */
2415 linkmode_copy(support, pl->supported);
2416 if (phylink_validate(pl, support, &config)) {
2417 phylink_err(pl, "validation of %s/%s with support %*pb failed\n",
2418 phylink_an_mode_str(pl->cur_link_an_mode),
2419 phy_modes(config.interface),
2420 __ETHTOOL_LINK_MODE_MASK_NBITS, support);
2424 /* Validate without changing the current supported mask. */
2425 linkmode_copy(support, pl->supported);
2426 if (phylink_validate(pl, support, &config))
2430 /* If autonegotiation is enabled, we must have an advertisement */
2431 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
2432 config.advertising) &&
2433 phylink_is_empty_linkmode(config.advertising))
2436 mutex_lock(&pl->state_mutex);
2437 pl->link_config.speed = config.speed;
2438 pl->link_config.duplex = config.duplex;
2440 if (pl->link_config.interface != config.interface) {
2441 /* The interface changed, e.g. 1000base-X <-> 2500base-X */
2442 /* We need to force the link down, then change the interface */
2443 if (pl->old_link_state) {
2444 phylink_link_down(pl);
2445 pl->old_link_state = false;
2447 if (!test_bit(PHYLINK_DISABLE_STOPPED,
2448 &pl->phylink_disable_state))
2449 phylink_major_config(pl, false, &config);
2450 pl->link_config.interface = config.interface;
2451 linkmode_copy(pl->link_config.advertising, config.advertising);
2452 } else if (!linkmode_equal(pl->link_config.advertising,
2453 config.advertising)) {
2454 linkmode_copy(pl->link_config.advertising, config.advertising);
2455 phylink_change_inband_advert(pl);
2457 mutex_unlock(&pl->state_mutex);
2461 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set);
2464 * phylink_ethtool_nway_reset() - restart negotiation
2465 * @pl: a pointer to a &struct phylink returned from phylink_create()
2467 * Restart negotiation for the phylink instance specified by @pl. This will
2468 * cause any attached phy to restart negotiation with the link partner, and
2469 * if the MAC is in a BaseX mode, the MAC will also be requested to restart
2472 * Returns zero on success, or negative error code.
2474 int phylink_ethtool_nway_reset(struct phylink *pl)
2481 ret = phy_restart_aneg(pl->phydev);
2482 phylink_mac_pcs_an_restart(pl);
2486 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset);
2489 * phylink_ethtool_get_pauseparam() - get the current pause parameters
2490 * @pl: a pointer to a &struct phylink returned from phylink_create()
2491 * @pause: a pointer to a &struct ethtool_pauseparam
2493 void phylink_ethtool_get_pauseparam(struct phylink *pl,
2494 struct ethtool_pauseparam *pause)
2498 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN);
2499 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX);
2500 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX);
2502 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam);
2505 * phylink_ethtool_set_pauseparam() - set the current pause parameters
2506 * @pl: a pointer to a &struct phylink returned from phylink_create()
2507 * @pause: a pointer to a &struct ethtool_pauseparam
2509 int phylink_ethtool_set_pauseparam(struct phylink *pl,
2510 struct ethtool_pauseparam *pause)
2512 struct phylink_link_state *config = &pl->link_config;
2513 bool manual_changed;
2518 if (pl->cur_link_an_mode == MLO_AN_FIXED)
2521 if (!phylink_test(pl->supported, Pause) &&
2522 !phylink_test(pl->supported, Asym_Pause))
2525 if (!phylink_test(pl->supported, Asym_Pause) &&
2526 pause->rx_pause != pause->tx_pause)
2531 pause_state |= MLO_PAUSE_AN;
2532 if (pause->rx_pause)
2533 pause_state |= MLO_PAUSE_RX;
2534 if (pause->tx_pause)
2535 pause_state |= MLO_PAUSE_TX;
2537 mutex_lock(&pl->state_mutex);
2539 * See the comments for linkmode_set_pause(), wrt the deficiencies
2540 * with the current implementation. A solution to this issue would
2542 * ethtool Local device
2543 * rx tx Pause AsymDir
2548 * and then use the ethtool rx/tx enablement status to mask the
2549 * rx/tx pause resolution.
2551 linkmode_set_pause(config->advertising, pause->tx_pause,
2554 manual_changed = (config->pause ^ pause_state) & MLO_PAUSE_AN ||
2555 (!(pause_state & MLO_PAUSE_AN) &&
2556 (config->pause ^ pause_state) & MLO_PAUSE_TXRX_MASK);
2558 config->pause = pause_state;
2560 /* Update our in-band advertisement, triggering a renegotiation if
2561 * the advertisement changed.
2564 phylink_change_inband_advert(pl);
2566 mutex_unlock(&pl->state_mutex);
2568 /* If we have a PHY, a change of the pause frame advertisement will
2569 * cause phylib to renegotiate (if AN is enabled) which will in turn
2570 * call our phylink_phy_change() and trigger a resolve. Note that
2571 * we can't hold our state mutex while calling phy_set_asym_pause().
2574 phy_set_asym_pause(pl->phydev, pause->rx_pause,
2577 /* If the manual pause settings changed, make sure we trigger a
2578 * resolve to update their state; we can not guarantee that the
2581 if (manual_changed) {
2582 pl->mac_link_dropped = true;
2583 phylink_run_resolve(pl);
2588 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam);
2591 * phylink_get_eee_err() - read the energy efficient ethernet error
2593 * @pl: a pointer to a &struct phylink returned from phylink_create().
2595 * Read the Energy Efficient Ethernet error counter from the PHY associated
2596 * with the phylink instance specified by @pl.
2598 * Returns positive error counter value, or negative error code.
2600 int phylink_get_eee_err(struct phylink *pl)
2607 ret = phy_get_eee_err(pl->phydev);
2611 EXPORT_SYMBOL_GPL(phylink_get_eee_err);
2614 * phylink_init_eee() - init and check the EEE features
2615 * @pl: a pointer to a &struct phylink returned from phylink_create()
2616 * @clk_stop_enable: allow PHY to stop receive clock
2618 * Must be called either with RTNL held or within mac_link_up()
2620 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable)
2622 int ret = -EOPNOTSUPP;
2625 ret = phy_init_eee(pl->phydev, clk_stop_enable);
2629 EXPORT_SYMBOL_GPL(phylink_init_eee);
2632 * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters
2633 * @pl: a pointer to a &struct phylink returned from phylink_create()
2634 * @eee: a pointer to a &struct ethtool_eee for the read parameters
2636 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee)
2638 int ret = -EOPNOTSUPP;
2643 ret = phy_ethtool_get_eee(pl->phydev, eee);
2647 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee);
2650 * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters
2651 * @pl: a pointer to a &struct phylink returned from phylink_create()
2652 * @eee: a pointer to a &struct ethtool_eee for the desired parameters
2654 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee)
2656 int ret = -EOPNOTSUPP;
2661 ret = phy_ethtool_set_eee(pl->phydev, eee);
2665 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee);
2667 /* This emulates MII registers for a fixed-mode phy operating as per the
2668 * passed in state. "aneg" defines if we report negotiation is possible.
2670 * FIXME: should deal with negotiation state too.
2672 static int phylink_mii_emul_read(unsigned int reg,
2673 struct phylink_link_state *state)
2675 struct fixed_phy_status fs;
2676 unsigned long *lpa = state->lp_advertising;
2679 fs.link = state->link;
2680 fs.speed = state->speed;
2681 fs.duplex = state->duplex;
2682 fs.pause = test_bit(ETHTOOL_LINK_MODE_Pause_BIT, lpa);
2683 fs.asym_pause = test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, lpa);
2685 val = swphy_read_reg(reg, &fs);
2686 if (reg == MII_BMSR) {
2687 if (!state->an_complete)
2688 val &= ~BMSR_ANEGCOMPLETE;
2693 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id,
2696 struct phy_device *phydev = pl->phydev;
2699 if (mdio_phy_id_is_c45(phy_id)) {
2700 prtad = mdio_phy_id_prtad(phy_id);
2701 devad = mdio_phy_id_devad(phy_id);
2702 return mdiobus_c45_read(pl->phydev->mdio.bus, prtad, devad,
2706 if (phydev->is_c45) {
2712 devad = __ffs(phydev->c45_ids.mmds_present);
2716 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN))
2718 devad = MDIO_MMD_AN;
2719 if (reg == MII_ADVERTISE)
2720 reg = MDIO_AN_ADVERTISE;
2728 return mdiobus_c45_read(pl->phydev->mdio.bus, prtad, devad,
2732 return mdiobus_read(pl->phydev->mdio.bus, phy_id, reg);
2735 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id,
2736 unsigned int reg, unsigned int val)
2738 struct phy_device *phydev = pl->phydev;
2741 if (mdio_phy_id_is_c45(phy_id)) {
2742 prtad = mdio_phy_id_prtad(phy_id);
2743 devad = mdio_phy_id_devad(phy_id);
2744 return mdiobus_c45_write(pl->phydev->mdio.bus, prtad, devad,
2748 if (phydev->is_c45) {
2754 devad = __ffs(phydev->c45_ids.mmds_present);
2758 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN))
2760 devad = MDIO_MMD_AN;
2761 if (reg == MII_ADVERTISE)
2762 reg = MDIO_AN_ADVERTISE;
2769 return mdiobus_c45_write(pl->phydev->mdio.bus, phy_id, devad,
2773 return mdiobus_write(phydev->mdio.bus, phy_id, reg, val);
2776 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id,
2779 struct phylink_link_state state;
2782 switch (pl->cur_link_an_mode) {
2785 phylink_get_fixed_state(pl, &state);
2786 val = phylink_mii_emul_read(reg, &state);
2795 phylink_mac_pcs_get_state(pl, &state);
2796 val = phylink_mii_emul_read(reg, &state);
2801 return val & 0xffff;
2804 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id,
2805 unsigned int reg, unsigned int val)
2807 switch (pl->cur_link_an_mode) {
2822 * phylink_mii_ioctl() - generic mii ioctl interface
2823 * @pl: a pointer to a &struct phylink returned from phylink_create()
2824 * @ifr: a pointer to a &struct ifreq for socket ioctls
2825 * @cmd: ioctl cmd to execute
2827 * Perform the specified MII ioctl on the PHY attached to the phylink instance
2828 * specified by @pl. If no PHY is attached, emulate the presence of the PHY.
2830 * Returns: zero on success or negative error code.
2833 * read register from the current PHY.
2835 * read register from the specified PHY.
2837 * set a register on the specified PHY.
2839 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)
2841 struct mii_ioctl_data *mii = if_mii(ifr);
2847 /* PHYs only exist for MLO_AN_PHY and SGMII */
2850 mii->phy_id = pl->phydev->mdio.addr;
2854 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num);
2862 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num,
2867 ret = phy_mii_ioctl(pl->phydev, ifr, cmd);
2877 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num);
2885 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num,
2897 EXPORT_SYMBOL_GPL(phylink_mii_ioctl);
2900 * phylink_speed_down() - set the non-SFP PHY to lowest speed supported by both
2902 * @pl: a pointer to a &struct phylink returned from phylink_create()
2903 * @sync: perform action synchronously
2905 * If we have a PHY that is not part of a SFP module, then set the speed
2906 * as described in the phy_speed_down() function. Please see this function
2907 * for a description of the @sync parameter.
2909 * Returns zero if there is no PHY, otherwise as per phy_speed_down().
2911 int phylink_speed_down(struct phylink *pl, bool sync)
2917 if (!pl->sfp_bus && pl->phydev)
2918 ret = phy_speed_down(pl->phydev, sync);
2922 EXPORT_SYMBOL_GPL(phylink_speed_down);
2925 * phylink_speed_up() - restore the advertised speeds prior to the call to
2926 * phylink_speed_down()
2927 * @pl: a pointer to a &struct phylink returned from phylink_create()
2929 * If we have a PHY that is not part of a SFP module, then restore the
2930 * PHY speeds as per phy_speed_up().
2932 * Returns zero if there is no PHY, otherwise as per phy_speed_up().
2934 int phylink_speed_up(struct phylink *pl)
2940 if (!pl->sfp_bus && pl->phydev)
2941 ret = phy_speed_up(pl->phydev);
2945 EXPORT_SYMBOL_GPL(phylink_speed_up);
2947 static void phylink_sfp_attach(void *upstream, struct sfp_bus *bus)
2949 struct phylink *pl = upstream;
2951 pl->netdev->sfp_bus = bus;
2954 static void phylink_sfp_detach(void *upstream, struct sfp_bus *bus)
2956 struct phylink *pl = upstream;
2958 pl->netdev->sfp_bus = NULL;
2961 static const phy_interface_t phylink_sfp_interface_preference[] = {
2962 PHY_INTERFACE_MODE_25GBASER,
2963 PHY_INTERFACE_MODE_USXGMII,
2964 PHY_INTERFACE_MODE_10GBASER,
2965 PHY_INTERFACE_MODE_5GBASER,
2966 PHY_INTERFACE_MODE_2500BASEX,
2967 PHY_INTERFACE_MODE_SGMII,
2968 PHY_INTERFACE_MODE_1000BASEX,
2969 PHY_INTERFACE_MODE_100BASEX,
2972 static DECLARE_PHY_INTERFACE_MASK(phylink_sfp_interfaces);
2974 static phy_interface_t phylink_choose_sfp_interface(struct phylink *pl,
2975 const unsigned long *intf)
2977 phy_interface_t interface;
2980 interface = PHY_INTERFACE_MODE_NA;
2981 for (i = 0; i < ARRAY_SIZE(phylink_sfp_interface_preference); i++)
2982 if (test_bit(phylink_sfp_interface_preference[i], intf)) {
2983 interface = phylink_sfp_interface_preference[i];
2990 static void phylink_sfp_set_config(struct phylink *pl, u8 mode,
2991 unsigned long *supported,
2992 struct phylink_link_state *state)
2994 bool changed = false;
2996 phylink_dbg(pl, "requesting link mode %s/%s with support %*pb\n",
2997 phylink_an_mode_str(mode), phy_modes(state->interface),
2998 __ETHTOOL_LINK_MODE_MASK_NBITS, supported);
3000 if (!linkmode_equal(pl->supported, supported)) {
3001 linkmode_copy(pl->supported, supported);
3005 if (!linkmode_equal(pl->link_config.advertising, state->advertising)) {
3006 linkmode_copy(pl->link_config.advertising, state->advertising);
3010 if (pl->cur_link_an_mode != mode ||
3011 pl->link_config.interface != state->interface) {
3012 pl->cur_link_an_mode = mode;
3013 pl->link_config.interface = state->interface;
3017 phylink_info(pl, "switched to %s/%s link mode\n",
3018 phylink_an_mode_str(mode),
3019 phy_modes(state->interface));
3022 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED,
3023 &pl->phylink_disable_state))
3024 phylink_mac_initial_config(pl, false);
3027 static int phylink_sfp_config_phy(struct phylink *pl, u8 mode,
3028 struct phy_device *phy)
3030 __ETHTOOL_DECLARE_LINK_MODE_MASK(support1);
3031 __ETHTOOL_DECLARE_LINK_MODE_MASK(support);
3032 struct phylink_link_state config;
3033 phy_interface_t iface;
3036 linkmode_copy(support, phy->supported);
3038 memset(&config, 0, sizeof(config));
3039 linkmode_copy(config.advertising, phy->advertising);
3040 config.interface = PHY_INTERFACE_MODE_NA;
3041 config.speed = SPEED_UNKNOWN;
3042 config.duplex = DUPLEX_UNKNOWN;
3043 config.pause = MLO_PAUSE_AN;
3045 /* Ignore errors if we're expecting a PHY to attach later */
3046 ret = phylink_validate(pl, support, &config);
3048 phylink_err(pl, "validation with support %*pb failed: %pe\n",
3049 __ETHTOOL_LINK_MODE_MASK_NBITS, support,
3054 iface = sfp_select_interface(pl->sfp_bus, config.advertising);
3055 if (iface == PHY_INTERFACE_MODE_NA) {
3057 "selection of interface failed, advertisement %*pb\n",
3058 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising);
3062 config.interface = iface;
3063 linkmode_copy(support1, support);
3064 ret = phylink_validate(pl, support1, &config);
3067 "validation of %s/%s with support %*pb failed: %pe\n",
3068 phylink_an_mode_str(mode),
3069 phy_modes(config.interface),
3070 __ETHTOOL_LINK_MODE_MASK_NBITS, support,
3075 pl->link_port = pl->sfp_port;
3077 phylink_sfp_set_config(pl, mode, support, &config);
3082 static int phylink_sfp_config_optical(struct phylink *pl)
3084 __ETHTOOL_DECLARE_LINK_MODE_MASK(support);
3085 DECLARE_PHY_INTERFACE_MASK(interfaces);
3086 struct phylink_link_state config;
3087 phy_interface_t interface;
3090 phylink_dbg(pl, "optical SFP: interfaces=[mac=%*pbl, sfp=%*pbl]\n",
3091 (int)PHY_INTERFACE_MODE_MAX,
3092 pl->config->supported_interfaces,
3093 (int)PHY_INTERFACE_MODE_MAX,
3094 pl->sfp_interfaces);
3096 /* Find the union of the supported interfaces by the PCS/MAC and
3099 phy_interface_and(interfaces, pl->config->supported_interfaces,
3100 pl->sfp_interfaces);
3101 if (phy_interface_empty(interfaces)) {
3102 phylink_err(pl, "unsupported SFP module: no common interface modes\n");
3106 memset(&config, 0, sizeof(config));
3107 linkmode_copy(support, pl->sfp_support);
3108 linkmode_copy(config.advertising, pl->sfp_support);
3109 config.speed = SPEED_UNKNOWN;
3110 config.duplex = DUPLEX_UNKNOWN;
3111 config.pause = MLO_PAUSE_AN;
3113 /* For all the interfaces that are supported, reduce the sfp_support
3114 * mask to only those link modes that can be supported.
3116 ret = phylink_validate_mask(pl, pl->sfp_support, &config, interfaces);
3118 phylink_err(pl, "unsupported SFP module: validation with support %*pb failed\n",
3119 __ETHTOOL_LINK_MODE_MASK_NBITS, support);
3123 interface = phylink_choose_sfp_interface(pl, interfaces);
3124 if (interface == PHY_INTERFACE_MODE_NA) {
3125 phylink_err(pl, "failed to select SFP interface\n");
3129 phylink_dbg(pl, "optical SFP: chosen %s interface\n",
3130 phy_modes(interface));
3132 config.interface = interface;
3134 /* Ignore errors if we're expecting a PHY to attach later */
3135 ret = phylink_validate(pl, support, &config);
3137 phylink_err(pl, "validation with support %*pb failed: %pe\n",
3138 __ETHTOOL_LINK_MODE_MASK_NBITS, support,
3143 pl->link_port = pl->sfp_port;
3145 phylink_sfp_set_config(pl, MLO_AN_INBAND, pl->sfp_support, &config);
3150 static int phylink_sfp_module_insert(void *upstream,
3151 const struct sfp_eeprom_id *id)
3153 struct phylink *pl = upstream;
3157 linkmode_zero(pl->sfp_support);
3158 phy_interface_zero(pl->sfp_interfaces);
3159 sfp_parse_support(pl->sfp_bus, id, pl->sfp_support, pl->sfp_interfaces);
3160 pl->sfp_port = sfp_parse_port(pl->sfp_bus, id, pl->sfp_support);
3162 /* If this module may have a PHY connecting later, defer until later */
3163 pl->sfp_may_have_phy = sfp_may_have_phy(pl->sfp_bus, id);
3164 if (pl->sfp_may_have_phy)
3167 return phylink_sfp_config_optical(pl);
3170 static int phylink_sfp_module_start(void *upstream)
3172 struct phylink *pl = upstream;
3174 /* If this SFP module has a PHY, start the PHY now. */
3176 phy_start(pl->phydev);
3180 /* If the module may have a PHY but we didn't detect one we
3181 * need to configure the MAC here.
3183 if (!pl->sfp_may_have_phy)
3186 return phylink_sfp_config_optical(pl);
3189 static void phylink_sfp_module_stop(void *upstream)
3191 struct phylink *pl = upstream;
3193 /* If this SFP module has a PHY, stop it. */
3195 phy_stop(pl->phydev);
3198 static void phylink_sfp_link_down(void *upstream)
3200 struct phylink *pl = upstream;
3204 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_LINK);
3207 static void phylink_sfp_link_up(void *upstream)
3209 struct phylink *pl = upstream;
3213 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_LINK);
3216 /* The Broadcom BCM84881 in the Methode DM7052 is unable to provide a SGMII
3217 * or 802.3z control word, so inband will not work.
3219 static bool phylink_phy_no_inband(struct phy_device *phy)
3221 return phy->is_c45 && phy_id_compare(phy->c45_ids.device_ids[1],
3222 0xae025150, 0xfffffff0);
3225 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy)
3227 struct phylink *pl = upstream;
3228 phy_interface_t interface;
3233 * This is the new way of dealing with flow control for PHYs,
3234 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
3235 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
3236 * using our validate call to the MAC, we rely upon the MAC
3237 * clearing the bits from both supported and advertising fields.
3239 phy_support_asym_pause(phy);
3241 if (phylink_phy_no_inband(phy))
3244 mode = MLO_AN_INBAND;
3246 /* Set the PHY's host supported interfaces */
3247 phy_interface_and(phy->host_interfaces, phylink_sfp_interfaces,
3248 pl->config->supported_interfaces);
3250 /* Do the initial configuration */
3251 ret = phylink_sfp_config_phy(pl, mode, phy);
3255 interface = pl->link_config.interface;
3256 ret = phylink_attach_phy(pl, phy, interface);
3260 ret = phylink_bringup_phy(pl, phy, interface);
3267 static void phylink_sfp_disconnect_phy(void *upstream)
3269 phylink_disconnect_phy(upstream);
3272 static const struct sfp_upstream_ops sfp_phylink_ops = {
3273 .attach = phylink_sfp_attach,
3274 .detach = phylink_sfp_detach,
3275 .module_insert = phylink_sfp_module_insert,
3276 .module_start = phylink_sfp_module_start,
3277 .module_stop = phylink_sfp_module_stop,
3278 .link_up = phylink_sfp_link_up,
3279 .link_down = phylink_sfp_link_down,
3280 .connect_phy = phylink_sfp_connect_phy,
3281 .disconnect_phy = phylink_sfp_disconnect_phy,
3284 /* Helpers for MAC drivers */
3289 } phylink_c73_priority_resolution[] = {
3290 { ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, SPEED_100000 },
3291 { ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, SPEED_100000 },
3292 /* 100GBASE-KP4 and 100GBASE-CR10 not supported */
3293 { ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, SPEED_40000 },
3294 { ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, SPEED_40000 },
3295 { ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, SPEED_10000 },
3296 { ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, SPEED_10000 },
3297 /* 5GBASE-KR not supported */
3298 { ETHTOOL_LINK_MODE_2500baseX_Full_BIT, SPEED_2500 },
3299 { ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, SPEED_1000 },
3302 void phylink_resolve_c73(struct phylink_link_state *state)
3306 for (i = 0; i < ARRAY_SIZE(phylink_c73_priority_resolution); i++) {
3307 int bit = phylink_c73_priority_resolution[i].bit;
3308 if (linkmode_test_bit(bit, state->advertising) &&
3309 linkmode_test_bit(bit, state->lp_advertising))
3313 if (i < ARRAY_SIZE(phylink_c73_priority_resolution)) {
3314 state->speed = phylink_c73_priority_resolution[i].speed;
3315 state->duplex = DUPLEX_FULL;
3317 /* negotiation failure */
3318 state->link = false;
3321 phylink_resolve_an_pause(state);
3323 EXPORT_SYMBOL_GPL(phylink_resolve_c73);
3325 static void phylink_decode_c37_word(struct phylink_link_state *state,
3326 uint16_t config_reg, int speed)
3330 if (speed == SPEED_2500)
3331 fd_bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT;
3333 fd_bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT;
3335 mii_lpa_mod_linkmode_x(state->lp_advertising, config_reg, fd_bit);
3337 if (linkmode_test_bit(fd_bit, state->advertising) &&
3338 linkmode_test_bit(fd_bit, state->lp_advertising)) {
3339 state->speed = speed;
3340 state->duplex = DUPLEX_FULL;
3342 /* negotiation failure */
3343 state->link = false;
3346 phylink_resolve_an_pause(state);
3349 static void phylink_decode_sgmii_word(struct phylink_link_state *state,
3350 uint16_t config_reg)
3352 if (!(config_reg & LPA_SGMII_LINK)) {
3353 state->link = false;
3357 switch (config_reg & LPA_SGMII_SPD_MASK) {
3359 state->speed = SPEED_10;
3362 state->speed = SPEED_100;
3364 case LPA_SGMII_1000:
3365 state->speed = SPEED_1000;
3368 state->link = false;
3371 if (config_reg & LPA_SGMII_FULL_DUPLEX)
3372 state->duplex = DUPLEX_FULL;
3374 state->duplex = DUPLEX_HALF;
3378 * phylink_decode_usxgmii_word() - decode the USXGMII word from a MAC PCS
3379 * @state: a pointer to a struct phylink_link_state.
3380 * @lpa: a 16 bit value which stores the USXGMII auto-negotiation word
3382 * Helper for MAC PCS supporting the USXGMII protocol and the auto-negotiation
3383 * code word. Decode the USXGMII code word and populate the corresponding fields
3384 * (speed, duplex) into the phylink_link_state structure.
3386 void phylink_decode_usxgmii_word(struct phylink_link_state *state,
3389 switch (lpa & MDIO_USXGMII_SPD_MASK) {
3390 case MDIO_USXGMII_10:
3391 state->speed = SPEED_10;
3393 case MDIO_USXGMII_100:
3394 state->speed = SPEED_100;
3396 case MDIO_USXGMII_1000:
3397 state->speed = SPEED_1000;
3399 case MDIO_USXGMII_2500:
3400 state->speed = SPEED_2500;
3402 case MDIO_USXGMII_5000:
3403 state->speed = SPEED_5000;
3405 case MDIO_USXGMII_10G:
3406 state->speed = SPEED_10000;
3409 state->link = false;
3413 if (lpa & MDIO_USXGMII_FULL_DUPLEX)
3414 state->duplex = DUPLEX_FULL;
3416 state->duplex = DUPLEX_HALF;
3418 EXPORT_SYMBOL_GPL(phylink_decode_usxgmii_word);
3421 * phylink_decode_usgmii_word() - decode the USGMII word from a MAC PCS
3422 * @state: a pointer to a struct phylink_link_state.
3423 * @lpa: a 16 bit value which stores the USGMII auto-negotiation word
3425 * Helper for MAC PCS supporting the USGMII protocol and the auto-negotiation
3426 * code word. Decode the USGMII code word and populate the corresponding fields
3427 * (speed, duplex) into the phylink_link_state structure. The structure for this
3428 * word is the same as the USXGMII word, except it only supports speeds up to
3431 static void phylink_decode_usgmii_word(struct phylink_link_state *state,
3434 switch (lpa & MDIO_USXGMII_SPD_MASK) {
3435 case MDIO_USXGMII_10:
3436 state->speed = SPEED_10;
3438 case MDIO_USXGMII_100:
3439 state->speed = SPEED_100;
3441 case MDIO_USXGMII_1000:
3442 state->speed = SPEED_1000;
3445 state->link = false;
3449 if (lpa & MDIO_USXGMII_FULL_DUPLEX)
3450 state->duplex = DUPLEX_FULL;
3452 state->duplex = DUPLEX_HALF;
3456 * phylink_mii_c22_pcs_decode_state() - Decode MAC PCS state from MII registers
3457 * @state: a pointer to a &struct phylink_link_state.
3458 * @bmsr: The value of the %MII_BMSR register
3459 * @lpa: The value of the %MII_LPA register
3461 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
3462 * clause 37 negotiation and/or SGMII control.
3464 * Parse the Clause 37 or Cisco SGMII link partner negotiation word into
3465 * the phylink @state structure. This is suitable to be used for implementing
3466 * the mac_pcs_get_state() member of the struct phylink_mac_ops structure if
3467 * accessing @bmsr and @lpa cannot be done with MDIO directly.
3469 void phylink_mii_c22_pcs_decode_state(struct phylink_link_state *state,
3472 state->link = !!(bmsr & BMSR_LSTATUS);
3473 state->an_complete = !!(bmsr & BMSR_ANEGCOMPLETE);
3474 /* If there is no link or autonegotiation is disabled, the LP advertisement
3475 * data is not meaningful, so don't go any further.
3477 if (!state->link || !linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
3478 state->advertising))
3481 switch (state->interface) {
3482 case PHY_INTERFACE_MODE_1000BASEX:
3483 phylink_decode_c37_word(state, lpa, SPEED_1000);
3486 case PHY_INTERFACE_MODE_2500BASEX:
3487 phylink_decode_c37_word(state, lpa, SPEED_2500);
3490 case PHY_INTERFACE_MODE_SGMII:
3491 case PHY_INTERFACE_MODE_QSGMII:
3492 phylink_decode_sgmii_word(state, lpa);
3494 case PHY_INTERFACE_MODE_QUSGMII:
3495 phylink_decode_usgmii_word(state, lpa);
3499 state->link = false;
3503 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_decode_state);
3506 * phylink_mii_c22_pcs_get_state() - read the MAC PCS state
3507 * @pcs: a pointer to a &struct mdio_device.
3508 * @state: a pointer to a &struct phylink_link_state.
3510 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
3511 * clause 37 negotiation and/or SGMII control.
3513 * Read the MAC PCS state from the MII device configured in @config and
3514 * parse the Clause 37 or Cisco SGMII link partner negotiation word into
3515 * the phylink @state structure. This is suitable to be directly plugged
3516 * into the mac_pcs_get_state() member of the struct phylink_mac_ops
3519 void phylink_mii_c22_pcs_get_state(struct mdio_device *pcs,
3520 struct phylink_link_state *state)
3524 bmsr = mdiodev_read(pcs, MII_BMSR);
3525 lpa = mdiodev_read(pcs, MII_LPA);
3526 if (bmsr < 0 || lpa < 0) {
3527 state->link = false;
3531 phylink_mii_c22_pcs_decode_state(state, bmsr, lpa);
3533 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_get_state);
3536 * phylink_mii_c22_pcs_encode_advertisement() - configure the clause 37 PCS
3538 * @interface: the PHY interface mode being configured
3539 * @advertising: the ethtool advertisement mask
3541 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
3542 * clause 37 negotiation and/or SGMII control.
3544 * Encode the clause 37 PCS advertisement as specified by @interface and
3547 * Return: The new value for @adv, or ``-EINVAL`` if it should not be changed.
3549 int phylink_mii_c22_pcs_encode_advertisement(phy_interface_t interface,
3550 const unsigned long *advertising)
3554 switch (interface) {
3555 case PHY_INTERFACE_MODE_1000BASEX:
3556 case PHY_INTERFACE_MODE_2500BASEX:
3557 adv = ADVERTISE_1000XFULL;
3558 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
3560 adv |= ADVERTISE_1000XPAUSE;
3561 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
3563 adv |= ADVERTISE_1000XPSE_ASYM;
3565 case PHY_INTERFACE_MODE_SGMII:
3566 case PHY_INTERFACE_MODE_QSGMII:
3569 /* Nothing to do for other modes */
3573 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_encode_advertisement);
3576 * phylink_mii_c22_pcs_config() - configure clause 22 PCS
3577 * @pcs: a pointer to a &struct mdio_device.
3578 * @interface: the PHY interface mode being configured
3579 * @advertising: the ethtool advertisement mask
3580 * @neg_mode: PCS negotiation mode
3582 * Configure a Clause 22 PCS PHY with the appropriate negotiation
3583 * parameters for the @mode, @interface and @advertising parameters.
3584 * Returns negative error number on failure, zero if the advertisement
3585 * has not changed, or positive if there is a change.
3587 int phylink_mii_c22_pcs_config(struct mdio_device *pcs,
3588 phy_interface_t interface,
3589 const unsigned long *advertising,
3590 unsigned int neg_mode)
3596 adv = phylink_mii_c22_pcs_encode_advertisement(interface, advertising);
3598 ret = mdiobus_modify_changed(pcs->bus, pcs->addr,
3599 MII_ADVERTISE, 0xffff, adv);
3605 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED)
3606 bmcr = BMCR_ANENABLE;
3610 /* Configure the inband state. Ensure ISOLATE bit is disabled */
3611 ret = mdiodev_modify(pcs, MII_BMCR, BMCR_ANENABLE | BMCR_ISOLATE, bmcr);
3617 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_config);
3620 * phylink_mii_c22_pcs_an_restart() - restart 802.3z autonegotiation
3621 * @pcs: a pointer to a &struct mdio_device.
3623 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
3624 * clause 37 negotiation.
3626 * Restart the clause 37 negotiation with the link partner. This is
3627 * suitable to be directly plugged into the mac_pcs_get_state() member
3628 * of the struct phylink_mac_ops structure.
3630 void phylink_mii_c22_pcs_an_restart(struct mdio_device *pcs)
3632 int val = mdiodev_read(pcs, MII_BMCR);
3635 val |= BMCR_ANRESTART;
3637 mdiodev_write(pcs, MII_BMCR, val);
3640 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_an_restart);
3642 void phylink_mii_c45_pcs_get_state(struct mdio_device *pcs,
3643 struct phylink_link_state *state)
3645 struct mii_bus *bus = pcs->bus;
3646 int addr = pcs->addr;
3649 stat = mdiobus_c45_read(bus, addr, MDIO_MMD_PCS, MDIO_STAT1);
3651 state->link = false;
3655 state->link = !!(stat & MDIO_STAT1_LSTATUS);
3659 switch (state->interface) {
3660 case PHY_INTERFACE_MODE_10GBASER:
3661 state->speed = SPEED_10000;
3662 state->duplex = DUPLEX_FULL;
3669 EXPORT_SYMBOL_GPL(phylink_mii_c45_pcs_get_state);
3671 static int __init phylink_init(void)
3673 for (int i = 0; i < ARRAY_SIZE(phylink_sfp_interface_preference); ++i)
3674 __set_bit(phylink_sfp_interface_preference[i],
3675 phylink_sfp_interfaces);
3680 module_init(phylink_init);
3682 MODULE_LICENSE("GPL v2");