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/ethtool.h>
9 #include <linux/export.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/netdevice.h>
13 #include <linux/of_mdio.h>
14 #include <linux/phy.h>
15 #include <linux/phy_fixed.h>
16 #include <linux/phylink.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/spinlock.h>
19 #include <linux/timer.h>
20 #include <linux/workqueue.h>
25 #define SUPPORTED_INTERFACES \
26 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \
27 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane)
28 #define ADVERTISED_INTERFACES \
29 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \
30 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane)
33 PHYLINK_DISABLE_STOPPED
,
38 * struct phylink - internal data type for phylink
42 struct net_device
*netdev
;
43 const struct phylink_mac_ops
*ops
;
44 struct phylink_config
*config
;
46 unsigned int old_link_state
:1;
48 unsigned long phylink_disable_state
; /* bitmask of disables */
49 struct phy_device
*phydev
;
50 phy_interface_t link_interface
; /* PHY_INTERFACE_xxx */
51 u8 cfg_link_an_mode
; /* MLO_AN_xxx */
53 u8 link_port
; /* The current non-phy ethtool port */
54 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported
);
56 /* The link configuration settings */
57 struct phylink_link_state link_config
;
59 /* The current settings */
60 phy_interface_t cur_interface
;
62 struct gpio_desc
*link_gpio
;
63 unsigned int link_irq
;
64 struct timer_list link_poll
;
65 void (*get_fixed_state
)(struct net_device
*dev
,
66 struct phylink_link_state
*s
);
68 struct mutex state_mutex
;
69 struct phylink_link_state phy_state
;
70 struct work_struct resolve
;
72 bool mac_link_dropped
;
74 struct sfp_bus
*sfp_bus
;
75 bool sfp_may_have_phy
;
76 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support
);
80 #define phylink_printk(level, pl, fmt, ...) \
82 if ((pl)->config->type == PHYLINK_NETDEV) \
83 netdev_printk(level, (pl)->netdev, fmt, ##__VA_ARGS__); \
84 else if ((pl)->config->type == PHYLINK_DEV) \
85 dev_printk(level, (pl)->dev, fmt, ##__VA_ARGS__); \
88 #define phylink_err(pl, fmt, ...) \
89 phylink_printk(KERN_ERR, pl, fmt, ##__VA_ARGS__)
90 #define phylink_warn(pl, fmt, ...) \
91 phylink_printk(KERN_WARNING, pl, fmt, ##__VA_ARGS__)
92 #define phylink_info(pl, fmt, ...) \
93 phylink_printk(KERN_INFO, pl, fmt, ##__VA_ARGS__)
94 #if defined(CONFIG_DYNAMIC_DEBUG)
95 #define phylink_dbg(pl, fmt, ...) \
97 if ((pl)->config->type == PHYLINK_NETDEV) \
98 netdev_dbg((pl)->netdev, fmt, ##__VA_ARGS__); \
99 else if ((pl)->config->type == PHYLINK_DEV) \
100 dev_dbg((pl)->dev, fmt, ##__VA_ARGS__); \
103 #define phylink_dbg(pl, fmt, ...) \
104 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__)
106 #define phylink_dbg(pl, fmt, ...) \
109 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__); \
114 * phylink_set_port_modes() - set the port type modes in the ethtool mask
115 * @mask: ethtool link mode mask
117 * Sets all the port type modes in the ethtool mask. MAC drivers should
118 * use this in their 'validate' callback.
120 void phylink_set_port_modes(unsigned long *mask
)
122 phylink_set(mask
, TP
);
123 phylink_set(mask
, AUI
);
124 phylink_set(mask
, MII
);
125 phylink_set(mask
, FIBRE
);
126 phylink_set(mask
, BNC
);
127 phylink_set(mask
, Backplane
);
129 EXPORT_SYMBOL_GPL(phylink_set_port_modes
);
131 static int phylink_is_empty_linkmode(const unsigned long *linkmode
)
133 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp
) = { 0, };
135 phylink_set_port_modes(tmp
);
136 phylink_set(tmp
, Autoneg
);
137 phylink_set(tmp
, Pause
);
138 phylink_set(tmp
, Asym_Pause
);
140 return linkmode_subset(linkmode
, tmp
);
143 static const char *phylink_an_mode_str(unsigned int mode
)
145 static const char *modestr
[] = {
146 [MLO_AN_PHY
] = "phy",
147 [MLO_AN_FIXED
] = "fixed",
148 [MLO_AN_INBAND
] = "inband",
151 return mode
< ARRAY_SIZE(modestr
) ? modestr
[mode
] : "unknown";
154 static int phylink_validate(struct phylink
*pl
, unsigned long *supported
,
155 struct phylink_link_state
*state
)
157 pl
->ops
->validate(pl
->config
, supported
, state
);
159 return phylink_is_empty_linkmode(supported
) ? -EINVAL
: 0;
162 static int phylink_parse_fixedlink(struct phylink
*pl
,
163 struct fwnode_handle
*fwnode
)
165 struct fwnode_handle
*fixed_node
;
166 const struct phy_setting
*s
;
167 struct gpio_desc
*desc
;
171 fixed_node
= fwnode_get_named_child_node(fwnode
, "fixed-link");
173 ret
= fwnode_property_read_u32(fixed_node
, "speed", &speed
);
175 pl
->link_config
.speed
= speed
;
176 pl
->link_config
.duplex
= DUPLEX_HALF
;
178 if (fwnode_property_read_bool(fixed_node
, "full-duplex"))
179 pl
->link_config
.duplex
= DUPLEX_FULL
;
181 /* We treat the "pause" and "asym-pause" terminology as
182 * defining the link partner's ability. */
183 if (fwnode_property_read_bool(fixed_node
, "pause"))
184 pl
->link_config
.pause
|= MLO_PAUSE_SYM
;
185 if (fwnode_property_read_bool(fixed_node
, "asym-pause"))
186 pl
->link_config
.pause
|= MLO_PAUSE_ASYM
;
189 desc
= fwnode_gpiod_get_index(fixed_node
, "link", 0,
193 pl
->link_gpio
= desc
;
194 else if (desc
== ERR_PTR(-EPROBE_DEFER
))
197 fwnode_handle_put(fixed_node
);
204 ret
= fwnode_property_read_u32_array(fwnode
, "fixed-link",
206 if (ret
!= ARRAY_SIZE(prop
)) {
207 phylink_err(pl
, "broken fixed-link?\n");
211 ret
= fwnode_property_read_u32_array(fwnode
, "fixed-link",
212 prop
, ARRAY_SIZE(prop
));
214 pl
->link_config
.duplex
= prop
[1] ?
215 DUPLEX_FULL
: DUPLEX_HALF
;
216 pl
->link_config
.speed
= prop
[2];
218 pl
->link_config
.pause
|= MLO_PAUSE_SYM
;
220 pl
->link_config
.pause
|= MLO_PAUSE_ASYM
;
224 if (pl
->link_config
.speed
> SPEED_1000
&&
225 pl
->link_config
.duplex
!= DUPLEX_FULL
)
226 phylink_warn(pl
, "fixed link specifies half duplex for %dMbps link?\n",
227 pl
->link_config
.speed
);
229 bitmap_fill(pl
->supported
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
230 linkmode_copy(pl
->link_config
.advertising
, pl
->supported
);
231 phylink_validate(pl
, pl
->supported
, &pl
->link_config
);
233 s
= phy_lookup_setting(pl
->link_config
.speed
, pl
->link_config
.duplex
,
234 pl
->supported
, true);
235 linkmode_zero(pl
->supported
);
236 phylink_set(pl
->supported
, MII
);
237 phylink_set(pl
->supported
, Pause
);
238 phylink_set(pl
->supported
, Asym_Pause
);
240 __set_bit(s
->bit
, pl
->supported
);
242 phylink_warn(pl
, "fixed link %s duplex %dMbps not recognised\n",
243 pl
->link_config
.duplex
== DUPLEX_FULL
? "full" : "half",
244 pl
->link_config
.speed
);
247 linkmode_and(pl
->link_config
.advertising
, pl
->link_config
.advertising
,
250 pl
->link_config
.link
= 1;
251 pl
->link_config
.an_complete
= 1;
256 static int phylink_parse_mode(struct phylink
*pl
, struct fwnode_handle
*fwnode
)
258 struct fwnode_handle
*dn
;
261 dn
= fwnode_get_named_child_node(fwnode
, "fixed-link");
262 if (dn
|| fwnode_property_present(fwnode
, "fixed-link"))
263 pl
->cfg_link_an_mode
= MLO_AN_FIXED
;
264 fwnode_handle_put(dn
);
266 if (fwnode_property_read_string(fwnode
, "managed", &managed
) == 0 &&
267 strcmp(managed
, "in-band-status") == 0) {
268 if (pl
->cfg_link_an_mode
== MLO_AN_FIXED
) {
270 "can't use both fixed-link and in-band-status\n");
274 linkmode_zero(pl
->supported
);
275 phylink_set(pl
->supported
, MII
);
276 phylink_set(pl
->supported
, Autoneg
);
277 phylink_set(pl
->supported
, Asym_Pause
);
278 phylink_set(pl
->supported
, Pause
);
279 pl
->link_config
.an_enabled
= true;
280 pl
->cfg_link_an_mode
= MLO_AN_INBAND
;
282 switch (pl
->link_config
.interface
) {
283 case PHY_INTERFACE_MODE_SGMII
:
284 case PHY_INTERFACE_MODE_QSGMII
:
285 phylink_set(pl
->supported
, 10baseT_Half
);
286 phylink_set(pl
->supported
, 10baseT_Full
);
287 phylink_set(pl
->supported
, 100baseT_Half
);
288 phylink_set(pl
->supported
, 100baseT_Full
);
289 phylink_set(pl
->supported
, 1000baseT_Half
);
290 phylink_set(pl
->supported
, 1000baseT_Full
);
293 case PHY_INTERFACE_MODE_1000BASEX
:
294 phylink_set(pl
->supported
, 1000baseX_Full
);
297 case PHY_INTERFACE_MODE_2500BASEX
:
298 phylink_set(pl
->supported
, 2500baseX_Full
);
301 case PHY_INTERFACE_MODE_USXGMII
:
302 case PHY_INTERFACE_MODE_10GKR
:
303 case PHY_INTERFACE_MODE_10GBASER
:
304 phylink_set(pl
->supported
, 10baseT_Half
);
305 phylink_set(pl
->supported
, 10baseT_Full
);
306 phylink_set(pl
->supported
, 100baseT_Half
);
307 phylink_set(pl
->supported
, 100baseT_Full
);
308 phylink_set(pl
->supported
, 1000baseT_Half
);
309 phylink_set(pl
->supported
, 1000baseT_Full
);
310 phylink_set(pl
->supported
, 1000baseX_Full
);
311 phylink_set(pl
->supported
, 2500baseT_Full
);
312 phylink_set(pl
->supported
, 2500baseX_Full
);
313 phylink_set(pl
->supported
, 5000baseT_Full
);
314 phylink_set(pl
->supported
, 10000baseT_Full
);
315 phylink_set(pl
->supported
, 10000baseKR_Full
);
316 phylink_set(pl
->supported
, 10000baseCR_Full
);
317 phylink_set(pl
->supported
, 10000baseSR_Full
);
318 phylink_set(pl
->supported
, 10000baseLR_Full
);
319 phylink_set(pl
->supported
, 10000baseLRM_Full
);
320 phylink_set(pl
->supported
, 10000baseER_Full
);
325 "incorrect link mode %s for in-band status\n",
326 phy_modes(pl
->link_config
.interface
));
330 linkmode_copy(pl
->link_config
.advertising
, pl
->supported
);
332 if (phylink_validate(pl
, pl
->supported
, &pl
->link_config
)) {
334 "failed to validate link configuration for in-band status\n");
342 static void phylink_mac_config(struct phylink
*pl
,
343 const struct phylink_link_state
*state
)
346 "%s: mode=%s/%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n",
347 __func__
, phylink_an_mode_str(pl
->cur_link_an_mode
),
348 phy_modes(state
->interface
),
349 phy_speed_to_str(state
->speed
),
350 phy_duplex_to_str(state
->duplex
),
351 __ETHTOOL_LINK_MODE_MASK_NBITS
, state
->advertising
,
352 state
->pause
, state
->link
, state
->an_enabled
);
354 pl
->ops
->mac_config(pl
->config
, pl
->cur_link_an_mode
, state
);
357 static void phylink_mac_config_up(struct phylink
*pl
,
358 const struct phylink_link_state
*state
)
361 phylink_mac_config(pl
, state
);
364 static void phylink_mac_an_restart(struct phylink
*pl
)
366 if (pl
->link_config
.an_enabled
&&
367 phy_interface_mode_is_8023z(pl
->link_config
.interface
))
368 pl
->ops
->mac_an_restart(pl
->config
);
371 static void phylink_mac_pcs_get_state(struct phylink
*pl
,
372 struct phylink_link_state
*state
)
374 linkmode_copy(state
->advertising
, pl
->link_config
.advertising
);
375 linkmode_zero(state
->lp_advertising
);
376 state
->interface
= pl
->link_config
.interface
;
377 state
->an_enabled
= pl
->link_config
.an_enabled
;
378 state
->speed
= SPEED_UNKNOWN
;
379 state
->duplex
= DUPLEX_UNKNOWN
;
380 state
->pause
= MLO_PAUSE_NONE
;
381 state
->an_complete
= 0;
384 pl
->ops
->mac_pcs_get_state(pl
->config
, state
);
387 /* The fixed state is... fixed except for the link state,
388 * which may be determined by a GPIO or a callback.
390 static void phylink_get_fixed_state(struct phylink
*pl
, struct phylink_link_state
*state
)
392 *state
= pl
->link_config
;
393 if (pl
->get_fixed_state
)
394 pl
->get_fixed_state(pl
->netdev
, state
);
395 else if (pl
->link_gpio
)
396 state
->link
= !!gpiod_get_value_cansleep(pl
->link_gpio
);
399 /* Flow control is resolved according to our and the link partners
400 * advertisements using the following drawn from the 802.3 specs:
401 * Local device Link partner
402 * Pause AsymDir Pause AsymDir Result
407 static void phylink_resolve_flow(struct phylink
*pl
,
408 struct phylink_link_state
*state
)
412 if (pl
->link_config
.pause
& MLO_PAUSE_AN
) {
415 if (phylink_test(pl
->link_config
.advertising
, Pause
))
416 pause
|= MLO_PAUSE_SYM
;
417 if (phylink_test(pl
->link_config
.advertising
, Asym_Pause
))
418 pause
|= MLO_PAUSE_ASYM
;
420 pause
&= state
->pause
;
422 if (pause
& MLO_PAUSE_SYM
)
423 new_pause
= MLO_PAUSE_TX
| MLO_PAUSE_RX
;
424 else if (pause
& MLO_PAUSE_ASYM
)
425 new_pause
= state
->pause
& MLO_PAUSE_SYM
?
426 MLO_PAUSE_TX
: MLO_PAUSE_RX
;
428 new_pause
= pl
->link_config
.pause
& MLO_PAUSE_TXRX_MASK
;
431 state
->pause
&= ~MLO_PAUSE_TXRX_MASK
;
432 state
->pause
|= new_pause
;
435 static const char *phylink_pause_to_str(int pause
)
437 switch (pause
& MLO_PAUSE_TXRX_MASK
) {
438 case MLO_PAUSE_TX
| MLO_PAUSE_RX
:
449 static void phylink_mac_link_up(struct phylink
*pl
,
450 struct phylink_link_state link_state
)
452 struct net_device
*ndev
= pl
->netdev
;
454 pl
->cur_interface
= link_state
.interface
;
455 pl
->ops
->mac_link_up(pl
->config
, pl
->cur_link_an_mode
,
456 pl
->cur_interface
, pl
->phydev
);
459 netif_carrier_on(ndev
);
462 "Link is Up - %s/%s - flow control %s\n",
463 phy_speed_to_str(link_state
.speed
),
464 phy_duplex_to_str(link_state
.duplex
),
465 phylink_pause_to_str(link_state
.pause
));
468 static void phylink_mac_link_down(struct phylink
*pl
)
470 struct net_device
*ndev
= pl
->netdev
;
473 netif_carrier_off(ndev
);
474 pl
->ops
->mac_link_down(pl
->config
, pl
->cur_link_an_mode
,
476 phylink_info(pl
, "Link is Down\n");
479 static void phylink_resolve(struct work_struct
*w
)
481 struct phylink
*pl
= container_of(w
, struct phylink
, resolve
);
482 struct phylink_link_state link_state
;
483 struct net_device
*ndev
= pl
->netdev
;
486 mutex_lock(&pl
->state_mutex
);
487 if (pl
->phylink_disable_state
) {
488 pl
->mac_link_dropped
= false;
489 link_state
.link
= false;
490 } else if (pl
->mac_link_dropped
) {
491 link_state
.link
= false;
493 switch (pl
->cur_link_an_mode
) {
495 link_state
= pl
->phy_state
;
496 phylink_resolve_flow(pl
, &link_state
);
497 phylink_mac_config_up(pl
, &link_state
);
501 phylink_get_fixed_state(pl
, &link_state
);
502 phylink_mac_config_up(pl
, &link_state
);
506 phylink_mac_pcs_get_state(pl
, &link_state
);
508 /* If we have a phy, the "up" state is the union of
509 * both the PHY and the MAC */
511 link_state
.link
&= pl
->phy_state
.link
;
513 /* Only update if the PHY link is up */
514 if (pl
->phydev
&& pl
->phy_state
.link
) {
515 link_state
.interface
= pl
->phy_state
.interface
;
517 /* If we have a PHY, we need to update with
518 * the pause mode bits. */
519 link_state
.pause
|= pl
->phy_state
.pause
;
520 phylink_resolve_flow(pl
, &link_state
);
521 phylink_mac_config(pl
, &link_state
);
528 link_changed
= (link_state
.link
!= netif_carrier_ok(ndev
));
530 link_changed
= (link_state
.link
!= pl
->old_link_state
);
533 pl
->old_link_state
= link_state
.link
;
534 if (!link_state
.link
)
535 phylink_mac_link_down(pl
);
537 phylink_mac_link_up(pl
, link_state
);
539 if (!link_state
.link
&& pl
->mac_link_dropped
) {
540 pl
->mac_link_dropped
= false;
541 queue_work(system_power_efficient_wq
, &pl
->resolve
);
543 mutex_unlock(&pl
->state_mutex
);
546 static void phylink_run_resolve(struct phylink
*pl
)
548 if (!pl
->phylink_disable_state
)
549 queue_work(system_power_efficient_wq
, &pl
->resolve
);
552 static void phylink_run_resolve_and_disable(struct phylink
*pl
, int bit
)
554 unsigned long state
= pl
->phylink_disable_state
;
556 set_bit(bit
, &pl
->phylink_disable_state
);
558 queue_work(system_power_efficient_wq
, &pl
->resolve
);
559 flush_work(&pl
->resolve
);
563 static void phylink_fixed_poll(struct timer_list
*t
)
565 struct phylink
*pl
= container_of(t
, struct phylink
, link_poll
);
567 mod_timer(t
, jiffies
+ HZ
);
569 phylink_run_resolve(pl
);
572 static const struct sfp_upstream_ops sfp_phylink_ops
;
574 static int phylink_register_sfp(struct phylink
*pl
,
575 struct fwnode_handle
*fwnode
)
583 bus
= sfp_bus_find_fwnode(fwnode
);
586 phylink_err(pl
, "unable to attach SFP bus: %d\n", ret
);
592 ret
= sfp_bus_add_upstream(bus
, pl
, &sfp_phylink_ops
);
599 * phylink_create() - create a phylink instance
600 * @config: a pointer to the target &struct phylink_config
601 * @fwnode: a pointer to a &struct fwnode_handle describing the network
603 * @iface: the desired link mode defined by &typedef phy_interface_t
604 * @ops: a pointer to a &struct phylink_mac_ops for the MAC.
606 * Create a new phylink instance, and parse the link parameters found in @np.
607 * This will parse in-band modes, fixed-link or SFP configuration.
609 * Note: the rtnl lock must not be held when calling this function.
611 * Returns a pointer to a &struct phylink, or an error-pointer value. Users
612 * must use IS_ERR() to check for errors from this function.
614 struct phylink
*phylink_create(struct phylink_config
*config
,
615 struct fwnode_handle
*fwnode
,
616 phy_interface_t iface
,
617 const struct phylink_mac_ops
*ops
)
622 pl
= kzalloc(sizeof(*pl
), GFP_KERNEL
);
624 return ERR_PTR(-ENOMEM
);
626 mutex_init(&pl
->state_mutex
);
627 INIT_WORK(&pl
->resolve
, phylink_resolve
);
630 if (config
->type
== PHYLINK_NETDEV
) {
631 pl
->netdev
= to_net_dev(config
->dev
);
632 } else if (config
->type
== PHYLINK_DEV
) {
633 pl
->dev
= config
->dev
;
636 return ERR_PTR(-EINVAL
);
639 pl
->phy_state
.interface
= iface
;
640 pl
->link_interface
= iface
;
641 if (iface
== PHY_INTERFACE_MODE_MOCA
)
642 pl
->link_port
= PORT_BNC
;
644 pl
->link_port
= PORT_MII
;
645 pl
->link_config
.interface
= iface
;
646 pl
->link_config
.pause
= MLO_PAUSE_AN
;
647 pl
->link_config
.speed
= SPEED_UNKNOWN
;
648 pl
->link_config
.duplex
= DUPLEX_UNKNOWN
;
649 pl
->link_config
.an_enabled
= true;
651 __set_bit(PHYLINK_DISABLE_STOPPED
, &pl
->phylink_disable_state
);
652 timer_setup(&pl
->link_poll
, phylink_fixed_poll
, 0);
654 bitmap_fill(pl
->supported
, __ETHTOOL_LINK_MODE_MASK_NBITS
);
655 linkmode_copy(pl
->link_config
.advertising
, pl
->supported
);
656 phylink_validate(pl
, pl
->supported
, &pl
->link_config
);
658 ret
= phylink_parse_mode(pl
, fwnode
);
664 if (pl
->cfg_link_an_mode
== MLO_AN_FIXED
) {
665 ret
= phylink_parse_fixedlink(pl
, fwnode
);
672 pl
->cur_link_an_mode
= pl
->cfg_link_an_mode
;
674 ret
= phylink_register_sfp(pl
, fwnode
);
682 EXPORT_SYMBOL_GPL(phylink_create
);
685 * phylink_destroy() - cleanup and destroy the phylink instance
686 * @pl: a pointer to a &struct phylink returned from phylink_create()
688 * Destroy a phylink instance. Any PHY that has been attached must have been
689 * cleaned up via phylink_disconnect_phy() prior to calling this function.
691 * Note: the rtnl lock must not be held when calling this function.
693 void phylink_destroy(struct phylink
*pl
)
695 sfp_bus_del_upstream(pl
->sfp_bus
);
697 gpiod_put(pl
->link_gpio
);
699 cancel_work_sync(&pl
->resolve
);
702 EXPORT_SYMBOL_GPL(phylink_destroy
);
704 static void phylink_phy_change(struct phy_device
*phydev
, bool up
,
707 struct phylink
*pl
= phydev
->phylink
;
709 mutex_lock(&pl
->state_mutex
);
710 pl
->phy_state
.speed
= phydev
->speed
;
711 pl
->phy_state
.duplex
= phydev
->duplex
;
712 pl
->phy_state
.pause
= MLO_PAUSE_NONE
;
714 pl
->phy_state
.pause
|= MLO_PAUSE_SYM
;
715 if (phydev
->asym_pause
)
716 pl
->phy_state
.pause
|= MLO_PAUSE_ASYM
;
717 pl
->phy_state
.interface
= phydev
->interface
;
718 pl
->phy_state
.link
= up
;
719 mutex_unlock(&pl
->state_mutex
);
721 phylink_run_resolve(pl
);
723 phylink_dbg(pl
, "phy link %s %s/%s/%s\n", up
? "up" : "down",
724 phy_modes(phydev
->interface
),
725 phy_speed_to_str(phydev
->speed
),
726 phy_duplex_to_str(phydev
->duplex
));
729 static int phylink_bringup_phy(struct phylink
*pl
, struct phy_device
*phy
,
730 phy_interface_t interface
)
732 struct phylink_link_state config
;
733 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported
);
738 * This is the new way of dealing with flow control for PHYs,
739 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
740 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
741 * using our validate call to the MAC, we rely upon the MAC
742 * clearing the bits from both supported and advertising fields.
744 phy_support_asym_pause(phy
);
746 memset(&config
, 0, sizeof(config
));
747 linkmode_copy(supported
, phy
->supported
);
748 linkmode_copy(config
.advertising
, phy
->advertising
);
750 /* Clause 45 PHYs switch their Serdes lane between several different
751 * modes, normally 10GBASE-R, SGMII. Some use 2500BASE-X for 2.5G
752 * speeds. We really need to know which interface modes the PHY and
753 * MAC supports to properly work out which linkmodes can be supported.
756 interface
!= PHY_INTERFACE_MODE_RXAUI
&&
757 interface
!= PHY_INTERFACE_MODE_XAUI
&&
758 interface
!= PHY_INTERFACE_MODE_USXGMII
)
759 config
.interface
= PHY_INTERFACE_MODE_NA
;
761 config
.interface
= interface
;
763 ret
= phylink_validate(pl
, supported
, &config
);
768 phy
->phy_link_change
= phylink_phy_change
;
770 irq_str
= phy_attached_info_irq(phy
);
772 "PHY [%s] driver [%s] (irq=%s)\n",
773 dev_name(&phy
->mdio
.dev
), phy
->drv
->name
, irq_str
);
776 mutex_lock(&phy
->lock
);
777 mutex_lock(&pl
->state_mutex
);
779 pl
->phy_state
.interface
= interface
;
780 linkmode_copy(pl
->supported
, supported
);
781 linkmode_copy(pl
->link_config
.advertising
, config
.advertising
);
783 /* Restrict the phy advertisement according to the MAC support. */
784 linkmode_copy(phy
->advertising
, config
.advertising
);
785 mutex_unlock(&pl
->state_mutex
);
786 mutex_unlock(&phy
->lock
);
789 "phy: setting supported %*pb advertising %*pb\n",
790 __ETHTOOL_LINK_MODE_MASK_NBITS
, pl
->supported
,
791 __ETHTOOL_LINK_MODE_MASK_NBITS
, phy
->advertising
);
793 if (phy_interrupt_is_valid(phy
))
794 phy_request_interrupt(phy
);
799 static int phylink_attach_phy(struct phylink
*pl
, struct phy_device
*phy
,
800 phy_interface_t interface
)
802 if (WARN_ON(pl
->cfg_link_an_mode
== MLO_AN_FIXED
||
803 (pl
->cfg_link_an_mode
== MLO_AN_INBAND
&&
804 phy_interface_mode_is_8023z(interface
))))
810 return phy_attach_direct(pl
->netdev
, phy
, 0, interface
);
814 * phylink_connect_phy() - connect a PHY to the phylink instance
815 * @pl: a pointer to a &struct phylink returned from phylink_create()
816 * @phy: a pointer to a &struct phy_device.
818 * Connect @phy to the phylink instance specified by @pl by calling
819 * phy_attach_direct(). Configure the @phy according to the MAC driver's
820 * capabilities, start the PHYLIB state machine and enable any interrupts
821 * that the PHY supports.
823 * This updates the phylink's ethtool supported and advertising link mode
826 * Returns 0 on success or a negative errno.
828 int phylink_connect_phy(struct phylink
*pl
, struct phy_device
*phy
)
832 /* Use PHY device/driver interface */
833 if (pl
->link_interface
== PHY_INTERFACE_MODE_NA
) {
834 pl
->link_interface
= phy
->interface
;
835 pl
->link_config
.interface
= pl
->link_interface
;
838 ret
= phylink_attach_phy(pl
, phy
, pl
->link_interface
);
842 ret
= phylink_bringup_phy(pl
, phy
, pl
->link_config
.interface
);
848 EXPORT_SYMBOL_GPL(phylink_connect_phy
);
851 * phylink_of_phy_connect() - connect the PHY specified in the DT mode.
852 * @pl: a pointer to a &struct phylink returned from phylink_create()
853 * @dn: a pointer to a &struct device_node.
854 * @flags: PHY-specific flags to communicate to the PHY device driver
856 * Connect the phy specified in the device node @dn to the phylink instance
857 * specified by @pl. Actions specified in phylink_connect_phy() will be
860 * Returns 0 on success or a negative errno.
862 int phylink_of_phy_connect(struct phylink
*pl
, struct device_node
*dn
,
865 struct device_node
*phy_node
;
866 struct phy_device
*phy_dev
;
869 /* Fixed links and 802.3z are handled without needing a PHY */
870 if (pl
->cfg_link_an_mode
== MLO_AN_FIXED
||
871 (pl
->cfg_link_an_mode
== MLO_AN_INBAND
&&
872 phy_interface_mode_is_8023z(pl
->link_interface
)))
875 phy_node
= of_parse_phandle(dn
, "phy-handle", 0);
877 phy_node
= of_parse_phandle(dn
, "phy", 0);
879 phy_node
= of_parse_phandle(dn
, "phy-device", 0);
882 if (pl
->cfg_link_an_mode
== MLO_AN_PHY
)
887 phy_dev
= of_phy_find_device(phy_node
);
888 /* We're done with the phy_node handle */
889 of_node_put(phy_node
);
893 ret
= phy_attach_direct(pl
->netdev
, phy_dev
, flags
,
898 ret
= phylink_bringup_phy(pl
, phy_dev
, pl
->link_config
.interface
);
904 EXPORT_SYMBOL_GPL(phylink_of_phy_connect
);
907 * phylink_disconnect_phy() - disconnect any PHY attached to the phylink
909 * @pl: a pointer to a &struct phylink returned from phylink_create()
911 * Disconnect any current PHY from the phylink instance described by @pl.
913 void phylink_disconnect_phy(struct phylink
*pl
)
915 struct phy_device
*phy
;
921 mutex_lock(&phy
->lock
);
922 mutex_lock(&pl
->state_mutex
);
924 mutex_unlock(&pl
->state_mutex
);
925 mutex_unlock(&phy
->lock
);
926 flush_work(&pl
->resolve
);
931 EXPORT_SYMBOL_GPL(phylink_disconnect_phy
);
934 * phylink_fixed_state_cb() - allow setting a fixed link callback
935 * @pl: a pointer to a &struct phylink returned from phylink_create()
936 * @cb: callback to execute to determine the fixed link state.
938 * The MAC driver should call this driver when the state of its link
939 * can be determined through e.g: an out of band MMIO register.
941 int phylink_fixed_state_cb(struct phylink
*pl
,
942 void (*cb
)(struct net_device
*dev
,
943 struct phylink_link_state
*state
))
945 /* It does not make sense to let the link be overriden unless we use
948 if (pl
->cfg_link_an_mode
!= MLO_AN_FIXED
)
951 mutex_lock(&pl
->state_mutex
);
952 pl
->get_fixed_state
= cb
;
953 mutex_unlock(&pl
->state_mutex
);
957 EXPORT_SYMBOL_GPL(phylink_fixed_state_cb
);
960 * phylink_mac_change() - notify phylink of a change in MAC state
961 * @pl: a pointer to a &struct phylink returned from phylink_create()
962 * @up: indicates whether the link is currently up.
964 * The MAC driver should call this driver when the state of its link
965 * changes (eg, link failure, new negotiation results, etc.)
967 void phylink_mac_change(struct phylink
*pl
, bool up
)
970 pl
->mac_link_dropped
= true;
971 phylink_run_resolve(pl
);
972 phylink_dbg(pl
, "mac link %s\n", up
? "up" : "down");
974 EXPORT_SYMBOL_GPL(phylink_mac_change
);
976 static irqreturn_t
phylink_link_handler(int irq
, void *data
)
978 struct phylink
*pl
= data
;
980 phylink_run_resolve(pl
);
986 * phylink_start() - start a phylink instance
987 * @pl: a pointer to a &struct phylink returned from phylink_create()
989 * Start the phylink instance specified by @pl, configuring the MAC for the
990 * desired link mode(s) and negotiation style. This should be called from the
991 * network device driver's &struct net_device_ops ndo_open() method.
993 void phylink_start(struct phylink
*pl
)
997 phylink_info(pl
, "configuring for %s/%s link mode\n",
998 phylink_an_mode_str(pl
->cur_link_an_mode
),
999 phy_modes(pl
->link_config
.interface
));
1001 /* Always set the carrier off */
1003 netif_carrier_off(pl
->netdev
);
1005 /* Apply the link configuration to the MAC when starting. This allows
1006 * a fixed-link to start with the correct parameters, and also
1007 * ensures that we set the appropriate advertisement for Serdes links.
1009 phylink_resolve_flow(pl
, &pl
->link_config
);
1010 phylink_mac_config(pl
, &pl
->link_config
);
1012 /* Restart autonegotiation if using 802.3z to ensure that the link
1013 * parameters are properly negotiated. This is necessary for DSA
1014 * switches using 802.3z negotiation to ensure they see our modes.
1016 phylink_mac_an_restart(pl
);
1018 clear_bit(PHYLINK_DISABLE_STOPPED
, &pl
->phylink_disable_state
);
1019 phylink_run_resolve(pl
);
1021 if (pl
->cfg_link_an_mode
== MLO_AN_FIXED
&& pl
->link_gpio
) {
1022 int irq
= gpiod_to_irq(pl
->link_gpio
);
1025 if (!request_irq(irq
, phylink_link_handler
,
1026 IRQF_TRIGGER_RISING
|
1027 IRQF_TRIGGER_FALLING
,
1034 mod_timer(&pl
->link_poll
, jiffies
+ HZ
);
1036 if ((pl
->cfg_link_an_mode
== MLO_AN_FIXED
&& pl
->get_fixed_state
) ||
1037 pl
->config
->pcs_poll
)
1038 mod_timer(&pl
->link_poll
, jiffies
+ HZ
);
1040 phy_start(pl
->phydev
);
1042 sfp_upstream_start(pl
->sfp_bus
);
1044 EXPORT_SYMBOL_GPL(phylink_start
);
1047 * phylink_stop() - stop a phylink instance
1048 * @pl: a pointer to a &struct phylink returned from phylink_create()
1050 * Stop the phylink instance specified by @pl. This should be called from the
1051 * network device driver's &struct net_device_ops ndo_stop() method. The
1052 * network device's carrier state should not be changed prior to calling this
1055 void phylink_stop(struct phylink
*pl
)
1060 sfp_upstream_stop(pl
->sfp_bus
);
1062 phy_stop(pl
->phydev
);
1063 del_timer_sync(&pl
->link_poll
);
1065 free_irq(pl
->link_irq
, pl
);
1069 phylink_run_resolve_and_disable(pl
, PHYLINK_DISABLE_STOPPED
);
1071 EXPORT_SYMBOL_GPL(phylink_stop
);
1074 * phylink_ethtool_get_wol() - get the wake on lan parameters for the PHY
1075 * @pl: a pointer to a &struct phylink returned from phylink_create()
1076 * @wol: a pointer to &struct ethtool_wolinfo to hold the read parameters
1078 * Read the wake on lan parameters from the PHY attached to the phylink
1079 * instance specified by @pl. If no PHY is currently attached, report no
1080 * support for wake on lan.
1082 void phylink_ethtool_get_wol(struct phylink
*pl
, struct ethtool_wolinfo
*wol
)
1090 phy_ethtool_get_wol(pl
->phydev
, wol
);
1092 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol
);
1095 * phylink_ethtool_set_wol() - set wake on lan parameters
1096 * @pl: a pointer to a &struct phylink returned from phylink_create()
1097 * @wol: a pointer to &struct ethtool_wolinfo for the desired parameters
1099 * Set the wake on lan parameters for the PHY attached to the phylink
1100 * instance specified by @pl. If no PHY is attached, returns %EOPNOTSUPP
1103 * Returns zero on success or negative errno code.
1105 int phylink_ethtool_set_wol(struct phylink
*pl
, struct ethtool_wolinfo
*wol
)
1107 int ret
= -EOPNOTSUPP
;
1112 ret
= phy_ethtool_set_wol(pl
->phydev
, wol
);
1116 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol
);
1118 static void phylink_merge_link_mode(unsigned long *dst
, const unsigned long *b
)
1120 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask
);
1122 linkmode_zero(mask
);
1123 phylink_set_port_modes(mask
);
1125 linkmode_and(dst
, dst
, mask
);
1126 linkmode_or(dst
, dst
, b
);
1129 static void phylink_get_ksettings(const struct phylink_link_state
*state
,
1130 struct ethtool_link_ksettings
*kset
)
1132 phylink_merge_link_mode(kset
->link_modes
.advertising
, state
->advertising
);
1133 linkmode_copy(kset
->link_modes
.lp_advertising
, state
->lp_advertising
);
1134 kset
->base
.speed
= state
->speed
;
1135 kset
->base
.duplex
= state
->duplex
;
1136 kset
->base
.autoneg
= state
->an_enabled
? AUTONEG_ENABLE
:
1141 * phylink_ethtool_ksettings_get() - get the current link settings
1142 * @pl: a pointer to a &struct phylink returned from phylink_create()
1143 * @kset: a pointer to a &struct ethtool_link_ksettings to hold link settings
1145 * Read the current link settings for the phylink instance specified by @pl.
1146 * This will be the link settings read from the MAC, PHY or fixed link
1147 * settings depending on the current negotiation mode.
1149 int phylink_ethtool_ksettings_get(struct phylink
*pl
,
1150 struct ethtool_link_ksettings
*kset
)
1152 struct phylink_link_state link_state
;
1157 phy_ethtool_ksettings_get(pl
->phydev
, kset
);
1159 kset
->base
.port
= pl
->link_port
;
1162 linkmode_copy(kset
->link_modes
.supported
, pl
->supported
);
1164 switch (pl
->cur_link_an_mode
) {
1166 /* We are using fixed settings. Report these as the
1167 * current link settings - and note that these also
1168 * represent the supported speeds/duplex/pause modes.
1170 phylink_get_fixed_state(pl
, &link_state
);
1171 phylink_get_ksettings(&link_state
, kset
);
1175 /* If there is a phy attached, then use the reported
1176 * settings from the phy with no modification.
1181 phylink_mac_pcs_get_state(pl
, &link_state
);
1183 /* The MAC is reporting the link results from its own PCS
1184 * layer via in-band status. Report these as the current
1187 phylink_get_ksettings(&link_state
, kset
);
1193 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get
);
1196 * phylink_ethtool_ksettings_set() - set the link settings
1197 * @pl: a pointer to a &struct phylink returned from phylink_create()
1198 * @kset: a pointer to a &struct ethtool_link_ksettings for the desired modes
1200 int phylink_ethtool_ksettings_set(struct phylink
*pl
,
1201 const struct ethtool_link_ksettings
*kset
)
1203 __ETHTOOL_DECLARE_LINK_MODE_MASK(support
);
1204 struct ethtool_link_ksettings our_kset
;
1205 struct phylink_link_state config
;
1210 if (kset
->base
.autoneg
!= AUTONEG_DISABLE
&&
1211 kset
->base
.autoneg
!= AUTONEG_ENABLE
)
1214 linkmode_copy(support
, pl
->supported
);
1215 config
= pl
->link_config
;
1217 /* Mask out unsupported advertisements */
1218 linkmode_and(config
.advertising
, kset
->link_modes
.advertising
,
1221 /* FIXME: should we reject autoneg if phy/mac does not support it? */
1222 if (kset
->base
.autoneg
== AUTONEG_DISABLE
) {
1223 const struct phy_setting
*s
;
1225 /* Autonegotiation disabled, select a suitable speed and
1228 s
= phy_lookup_setting(kset
->base
.speed
, kset
->base
.duplex
,
1233 /* If we have a fixed link (as specified by firmware), refuse
1234 * to change link parameters.
1236 if (pl
->cur_link_an_mode
== MLO_AN_FIXED
&&
1237 (s
->speed
!= pl
->link_config
.speed
||
1238 s
->duplex
!= pl
->link_config
.duplex
))
1241 config
.speed
= s
->speed
;
1242 config
.duplex
= s
->duplex
;
1243 config
.an_enabled
= false;
1245 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
, config
.advertising
);
1247 /* If we have a fixed link, refuse to enable autonegotiation */
1248 if (pl
->cur_link_an_mode
== MLO_AN_FIXED
)
1251 config
.speed
= SPEED_UNKNOWN
;
1252 config
.duplex
= DUPLEX_UNKNOWN
;
1253 config
.an_enabled
= true;
1255 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT
, config
.advertising
);
1259 /* If we have a PHY, we process the kset change via phylib.
1260 * phylib will call our link state function if the PHY
1261 * parameters have changed, which will trigger a resolve
1262 * and update the MAC configuration.
1265 linkmode_copy(our_kset
.link_modes
.advertising
,
1266 config
.advertising
);
1267 our_kset
.base
.speed
= config
.speed
;
1268 our_kset
.base
.duplex
= config
.duplex
;
1270 ret
= phy_ethtool_ksettings_set(pl
->phydev
, &our_kset
);
1274 mutex_lock(&pl
->state_mutex
);
1275 /* Save the new configuration */
1276 linkmode_copy(pl
->link_config
.advertising
,
1277 our_kset
.link_modes
.advertising
);
1278 pl
->link_config
.interface
= config
.interface
;
1279 pl
->link_config
.speed
= our_kset
.base
.speed
;
1280 pl
->link_config
.duplex
= our_kset
.base
.duplex
;
1281 pl
->link_config
.an_enabled
= our_kset
.base
.autoneg
!=
1283 mutex_unlock(&pl
->state_mutex
);
1285 /* For a fixed link, this isn't able to change any parameters,
1286 * which just leaves inband mode.
1288 if (phylink_validate(pl
, support
, &config
))
1291 /* If autonegotiation is enabled, we must have an advertisement */
1292 if (config
.an_enabled
&&
1293 phylink_is_empty_linkmode(config
.advertising
))
1296 mutex_lock(&pl
->state_mutex
);
1297 linkmode_copy(pl
->link_config
.advertising
, config
.advertising
);
1298 pl
->link_config
.interface
= config
.interface
;
1299 pl
->link_config
.speed
= config
.speed
;
1300 pl
->link_config
.duplex
= config
.duplex
;
1301 pl
->link_config
.an_enabled
= kset
->base
.autoneg
!=
1304 if (pl
->cur_link_an_mode
== MLO_AN_INBAND
&&
1305 !test_bit(PHYLINK_DISABLE_STOPPED
,
1306 &pl
->phylink_disable_state
)) {
1307 /* If in 802.3z mode, this updates the advertisement.
1309 * If we are in SGMII mode without a PHY, there is no
1310 * advertisement; the only thing we have is the pause
1311 * modes which can only come from a PHY.
1313 phylink_mac_config(pl
, &pl
->link_config
);
1314 phylink_mac_an_restart(pl
);
1316 mutex_unlock(&pl
->state_mutex
);
1321 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set
);
1324 * phylink_ethtool_nway_reset() - restart negotiation
1325 * @pl: a pointer to a &struct phylink returned from phylink_create()
1327 * Restart negotiation for the phylink instance specified by @pl. This will
1328 * cause any attached phy to restart negotiation with the link partner, and
1329 * if the MAC is in a BaseX mode, the MAC will also be requested to restart
1332 * Returns zero on success, or negative error code.
1334 int phylink_ethtool_nway_reset(struct phylink
*pl
)
1341 ret
= phy_restart_aneg(pl
->phydev
);
1342 phylink_mac_an_restart(pl
);
1346 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset
);
1349 * phylink_ethtool_get_pauseparam() - get the current pause parameters
1350 * @pl: a pointer to a &struct phylink returned from phylink_create()
1351 * @pause: a pointer to a &struct ethtool_pauseparam
1353 void phylink_ethtool_get_pauseparam(struct phylink
*pl
,
1354 struct ethtool_pauseparam
*pause
)
1358 pause
->autoneg
= !!(pl
->link_config
.pause
& MLO_PAUSE_AN
);
1359 pause
->rx_pause
= !!(pl
->link_config
.pause
& MLO_PAUSE_RX
);
1360 pause
->tx_pause
= !!(pl
->link_config
.pause
& MLO_PAUSE_TX
);
1362 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam
);
1365 * phylink_ethtool_set_pauseparam() - set the current pause parameters
1366 * @pl: a pointer to a &struct phylink returned from phylink_create()
1367 * @pause: a pointer to a &struct ethtool_pauseparam
1369 int phylink_ethtool_set_pauseparam(struct phylink
*pl
,
1370 struct ethtool_pauseparam
*pause
)
1372 struct phylink_link_state
*config
= &pl
->link_config
;
1376 if (pl
->cur_link_an_mode
== MLO_AN_FIXED
)
1379 if (!phylink_test(pl
->supported
, Pause
) &&
1380 !phylink_test(pl
->supported
, Asym_Pause
))
1383 if (!phylink_test(pl
->supported
, Asym_Pause
) &&
1384 !pause
->autoneg
&& pause
->rx_pause
!= pause
->tx_pause
)
1387 config
->pause
&= ~(MLO_PAUSE_AN
| MLO_PAUSE_TXRX_MASK
);
1390 config
->pause
|= MLO_PAUSE_AN
;
1391 if (pause
->rx_pause
)
1392 config
->pause
|= MLO_PAUSE_RX
;
1393 if (pause
->tx_pause
)
1394 config
->pause
|= MLO_PAUSE_TX
;
1396 /* If we have a PHY, phylib will call our link state function if the
1397 * mode has changed, which will trigger a resolve and update the MAC
1401 phy_set_asym_pause(pl
->phydev
, pause
->rx_pause
,
1403 } else if (!test_bit(PHYLINK_DISABLE_STOPPED
,
1404 &pl
->phylink_disable_state
)) {
1405 phylink_mac_config(pl
, &pl
->link_config
);
1406 phylink_mac_an_restart(pl
);
1411 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam
);
1414 * phylink_ethtool_get_eee_err() - read the energy efficient ethernet error
1416 * @pl: a pointer to a &struct phylink returned from phylink_create().
1418 * Read the Energy Efficient Ethernet error counter from the PHY associated
1419 * with the phylink instance specified by @pl.
1421 * Returns positive error counter value, or negative error code.
1423 int phylink_get_eee_err(struct phylink
*pl
)
1430 ret
= phy_get_eee_err(pl
->phydev
);
1434 EXPORT_SYMBOL_GPL(phylink_get_eee_err
);
1437 * phylink_init_eee() - init and check the EEE features
1438 * @pl: a pointer to a &struct phylink returned from phylink_create()
1439 * @clk_stop_enable: allow PHY to stop receive clock
1441 * Must be called either with RTNL held or within mac_link_up()
1443 int phylink_init_eee(struct phylink
*pl
, bool clk_stop_enable
)
1445 int ret
= -EOPNOTSUPP
;
1448 ret
= phy_init_eee(pl
->phydev
, clk_stop_enable
);
1452 EXPORT_SYMBOL_GPL(phylink_init_eee
);
1455 * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters
1456 * @pl: a pointer to a &struct phylink returned from phylink_create()
1457 * @eee: a pointer to a &struct ethtool_eee for the read parameters
1459 int phylink_ethtool_get_eee(struct phylink
*pl
, struct ethtool_eee
*eee
)
1461 int ret
= -EOPNOTSUPP
;
1466 ret
= phy_ethtool_get_eee(pl
->phydev
, eee
);
1470 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee
);
1473 * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters
1474 * @pl: a pointer to a &struct phylink returned from phylink_create()
1475 * @eee: a pointer to a &struct ethtool_eee for the desired parameters
1477 int phylink_ethtool_set_eee(struct phylink
*pl
, struct ethtool_eee
*eee
)
1479 int ret
= -EOPNOTSUPP
;
1484 ret
= phy_ethtool_set_eee(pl
->phydev
, eee
);
1488 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee
);
1490 /* This emulates MII registers for a fixed-mode phy operating as per the
1491 * passed in state. "aneg" defines if we report negotiation is possible.
1493 * FIXME: should deal with negotiation state too.
1495 static int phylink_mii_emul_read(unsigned int reg
,
1496 struct phylink_link_state
*state
)
1498 struct fixed_phy_status fs
;
1501 fs
.link
= state
->link
;
1502 fs
.speed
= state
->speed
;
1503 fs
.duplex
= state
->duplex
;
1504 fs
.pause
= state
->pause
& MLO_PAUSE_SYM
;
1505 fs
.asym_pause
= state
->pause
& MLO_PAUSE_ASYM
;
1507 val
= swphy_read_reg(reg
, &fs
);
1508 if (reg
== MII_BMSR
) {
1509 if (!state
->an_complete
)
1510 val
&= ~BMSR_ANEGCOMPLETE
;
1515 static int phylink_phy_read(struct phylink
*pl
, unsigned int phy_id
,
1518 struct phy_device
*phydev
= pl
->phydev
;
1521 if (mdio_phy_id_is_c45(phy_id
)) {
1522 prtad
= mdio_phy_id_prtad(phy_id
);
1523 devad
= mdio_phy_id_devad(phy_id
);
1524 devad
= MII_ADDR_C45
| devad
<< 16 | reg
;
1525 } else if (phydev
->is_c45
) {
1531 devad
= __ffs(phydev
->c45_ids
.devices_in_package
);
1535 if (!(phydev
->c45_ids
.devices_in_package
& MDIO_DEVS_AN
))
1537 devad
= MDIO_MMD_AN
;
1538 if (reg
== MII_ADVERTISE
)
1539 reg
= MDIO_AN_ADVERTISE
;
1547 devad
= MII_ADDR_C45
| devad
<< 16 | reg
;
1552 return mdiobus_read(pl
->phydev
->mdio
.bus
, prtad
, devad
);
1555 static int phylink_phy_write(struct phylink
*pl
, unsigned int phy_id
,
1556 unsigned int reg
, unsigned int val
)
1558 struct phy_device
*phydev
= pl
->phydev
;
1561 if (mdio_phy_id_is_c45(phy_id
)) {
1562 prtad
= mdio_phy_id_prtad(phy_id
);
1563 devad
= mdio_phy_id_devad(phy_id
);
1564 devad
= MII_ADDR_C45
| devad
<< 16 | reg
;
1565 } else if (phydev
->is_c45
) {
1571 devad
= __ffs(phydev
->c45_ids
.devices_in_package
);
1575 if (!(phydev
->c45_ids
.devices_in_package
& MDIO_DEVS_AN
))
1577 devad
= MDIO_MMD_AN
;
1578 if (reg
== MII_ADVERTISE
)
1579 reg
= MDIO_AN_ADVERTISE
;
1587 devad
= MII_ADDR_C45
| devad
<< 16 | reg
;
1593 return mdiobus_write(phydev
->mdio
.bus
, prtad
, devad
, val
);
1596 static int phylink_mii_read(struct phylink
*pl
, unsigned int phy_id
,
1599 struct phylink_link_state state
;
1602 switch (pl
->cur_link_an_mode
) {
1605 phylink_get_fixed_state(pl
, &state
);
1606 val
= phylink_mii_emul_read(reg
, &state
);
1615 phylink_mac_pcs_get_state(pl
, &state
);
1616 val
= phylink_mii_emul_read(reg
, &state
);
1621 return val
& 0xffff;
1624 static int phylink_mii_write(struct phylink
*pl
, unsigned int phy_id
,
1625 unsigned int reg
, unsigned int val
)
1627 switch (pl
->cur_link_an_mode
) {
1642 * phylink_mii_ioctl() - generic mii ioctl interface
1643 * @pl: a pointer to a &struct phylink returned from phylink_create()
1644 * @ifr: a pointer to a &struct ifreq for socket ioctls
1645 * @cmd: ioctl cmd to execute
1647 * Perform the specified MII ioctl on the PHY attached to the phylink instance
1648 * specified by @pl. If no PHY is attached, emulate the presence of the PHY.
1650 * Returns: zero on success or negative error code.
1653 * read register from the current PHY.
1655 * read register from the specified PHY.
1657 * set a register on the specified PHY.
1659 int phylink_mii_ioctl(struct phylink
*pl
, struct ifreq
*ifr
, int cmd
)
1661 struct mii_ioctl_data
*mii
= if_mii(ifr
);
1667 /* PHYs only exist for MLO_AN_PHY and SGMII */
1670 mii
->phy_id
= pl
->phydev
->mdio
.addr
;
1674 ret
= phylink_phy_read(pl
, mii
->phy_id
, mii
->reg_num
);
1682 ret
= phylink_phy_write(pl
, mii
->phy_id
, mii
->reg_num
,
1687 ret
= phy_mii_ioctl(pl
->phydev
, ifr
, cmd
);
1697 ret
= phylink_mii_read(pl
, mii
->phy_id
, mii
->reg_num
);
1705 ret
= phylink_mii_write(pl
, mii
->phy_id
, mii
->reg_num
,
1717 EXPORT_SYMBOL_GPL(phylink_mii_ioctl
);
1719 static void phylink_sfp_attach(void *upstream
, struct sfp_bus
*bus
)
1721 struct phylink
*pl
= upstream
;
1723 pl
->netdev
->sfp_bus
= bus
;
1726 static void phylink_sfp_detach(void *upstream
, struct sfp_bus
*bus
)
1728 struct phylink
*pl
= upstream
;
1730 pl
->netdev
->sfp_bus
= NULL
;
1733 static int phylink_sfp_config(struct phylink
*pl
, u8 mode
,
1734 const unsigned long *supported
,
1735 const unsigned long *advertising
)
1737 __ETHTOOL_DECLARE_LINK_MODE_MASK(support1
);
1738 __ETHTOOL_DECLARE_LINK_MODE_MASK(support
);
1739 struct phylink_link_state config
;
1740 phy_interface_t iface
;
1744 linkmode_copy(support
, supported
);
1746 memset(&config
, 0, sizeof(config
));
1747 linkmode_copy(config
.advertising
, advertising
);
1748 config
.interface
= PHY_INTERFACE_MODE_NA
;
1749 config
.speed
= SPEED_UNKNOWN
;
1750 config
.duplex
= DUPLEX_UNKNOWN
;
1751 config
.pause
= MLO_PAUSE_AN
;
1752 config
.an_enabled
= pl
->link_config
.an_enabled
;
1754 /* Ignore errors if we're expecting a PHY to attach later */
1755 ret
= phylink_validate(pl
, support
, &config
);
1757 phylink_err(pl
, "validation with support %*pb failed: %d\n",
1758 __ETHTOOL_LINK_MODE_MASK_NBITS
, support
, ret
);
1762 iface
= sfp_select_interface(pl
->sfp_bus
, config
.advertising
);
1763 if (iface
== PHY_INTERFACE_MODE_NA
) {
1765 "selection of interface failed, advertisement %*pb\n",
1766 __ETHTOOL_LINK_MODE_MASK_NBITS
, config
.advertising
);
1770 config
.interface
= iface
;
1771 linkmode_copy(support1
, support
);
1772 ret
= phylink_validate(pl
, support1
, &config
);
1774 phylink_err(pl
, "validation of %s/%s with support %*pb failed: %d\n",
1775 phylink_an_mode_str(mode
),
1776 phy_modes(config
.interface
),
1777 __ETHTOOL_LINK_MODE_MASK_NBITS
, support
, ret
);
1781 phylink_dbg(pl
, "requesting link mode %s/%s with support %*pb\n",
1782 phylink_an_mode_str(mode
), phy_modes(config
.interface
),
1783 __ETHTOOL_LINK_MODE_MASK_NBITS
, support
);
1785 if (phy_interface_mode_is_8023z(iface
) && pl
->phydev
)
1788 changed
= !linkmode_equal(pl
->supported
, support
);
1790 linkmode_copy(pl
->supported
, support
);
1791 linkmode_copy(pl
->link_config
.advertising
, config
.advertising
);
1794 if (pl
->cur_link_an_mode
!= mode
||
1795 pl
->link_config
.interface
!= config
.interface
) {
1796 pl
->link_config
.interface
= config
.interface
;
1797 pl
->cur_link_an_mode
= mode
;
1801 phylink_info(pl
, "switched to %s/%s link mode\n",
1802 phylink_an_mode_str(mode
),
1803 phy_modes(config
.interface
));
1806 pl
->link_port
= pl
->sfp_port
;
1808 if (changed
&& !test_bit(PHYLINK_DISABLE_STOPPED
,
1809 &pl
->phylink_disable_state
))
1810 phylink_mac_config(pl
, &pl
->link_config
);
1815 static int phylink_sfp_module_insert(void *upstream
,
1816 const struct sfp_eeprom_id
*id
)
1818 struct phylink
*pl
= upstream
;
1819 unsigned long *support
= pl
->sfp_support
;
1823 linkmode_zero(support
);
1824 sfp_parse_support(pl
->sfp_bus
, id
, support
);
1825 pl
->sfp_port
= sfp_parse_port(pl
->sfp_bus
, id
, support
);
1827 /* If this module may have a PHY connecting later, defer until later */
1828 pl
->sfp_may_have_phy
= sfp_may_have_phy(pl
->sfp_bus
, id
);
1829 if (pl
->sfp_may_have_phy
)
1832 return phylink_sfp_config(pl
, MLO_AN_INBAND
, support
, support
);
1835 static int phylink_sfp_module_start(void *upstream
)
1837 struct phylink
*pl
= upstream
;
1839 /* If this SFP module has a PHY, start the PHY now. */
1841 phy_start(pl
->phydev
);
1845 /* If the module may have a PHY but we didn't detect one we
1846 * need to configure the MAC here.
1848 if (!pl
->sfp_may_have_phy
)
1851 return phylink_sfp_config(pl
, MLO_AN_INBAND
,
1852 pl
->sfp_support
, pl
->sfp_support
);
1855 static void phylink_sfp_module_stop(void *upstream
)
1857 struct phylink
*pl
= upstream
;
1859 /* If this SFP module has a PHY, stop it. */
1861 phy_stop(pl
->phydev
);
1864 static void phylink_sfp_link_down(void *upstream
)
1866 struct phylink
*pl
= upstream
;
1870 phylink_run_resolve_and_disable(pl
, PHYLINK_DISABLE_LINK
);
1873 static void phylink_sfp_link_up(void *upstream
)
1875 struct phylink
*pl
= upstream
;
1879 clear_bit(PHYLINK_DISABLE_LINK
, &pl
->phylink_disable_state
);
1880 phylink_run_resolve(pl
);
1883 /* The Broadcom BCM84881 in the Methode DM7052 is unable to provide a SGMII
1884 * or 802.3z control word, so inband will not work.
1886 static bool phylink_phy_no_inband(struct phy_device
*phy
)
1888 return phy
->is_c45
&&
1889 (phy
->c45_ids
.device_ids
[1] & 0xfffffff0) == 0xae025150;
1892 static int phylink_sfp_connect_phy(void *upstream
, struct phy_device
*phy
)
1894 struct phylink
*pl
= upstream
;
1895 phy_interface_t interface
;
1900 * This is the new way of dealing with flow control for PHYs,
1901 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
1902 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
1903 * using our validate call to the MAC, we rely upon the MAC
1904 * clearing the bits from both supported and advertising fields.
1906 phy_support_asym_pause(phy
);
1908 if (phylink_phy_no_inband(phy
))
1911 mode
= MLO_AN_INBAND
;
1913 /* Do the initial configuration */
1914 ret
= phylink_sfp_config(pl
, mode
, phy
->supported
, phy
->advertising
);
1918 interface
= pl
->link_config
.interface
;
1919 ret
= phylink_attach_phy(pl
, phy
, interface
);
1923 ret
= phylink_bringup_phy(pl
, phy
, interface
);
1930 static void phylink_sfp_disconnect_phy(void *upstream
)
1932 phylink_disconnect_phy(upstream
);
1935 static const struct sfp_upstream_ops sfp_phylink_ops
= {
1936 .attach
= phylink_sfp_attach
,
1937 .detach
= phylink_sfp_detach
,
1938 .module_insert
= phylink_sfp_module_insert
,
1939 .module_start
= phylink_sfp_module_start
,
1940 .module_stop
= phylink_sfp_module_stop
,
1941 .link_up
= phylink_sfp_link_up
,
1942 .link_down
= phylink_sfp_link_down
,
1943 .connect_phy
= phylink_sfp_connect_phy
,
1944 .disconnect_phy
= phylink_sfp_disconnect_phy
,
1947 /* Helpers for MAC drivers */
1950 * phylink_helper_basex_speed() - 1000BaseX/2500BaseX helper
1951 * @state: a pointer to a &struct phylink_link_state
1953 * Inspect the interface mode, advertising mask or forced speed and
1954 * decide whether to run at 2.5Gbit or 1Gbit appropriately, switching
1955 * the interface mode to suit. @state->interface is appropriately
1956 * updated, and the advertising mask has the "other" baseX_Full flag
1959 void phylink_helper_basex_speed(struct phylink_link_state
*state
)
1961 if (phy_interface_mode_is_8023z(state
->interface
)) {
1962 bool want_2500
= state
->an_enabled
?
1963 phylink_test(state
->advertising
, 2500baseX_Full
) :
1964 state
->speed
== SPEED_2500
;
1967 phylink_clear(state
->advertising
, 1000baseX_Full
);
1968 state
->interface
= PHY_INTERFACE_MODE_2500BASEX
;
1970 phylink_clear(state
->advertising
, 2500baseX_Full
);
1971 state
->interface
= PHY_INTERFACE_MODE_1000BASEX
;
1975 EXPORT_SYMBOL_GPL(phylink_helper_basex_speed
);
1977 MODULE_LICENSE("GPL v2");