2 * phylink models the MAC to optional PHY connection, supporting
3 * technologies such as SFP cages where the PHY is hot-pluggable.
5 * Copyright (C) 2015 Russell King
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 #include <linux/ethtool.h>
12 #include <linux/export.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/netdevice.h>
16 #include <linux/of_mdio.h>
17 #include <linux/phy.h>
18 #include <linux/phy_fixed.h>
19 #include <linux/phylink.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/spinlock.h>
22 #include <linux/workqueue.h>
27 #define SUPPORTED_INTERFACES \
28 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \
29 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane)
30 #define ADVERTISED_INTERFACES \
31 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \
32 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane)
35 PHYLINK_DISABLE_STOPPED,
40 struct net_device *netdev;
41 const struct phylink_mac_ops *ops;
43 unsigned long phylink_disable_state; /* bitmask of disables */
44 struct phy_device *phydev;
45 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */
46 u8 link_an_mode; /* MLO_AN_xxx */
47 u8 link_port; /* The current non-phy ethtool port */
48 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
50 /* The link configuration settings */
51 struct phylink_link_state link_config;
52 struct gpio_desc *link_gpio;
54 struct mutex state_mutex;
55 struct phylink_link_state phy_state;
56 struct work_struct resolve;
58 bool mac_link_dropped;
60 struct sfp_bus *sfp_bus;
63 static inline void linkmode_zero(unsigned long *dst)
65 bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
68 static inline void linkmode_copy(unsigned long *dst, const unsigned long *src)
70 bitmap_copy(dst, src, __ETHTOOL_LINK_MODE_MASK_NBITS);
73 static inline void linkmode_and(unsigned long *dst, const unsigned long *a,
74 const unsigned long *b)
76 bitmap_and(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
79 static inline void linkmode_or(unsigned long *dst, const unsigned long *a,
80 const unsigned long *b)
82 bitmap_or(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
85 static inline bool linkmode_empty(const unsigned long *src)
87 return bitmap_empty(src, __ETHTOOL_LINK_MODE_MASK_NBITS);
90 void phylink_set_port_modes(unsigned long *mask)
92 phylink_set(mask, TP);
93 phylink_set(mask, AUI);
94 phylink_set(mask, MII);
95 phylink_set(mask, FIBRE);
96 phylink_set(mask, BNC);
97 phylink_set(mask, Backplane);
99 EXPORT_SYMBOL_GPL(phylink_set_port_modes);
101 static int phylink_is_empty_linkmode(const unsigned long *linkmode)
103 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, };
105 phylink_set_port_modes(tmp);
106 phylink_set(tmp, Autoneg);
107 phylink_set(tmp, Pause);
108 phylink_set(tmp, Asym_Pause);
110 bitmap_andnot(tmp, linkmode, tmp, __ETHTOOL_LINK_MODE_MASK_NBITS);
112 return linkmode_empty(tmp);
115 static const char *phylink_an_mode_str(unsigned int mode)
117 static const char *modestr[] = {
118 [MLO_AN_PHY] = "phy",
119 [MLO_AN_FIXED] = "fixed",
120 [MLO_AN_SGMII] = "SGMII",
121 [MLO_AN_8023Z] = "802.3z",
124 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown";
127 static int phylink_validate(struct phylink *pl, unsigned long *supported,
128 struct phylink_link_state *state)
130 pl->ops->validate(pl->netdev, supported, state);
132 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0;
135 static int phylink_parse_fixedlink(struct phylink *pl, struct device_node *np)
137 struct device_node *fixed_node;
138 const struct phy_setting *s;
139 struct gpio_desc *desc;
140 const __be32 *fixed_prop;
144 fixed_node = of_get_child_by_name(np, "fixed-link");
146 ret = of_property_read_u32(fixed_node, "speed", &speed);
148 pl->link_config.speed = speed;
149 pl->link_config.duplex = DUPLEX_HALF;
151 if (of_property_read_bool(fixed_node, "full-duplex"))
152 pl->link_config.duplex = DUPLEX_FULL;
154 /* We treat the "pause" and "asym-pause" terminology as
155 * defining the link partner's ability. */
156 if (of_property_read_bool(fixed_node, "pause"))
157 pl->link_config.pause |= MLO_PAUSE_SYM;
158 if (of_property_read_bool(fixed_node, "asym-pause"))
159 pl->link_config.pause |= MLO_PAUSE_ASYM;
162 desc = fwnode_get_named_gpiod(&fixed_node->fwnode,
167 pl->link_gpio = desc;
168 else if (desc == ERR_PTR(-EPROBE_DEFER))
171 of_node_put(fixed_node);
176 fixed_prop = of_get_property(np, "fixed-link", &len);
178 netdev_err(pl->netdev, "broken fixed-link?\n");
181 if (len == 5 * sizeof(*fixed_prop)) {
182 pl->link_config.duplex = be32_to_cpu(fixed_prop[1]) ?
183 DUPLEX_FULL : DUPLEX_HALF;
184 pl->link_config.speed = be32_to_cpu(fixed_prop[2]);
185 if (be32_to_cpu(fixed_prop[3]))
186 pl->link_config.pause |= MLO_PAUSE_SYM;
187 if (be32_to_cpu(fixed_prop[4]))
188 pl->link_config.pause |= MLO_PAUSE_ASYM;
192 if (pl->link_config.speed > SPEED_1000 &&
193 pl->link_config.duplex != DUPLEX_FULL)
194 netdev_warn(pl->netdev, "fixed link specifies half duplex for %dMbps link?\n",
195 pl->link_config.speed);
197 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
198 linkmode_copy(pl->link_config.advertising, pl->supported);
199 phylink_validate(pl, pl->supported, &pl->link_config);
201 s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex,
203 __ETHTOOL_LINK_MODE_MASK_NBITS, true);
204 linkmode_zero(pl->supported);
205 phylink_set(pl->supported, MII);
206 phylink_set(pl->supported, Pause);
207 phylink_set(pl->supported, Asym_Pause);
209 __set_bit(s->bit, pl->supported);
211 netdev_warn(pl->netdev, "fixed link %s duplex %dMbps not recognised\n",
212 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half",
213 pl->link_config.speed);
216 linkmode_and(pl->link_config.advertising, pl->link_config.advertising,
219 pl->link_config.link = 1;
220 pl->link_config.an_complete = 1;
225 static int phylink_parse_mode(struct phylink *pl, struct device_node *np)
227 struct device_node *dn;
230 dn = of_get_child_by_name(np, "fixed-link");
231 if (dn || of_find_property(np, "fixed-link", NULL))
232 pl->link_an_mode = MLO_AN_FIXED;
235 if (of_property_read_string(np, "managed", &managed) == 0 &&
236 strcmp(managed, "in-band-status") == 0) {
237 if (pl->link_an_mode == MLO_AN_FIXED) {
238 netdev_err(pl->netdev,
239 "can't use both fixed-link and in-band-status\n");
243 linkmode_zero(pl->supported);
244 phylink_set(pl->supported, MII);
245 phylink_set(pl->supported, Autoneg);
246 phylink_set(pl->supported, Asym_Pause);
247 phylink_set(pl->supported, Pause);
248 pl->link_config.an_enabled = true;
250 switch (pl->link_config.interface) {
251 case PHY_INTERFACE_MODE_SGMII:
252 phylink_set(pl->supported, 10baseT_Half);
253 phylink_set(pl->supported, 10baseT_Full);
254 phylink_set(pl->supported, 100baseT_Half);
255 phylink_set(pl->supported, 100baseT_Full);
256 phylink_set(pl->supported, 1000baseT_Half);
257 phylink_set(pl->supported, 1000baseT_Full);
258 pl->link_an_mode = MLO_AN_SGMII;
261 case PHY_INTERFACE_MODE_1000BASEX:
262 phylink_set(pl->supported, 1000baseX_Full);
263 pl->link_an_mode = MLO_AN_8023Z;
266 case PHY_INTERFACE_MODE_2500BASEX:
267 phylink_set(pl->supported, 2500baseX_Full);
268 pl->link_an_mode = MLO_AN_8023Z;
271 case PHY_INTERFACE_MODE_10GKR:
272 phylink_set(pl->supported, 10baseT_Half);
273 phylink_set(pl->supported, 10baseT_Full);
274 phylink_set(pl->supported, 100baseT_Half);
275 phylink_set(pl->supported, 100baseT_Full);
276 phylink_set(pl->supported, 1000baseT_Half);
277 phylink_set(pl->supported, 1000baseT_Full);
278 phylink_set(pl->supported, 1000baseX_Full);
279 phylink_set(pl->supported, 10000baseKR_Full);
280 phylink_set(pl->supported, 10000baseCR_Full);
281 phylink_set(pl->supported, 10000baseSR_Full);
282 phylink_set(pl->supported, 10000baseLR_Full);
283 phylink_set(pl->supported, 10000baseLRM_Full);
284 phylink_set(pl->supported, 10000baseER_Full);
285 pl->link_an_mode = MLO_AN_SGMII;
289 netdev_err(pl->netdev,
290 "incorrect link mode %s for in-band status\n",
291 phy_modes(pl->link_config.interface));
295 linkmode_copy(pl->link_config.advertising, pl->supported);
297 if (phylink_validate(pl, pl->supported, &pl->link_config)) {
298 netdev_err(pl->netdev,
299 "failed to validate link configuration for in-band status\n");
307 static void phylink_mac_config(struct phylink *pl,
308 const struct phylink_link_state *state)
310 netdev_dbg(pl->netdev,
311 "%s: mode=%s/%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n",
312 __func__, phylink_an_mode_str(pl->link_an_mode),
313 phy_modes(state->interface),
314 phy_speed_to_str(state->speed),
315 phy_duplex_to_str(state->duplex),
316 __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising,
317 state->pause, state->link, state->an_enabled);
319 pl->ops->mac_config(pl->netdev, pl->link_an_mode, state);
322 static void phylink_mac_an_restart(struct phylink *pl)
324 if (pl->link_config.an_enabled &&
325 (pl->link_config.interface == PHY_INTERFACE_MODE_1000BASEX ||
326 pl->link_config.interface == PHY_INTERFACE_MODE_2500BASEX))
327 pl->ops->mac_an_restart(pl->netdev);
330 static int phylink_get_mac_state(struct phylink *pl, struct phylink_link_state *state)
332 struct net_device *ndev = pl->netdev;
334 linkmode_copy(state->advertising, pl->link_config.advertising);
335 linkmode_zero(state->lp_advertising);
336 state->interface = pl->link_config.interface;
337 state->an_enabled = pl->link_config.an_enabled;
338 state->speed = SPEED_UNKNOWN;
339 state->duplex = DUPLEX_UNKNOWN;
340 state->pause = MLO_PAUSE_NONE;
341 state->an_complete = 0;
344 return pl->ops->mac_link_state(ndev, state);
347 /* The fixed state is... fixed except for the link state,
348 * which may be determined by a GPIO.
350 static void phylink_get_fixed_state(struct phylink *pl, struct phylink_link_state *state)
352 *state = pl->link_config;
354 state->link = !!gpiod_get_value(pl->link_gpio);
357 /* Flow control is resolved according to our and the link partners
358 * advertisments using the following drawn from the 802.3 specs:
359 * Local device Link partner
360 * Pause AsymDir Pause AsymDir Result
365 static void phylink_resolve_flow(struct phylink *pl,
366 struct phylink_link_state *state)
370 if (pl->link_config.pause & MLO_PAUSE_AN) {
373 if (phylink_test(pl->link_config.advertising, Pause))
374 pause |= MLO_PAUSE_SYM;
375 if (phylink_test(pl->link_config.advertising, Asym_Pause))
376 pause |= MLO_PAUSE_ASYM;
378 pause &= state->pause;
380 if (pause & MLO_PAUSE_SYM)
381 new_pause = MLO_PAUSE_TX | MLO_PAUSE_RX;
382 else if (pause & MLO_PAUSE_ASYM)
383 new_pause = state->pause & MLO_PAUSE_SYM ?
384 MLO_PAUSE_TX : MLO_PAUSE_RX;
386 new_pause = pl->link_config.pause & MLO_PAUSE_TXRX_MASK;
389 state->pause &= ~MLO_PAUSE_TXRX_MASK;
390 state->pause |= new_pause;
393 static const char *phylink_pause_to_str(int pause)
395 switch (pause & MLO_PAUSE_TXRX_MASK) {
396 case MLO_PAUSE_TX | MLO_PAUSE_RX:
407 static void phylink_resolve(struct work_struct *w)
409 struct phylink *pl = container_of(w, struct phylink, resolve);
410 struct phylink_link_state link_state;
411 struct net_device *ndev = pl->netdev;
413 mutex_lock(&pl->state_mutex);
414 if (pl->phylink_disable_state) {
415 pl->mac_link_dropped = false;
416 link_state.link = false;
417 } else if (pl->mac_link_dropped) {
418 link_state.link = false;
420 switch (pl->link_an_mode) {
422 link_state = pl->phy_state;
423 phylink_resolve_flow(pl, &link_state);
424 phylink_mac_config(pl, &link_state);
428 phylink_get_fixed_state(pl, &link_state);
429 phylink_mac_config(pl, &link_state);
433 phylink_get_mac_state(pl, &link_state);
435 bool changed = false;
437 link_state.link = link_state.link &&
440 if (pl->phy_state.interface !=
441 link_state.interface) {
442 link_state.interface = pl->phy_state.interface;
446 /* Propagate the flow control from the PHY
447 * to the MAC. Also propagate the interface
450 if (pl->phy_state.link || changed) {
451 link_state.pause |= pl->phy_state.pause;
452 phylink_resolve_flow(pl, &link_state);
454 phylink_mac_config(pl, &link_state);
460 phylink_get_mac_state(pl, &link_state);
465 if (link_state.link != netif_carrier_ok(ndev)) {
466 if (!link_state.link) {
467 netif_carrier_off(ndev);
468 pl->ops->mac_link_down(ndev, pl->link_an_mode);
469 netdev_info(ndev, "Link is Down\n");
471 pl->ops->mac_link_up(ndev, pl->link_an_mode,
474 netif_carrier_on(ndev);
477 "Link is Up - %s/%s - flow control %s\n",
478 phy_speed_to_str(link_state.speed),
479 phy_duplex_to_str(link_state.duplex),
480 phylink_pause_to_str(link_state.pause));
483 if (!link_state.link && pl->mac_link_dropped) {
484 pl->mac_link_dropped = false;
485 queue_work(system_power_efficient_wq, &pl->resolve);
487 mutex_unlock(&pl->state_mutex);
490 static void phylink_run_resolve(struct phylink *pl)
492 if (!pl->phylink_disable_state)
493 queue_work(system_power_efficient_wq, &pl->resolve);
496 static void phylink_run_resolve_and_disable(struct phylink *pl, int bit)
498 unsigned long state = pl->phylink_disable_state;
500 set_bit(bit, &pl->phylink_disable_state);
502 queue_work(system_power_efficient_wq, &pl->resolve);
503 flush_work(&pl->resolve);
507 static const struct sfp_upstream_ops sfp_phylink_ops;
509 static int phylink_register_sfp(struct phylink *pl, struct device_node *np)
511 struct device_node *sfp_np;
513 sfp_np = of_parse_phandle(np, "sfp", 0);
517 pl->sfp_bus = sfp_register_upstream(sfp_np, pl->netdev, pl,
525 struct phylink *phylink_create(struct net_device *ndev, struct device_node *np,
526 phy_interface_t iface, const struct phylink_mac_ops *ops)
531 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
533 return ERR_PTR(-ENOMEM);
535 mutex_init(&pl->state_mutex);
536 INIT_WORK(&pl->resolve, phylink_resolve);
538 pl->phy_state.interface = iface;
539 pl->link_interface = iface;
540 pl->link_port = PORT_MII;
541 pl->link_config.interface = iface;
542 pl->link_config.pause = MLO_PAUSE_AN;
543 pl->link_config.speed = SPEED_UNKNOWN;
544 pl->link_config.duplex = DUPLEX_UNKNOWN;
545 pl->link_config.an_enabled = true;
547 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
549 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
550 linkmode_copy(pl->link_config.advertising, pl->supported);
551 phylink_validate(pl, pl->supported, &pl->link_config);
553 ret = phylink_parse_mode(pl, np);
559 if (pl->link_an_mode == MLO_AN_FIXED) {
560 ret = phylink_parse_fixedlink(pl, np);
567 ret = phylink_register_sfp(pl, np);
575 EXPORT_SYMBOL_GPL(phylink_create);
577 void phylink_destroy(struct phylink *pl)
580 sfp_unregister_upstream(pl->sfp_bus);
581 if (!IS_ERR_OR_NULL(pl->link_gpio))
582 gpiod_put(pl->link_gpio);
584 cancel_work_sync(&pl->resolve);
587 EXPORT_SYMBOL_GPL(phylink_destroy);
589 void phylink_phy_change(struct phy_device *phydev, bool up, bool do_carrier)
591 struct phylink *pl = phydev->phylink;
593 mutex_lock(&pl->state_mutex);
594 pl->phy_state.speed = phydev->speed;
595 pl->phy_state.duplex = phydev->duplex;
596 pl->phy_state.pause = MLO_PAUSE_NONE;
598 pl->phy_state.pause |= MLO_PAUSE_SYM;
599 if (phydev->asym_pause)
600 pl->phy_state.pause |= MLO_PAUSE_ASYM;
601 pl->phy_state.interface = phydev->interface;
602 pl->phy_state.link = up;
603 mutex_unlock(&pl->state_mutex);
605 phylink_run_resolve(pl);
607 netdev_dbg(pl->netdev, "phy link %s %s/%s/%s\n", up ? "up" : "down",
608 phy_modes(phydev->interface),
609 phy_speed_to_str(phydev->speed),
610 phy_duplex_to_str(phydev->duplex));
613 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy)
615 struct phylink_link_state config;
616 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
620 memset(&config, 0, sizeof(config));
621 ethtool_convert_legacy_u32_to_link_mode(supported, phy->supported);
622 ethtool_convert_legacy_u32_to_link_mode(config.advertising,
624 config.interface = pl->link_config.interface;
627 * This is the new way of dealing with flow control for PHYs,
628 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
629 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
630 * using our validate call to the MAC, we rely upon the MAC
631 * clearing the bits from both supported and advertising fields.
633 if (phylink_test(supported, Pause))
634 phylink_set(config.advertising, Pause);
635 if (phylink_test(supported, Asym_Pause))
636 phylink_set(config.advertising, Asym_Pause);
638 ret = phylink_validate(pl, supported, &config);
643 phy->phy_link_change = phylink_phy_change;
645 netdev_info(pl->netdev,
646 "PHY [%s] driver [%s]\n", dev_name(&phy->mdio.dev),
649 mutex_lock(&phy->lock);
650 mutex_lock(&pl->state_mutex);
651 pl->netdev->phydev = phy;
653 linkmode_copy(pl->supported, supported);
654 linkmode_copy(pl->link_config.advertising, config.advertising);
656 /* Restrict the phy advertisment according to the MAC support. */
657 ethtool_convert_link_mode_to_legacy_u32(&advertising, config.advertising);
658 phy->advertising = advertising;
659 mutex_unlock(&pl->state_mutex);
660 mutex_unlock(&phy->lock);
662 netdev_dbg(pl->netdev,
663 "phy: setting supported %*pb advertising 0x%08x\n",
664 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported,
667 phy_start_machine(phy);
669 phy_start_interrupts(phy);
674 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy)
678 ret = phy_attach_direct(pl->netdev, phy, 0, pl->link_interface);
682 ret = phylink_bringup_phy(pl, phy);
688 EXPORT_SYMBOL_GPL(phylink_connect_phy);
690 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn)
692 struct device_node *phy_node;
693 struct phy_device *phy_dev;
696 /* Fixed links are handled without needing a PHY */
697 if (pl->link_an_mode == MLO_AN_FIXED)
700 phy_node = of_parse_phandle(dn, "phy-handle", 0);
702 phy_node = of_parse_phandle(dn, "phy", 0);
704 phy_node = of_parse_phandle(dn, "phy-device", 0);
707 if (pl->link_an_mode == MLO_AN_PHY) {
708 netdev_err(pl->netdev, "unable to find PHY node\n");
714 phy_dev = of_phy_attach(pl->netdev, phy_node, 0, pl->link_interface);
715 /* We're done with the phy_node handle */
716 of_node_put(phy_node);
721 ret = phylink_bringup_phy(pl, phy_dev);
727 EXPORT_SYMBOL_GPL(phylink_of_phy_connect);
729 void phylink_disconnect_phy(struct phylink *pl)
731 struct phy_device *phy;
733 WARN_ON(!lockdep_rtnl_is_held());
737 mutex_lock(&phy->lock);
738 mutex_lock(&pl->state_mutex);
739 pl->netdev->phydev = NULL;
741 mutex_unlock(&pl->state_mutex);
742 mutex_unlock(&phy->lock);
743 flush_work(&pl->resolve);
748 EXPORT_SYMBOL_GPL(phylink_disconnect_phy);
750 void phylink_mac_change(struct phylink *pl, bool up)
753 pl->mac_link_dropped = true;
754 phylink_run_resolve(pl);
755 netdev_dbg(pl->netdev, "mac link %s\n", up ? "up" : "down");
757 EXPORT_SYMBOL_GPL(phylink_mac_change);
759 void phylink_start(struct phylink *pl)
761 WARN_ON(!lockdep_rtnl_is_held());
763 netdev_info(pl->netdev, "configuring for %s/%s link mode\n",
764 phylink_an_mode_str(pl->link_an_mode),
765 phy_modes(pl->link_config.interface));
767 /* Always set the carrier off */
768 netif_carrier_off(pl->netdev);
770 /* Apply the link configuration to the MAC when starting. This allows
771 * a fixed-link to start with the correct parameters, and also
772 * ensures that we set the appropriate advertisment for Serdes links.
774 phylink_resolve_flow(pl, &pl->link_config);
775 phylink_mac_config(pl, &pl->link_config);
777 clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
778 phylink_run_resolve(pl);
781 sfp_upstream_start(pl->sfp_bus);
783 phy_start(pl->phydev);
785 EXPORT_SYMBOL_GPL(phylink_start);
787 void phylink_stop(struct phylink *pl)
789 WARN_ON(!lockdep_rtnl_is_held());
792 phy_stop(pl->phydev);
794 sfp_upstream_stop(pl->sfp_bus);
796 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED);
798 EXPORT_SYMBOL_GPL(phylink_stop);
800 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
802 WARN_ON(!lockdep_rtnl_is_held());
808 phy_ethtool_get_wol(pl->phydev, wol);
810 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol);
812 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
814 int ret = -EOPNOTSUPP;
816 WARN_ON(!lockdep_rtnl_is_held());
819 ret = phy_ethtool_set_wol(pl->phydev, wol);
823 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol);
825 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b)
827 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask);
830 phylink_set_port_modes(mask);
832 linkmode_and(dst, dst, mask);
833 linkmode_or(dst, dst, b);
836 static void phylink_get_ksettings(const struct phylink_link_state *state,
837 struct ethtool_link_ksettings *kset)
839 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising);
840 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising);
841 kset->base.speed = state->speed;
842 kset->base.duplex = state->duplex;
843 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE :
847 int phylink_ethtool_ksettings_get(struct phylink *pl,
848 struct ethtool_link_ksettings *kset)
850 struct phylink_link_state link_state;
852 WARN_ON(!lockdep_rtnl_is_held());
855 phy_ethtool_ksettings_get(pl->phydev, kset);
857 kset->base.port = pl->link_port;
860 linkmode_copy(kset->link_modes.supported, pl->supported);
862 switch (pl->link_an_mode) {
864 /* We are using fixed settings. Report these as the
865 * current link settings - and note that these also
866 * represent the supported speeds/duplex/pause modes.
868 phylink_get_fixed_state(pl, &link_state);
869 phylink_get_ksettings(&link_state, kset);
873 /* If there is a phy attached, then use the reported
874 * settings from the phy with no modification.
880 phylink_get_mac_state(pl, &link_state);
882 /* The MAC is reporting the link results from its own PCS
883 * layer via in-band status. Report these as the current
886 phylink_get_ksettings(&link_state, kset);
892 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get);
894 int phylink_ethtool_ksettings_set(struct phylink *pl,
895 const struct ethtool_link_ksettings *kset)
897 struct ethtool_link_ksettings our_kset;
898 struct phylink_link_state config;
901 WARN_ON(!lockdep_rtnl_is_held());
903 if (kset->base.autoneg != AUTONEG_DISABLE &&
904 kset->base.autoneg != AUTONEG_ENABLE)
907 config = pl->link_config;
909 /* Mask out unsupported advertisments */
910 linkmode_and(config.advertising, kset->link_modes.advertising,
913 /* FIXME: should we reject autoneg if phy/mac does not support it? */
914 if (kset->base.autoneg == AUTONEG_DISABLE) {
915 const struct phy_setting *s;
917 /* Autonegotiation disabled, select a suitable speed and
920 s = phy_lookup_setting(kset->base.speed, kset->base.duplex,
922 __ETHTOOL_LINK_MODE_MASK_NBITS, false);
926 /* If we have a fixed link (as specified by firmware), refuse
927 * to change link parameters.
929 if (pl->link_an_mode == MLO_AN_FIXED &&
930 (s->speed != pl->link_config.speed ||
931 s->duplex != pl->link_config.duplex))
934 config.speed = s->speed;
935 config.duplex = s->duplex;
936 config.an_enabled = false;
938 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising);
940 /* If we have a fixed link, refuse to enable autonegotiation */
941 if (pl->link_an_mode == MLO_AN_FIXED)
944 config.speed = SPEED_UNKNOWN;
945 config.duplex = DUPLEX_UNKNOWN;
946 config.an_enabled = true;
948 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising);
951 if (phylink_validate(pl, pl->supported, &config))
954 /* If autonegotiation is enabled, we must have an advertisment */
955 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising))
959 linkmode_copy(our_kset.link_modes.advertising, config.advertising);
960 our_kset.base.speed = config.speed;
961 our_kset.base.duplex = config.duplex;
963 /* If we have a PHY, configure the phy */
965 ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset);
970 mutex_lock(&pl->state_mutex);
971 /* Configure the MAC to match the new settings */
972 linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising);
973 pl->link_config.interface = config.interface;
974 pl->link_config.speed = our_kset.base.speed;
975 pl->link_config.duplex = our_kset.base.duplex;
976 pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE;
978 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) {
979 phylink_mac_config(pl, &pl->link_config);
980 phylink_mac_an_restart(pl);
982 mutex_unlock(&pl->state_mutex);
986 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set);
988 int phylink_ethtool_nway_reset(struct phylink *pl)
992 WARN_ON(!lockdep_rtnl_is_held());
995 ret = phy_restart_aneg(pl->phydev);
996 phylink_mac_an_restart(pl);
1000 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset);
1002 void phylink_ethtool_get_pauseparam(struct phylink *pl,
1003 struct ethtool_pauseparam *pause)
1005 WARN_ON(!lockdep_rtnl_is_held());
1007 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN);
1008 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX);
1009 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX);
1011 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam);
1013 int phylink_ethtool_set_pauseparam(struct phylink *pl,
1014 struct ethtool_pauseparam *pause)
1016 struct phylink_link_state *config = &pl->link_config;
1018 WARN_ON(!lockdep_rtnl_is_held());
1020 if (!phylink_test(pl->supported, Pause) &&
1021 !phylink_test(pl->supported, Asym_Pause))
1024 if (!phylink_test(pl->supported, Asym_Pause) &&
1025 pause->rx_pause != pause->tx_pause)
1028 config->pause &= ~(MLO_PAUSE_AN | MLO_PAUSE_TXRX_MASK);
1031 config->pause |= MLO_PAUSE_AN;
1032 if (pause->rx_pause)
1033 config->pause |= MLO_PAUSE_RX;
1034 if (pause->tx_pause)
1035 config->pause |= MLO_PAUSE_TX;
1037 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) {
1038 switch (pl->link_an_mode) {
1040 /* Silently mark the carrier down, and then trigger a resolve */
1041 netif_carrier_off(pl->netdev);
1042 phylink_run_resolve(pl);
1046 /* Should we allow fixed links to change against the config? */
1047 phylink_resolve_flow(pl, config);
1048 phylink_mac_config(pl, config);
1053 phylink_mac_config(pl, config);
1054 phylink_mac_an_restart(pl);
1061 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam);
1063 int phylink_ethtool_get_module_info(struct phylink *pl,
1064 struct ethtool_modinfo *modinfo)
1066 int ret = -EOPNOTSUPP;
1068 WARN_ON(!lockdep_rtnl_is_held());
1071 ret = sfp_get_module_info(pl->sfp_bus, modinfo);
1075 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_info);
1077 int phylink_ethtool_get_module_eeprom(struct phylink *pl,
1078 struct ethtool_eeprom *ee, u8 *buf)
1080 int ret = -EOPNOTSUPP;
1082 WARN_ON(!lockdep_rtnl_is_held());
1085 ret = sfp_get_module_eeprom(pl->sfp_bus, ee, buf);
1089 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_eeprom);
1091 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable)
1093 int ret = -EPROTONOSUPPORT;
1095 WARN_ON(!lockdep_rtnl_is_held());
1098 ret = phy_init_eee(pl->phydev, clk_stop_enable);
1102 EXPORT_SYMBOL_GPL(phylink_init_eee);
1104 int phylink_get_eee_err(struct phylink *pl)
1108 WARN_ON(!lockdep_rtnl_is_held());
1111 ret = phy_get_eee_err(pl->phydev);
1115 EXPORT_SYMBOL_GPL(phylink_get_eee_err);
1117 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee)
1119 int ret = -EOPNOTSUPP;
1121 WARN_ON(!lockdep_rtnl_is_held());
1124 ret = phy_ethtool_get_eee(pl->phydev, eee);
1128 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee);
1130 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee)
1132 int ret = -EOPNOTSUPP;
1134 WARN_ON(!lockdep_rtnl_is_held());
1137 ret = phy_ethtool_set_eee(pl->phydev, eee);
1141 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee);
1143 /* This emulates MII registers for a fixed-mode phy operating as per the
1144 * passed in state. "aneg" defines if we report negotiation is possible.
1146 * FIXME: should deal with negotiation state too.
1148 static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg,
1149 struct phylink_link_state *state, bool aneg)
1151 struct fixed_phy_status fs;
1154 fs.link = state->link;
1155 fs.speed = state->speed;
1156 fs.duplex = state->duplex;
1157 fs.pause = state->pause & MLO_PAUSE_SYM;
1158 fs.asym_pause = state->pause & MLO_PAUSE_ASYM;
1160 val = swphy_read_reg(reg, &fs);
1161 if (reg == MII_BMSR) {
1162 if (!state->an_complete)
1163 val &= ~BMSR_ANEGCOMPLETE;
1165 val &= ~BMSR_ANEGCAPABLE;
1170 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id,
1173 struct phy_device *phydev = pl->phydev;
1176 if (mdio_phy_id_is_c45(phy_id)) {
1177 prtad = mdio_phy_id_prtad(phy_id);
1178 devad = mdio_phy_id_devad(phy_id);
1179 devad = MII_ADDR_C45 | devad << 16 | reg;
1180 } else if (phydev->is_c45) {
1186 devad = __ffs(phydev->c45_ids.devices_in_package);
1190 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN))
1192 devad = MDIO_MMD_AN;
1193 if (reg == MII_ADVERTISE)
1194 reg = MDIO_AN_ADVERTISE;
1202 devad = MII_ADDR_C45 | devad << 16 | reg;
1207 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad);
1210 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id,
1211 unsigned int reg, unsigned int val)
1213 struct phy_device *phydev = pl->phydev;
1216 if (mdio_phy_id_is_c45(phy_id)) {
1217 prtad = mdio_phy_id_prtad(phy_id);
1218 devad = mdio_phy_id_devad(phy_id);
1219 devad = MII_ADDR_C45 | devad << 16 | reg;
1220 } else if (phydev->is_c45) {
1226 devad = __ffs(phydev->c45_ids.devices_in_package);
1230 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN))
1232 devad = MDIO_MMD_AN;
1233 if (reg == MII_ADVERTISE)
1234 reg = MDIO_AN_ADVERTISE;
1242 devad = MII_ADDR_C45 | devad << 16 | reg;
1248 return mdiobus_write(phydev->mdio.bus, prtad, devad, val);
1251 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id,
1254 struct phylink_link_state state;
1257 switch (pl->link_an_mode) {
1260 phylink_get_fixed_state(pl, &state);
1261 val = phylink_mii_emul_read(pl->netdev, reg, &state,
1270 /* No phy, fall through to 8023z method */
1273 val = phylink_get_mac_state(pl, &state);
1277 val = phylink_mii_emul_read(pl->netdev, reg, &state,
1283 return val & 0xffff;
1286 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id,
1287 unsigned int reg, unsigned int val)
1289 switch (pl->link_an_mode) {
1297 /* No phy, fall through to 8023z method */
1305 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)
1307 struct mii_ioctl_data *mii = if_mii(ifr);
1310 WARN_ON(!lockdep_rtnl_is_held());
1313 /* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */
1316 mii->phy_id = pl->phydev->mdio.addr;
1319 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num);
1327 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num,
1332 ret = phy_mii_ioctl(pl->phydev, ifr, cmd);
1341 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num);
1349 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num,
1361 EXPORT_SYMBOL_GPL(phylink_mii_ioctl);
1365 static int phylink_sfp_module_insert(void *upstream,
1366 const struct sfp_eeprom_id *id)
1368 struct phylink *pl = upstream;
1369 __ETHTOOL_DECLARE_LINK_MODE_MASK(support) = { 0, };
1370 struct phylink_link_state config;
1371 phy_interface_t iface;
1376 sfp_parse_support(pl->sfp_bus, id, support);
1377 port = sfp_parse_port(pl->sfp_bus, id, support);
1378 iface = sfp_parse_interface(pl->sfp_bus, id);
1380 WARN_ON(!lockdep_rtnl_is_held());
1383 case PHY_INTERFACE_MODE_SGMII:
1384 mode = MLO_AN_SGMII;
1386 case PHY_INTERFACE_MODE_1000BASEX:
1387 mode = MLO_AN_8023Z;
1393 memset(&config, 0, sizeof(config));
1394 linkmode_copy(config.advertising, support);
1395 config.interface = iface;
1396 config.speed = SPEED_UNKNOWN;
1397 config.duplex = DUPLEX_UNKNOWN;
1398 config.pause = MLO_PAUSE_AN;
1399 config.an_enabled = pl->link_config.an_enabled;
1401 /* Ignore errors if we're expecting a PHY to attach later */
1402 ret = phylink_validate(pl, support, &config);
1404 netdev_err(pl->netdev, "validation of %s/%s with support %*pb failed: %d\n",
1405 phylink_an_mode_str(mode), phy_modes(config.interface),
1406 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret);
1410 netdev_dbg(pl->netdev, "requesting link mode %s/%s with support %*pb\n",
1411 phylink_an_mode_str(mode), phy_modes(config.interface),
1412 __ETHTOOL_LINK_MODE_MASK_NBITS, support);
1414 if (mode == MLO_AN_8023Z && pl->phydev)
1417 changed = !bitmap_equal(pl->supported, support,
1418 __ETHTOOL_LINK_MODE_MASK_NBITS);
1420 linkmode_copy(pl->supported, support);
1421 linkmode_copy(pl->link_config.advertising, config.advertising);
1424 if (pl->link_an_mode != mode ||
1425 pl->link_config.interface != config.interface) {
1426 pl->link_config.interface = config.interface;
1427 pl->link_an_mode = mode;
1431 netdev_info(pl->netdev, "switched to %s/%s link mode\n",
1432 phylink_an_mode_str(mode),
1433 phy_modes(config.interface));
1436 pl->link_port = port;
1438 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED,
1439 &pl->phylink_disable_state))
1440 phylink_mac_config(pl, &pl->link_config);
1445 static void phylink_sfp_link_down(void *upstream)
1447 struct phylink *pl = upstream;
1449 WARN_ON(!lockdep_rtnl_is_held());
1451 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_LINK);
1454 static void phylink_sfp_link_up(void *upstream)
1456 struct phylink *pl = upstream;
1458 WARN_ON(!lockdep_rtnl_is_held());
1460 clear_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state);
1461 phylink_run_resolve(pl);
1464 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy)
1466 return phylink_connect_phy(upstream, phy);
1469 static void phylink_sfp_disconnect_phy(void *upstream)
1471 phylink_disconnect_phy(upstream);
1474 static const struct sfp_upstream_ops sfp_phylink_ops = {
1475 .module_insert = phylink_sfp_module_insert,
1476 .link_up = phylink_sfp_link_up,
1477 .link_down = phylink_sfp_link_down,
1478 .connect_phy = phylink_sfp_connect_phy,
1479 .disconnect_phy = phylink_sfp_disconnect_phy,
1482 MODULE_LICENSE("GPL");