1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * phylink models the MAC to optional PHY connection, supporting
4 * technologies such as SFP cages where the PHY is hot-pluggable.
5 *
6 * Copyright (C) 2015 Russell King
7 */
8 #include <linux/ethtool.h>
9 #include <linux/export.h>
10 #include <linux/gpio/consumer.h>
11 #include <linux/netdevice.h>
12 #include <linux/of.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>
21
22 #include "sfp.h"
23 #include "swphy.h"
24
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)
31
32 enum {
33 PHYLINK_DISABLE_STOPPED,
34 PHYLINK_DISABLE_LINK,
35 };
36
37 /**
38 * struct phylink - internal data type for phylink
39 */
40 struct phylink {
41 /* private: */
42 struct net_device *netdev;
43 const struct phylink_mac_ops *mac_ops;
44 const struct phylink_pcs_ops *pcs_ops;
45 struct phylink_config *config;
46 struct phylink_pcs *pcs;
47 struct device *dev;
48 unsigned int old_link_state:1;
49
50 unsigned long phylink_disable_state; /* bitmask of disables */
51 struct phy_device *phydev;
52 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */
53 u8 cfg_link_an_mode; /* MLO_AN_xxx */
54 u8 cur_link_an_mode;
55 u8 link_port; /* The current non-phy ethtool port */
56 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
57
58 /* The link configuration settings */
59 struct phylink_link_state link_config;
60
61 /* The current settings */
62 phy_interface_t cur_interface;
63
64 struct gpio_desc *link_gpio;
65 unsigned int link_irq;
66 struct timer_list link_poll;
67 void (*get_fixed_state)(struct net_device *dev,
68 struct phylink_link_state *s);
69
70 struct mutex state_mutex;
71 struct phylink_link_state phy_state;
72 struct work_struct resolve;
73
74 bool mac_link_dropped;
75
76 struct sfp_bus *sfp_bus;
77 bool sfp_may_have_phy;
78 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support);
79 u8 sfp_port;
80 };
81
82 #define phylink_printk(level, pl, fmt, ...) \
83 do { \
84 if ((pl)->config->type == PHYLINK_NETDEV) \
85 netdev_printk(level, (pl)->netdev, fmt, ##__VA_ARGS__); \
86 else if ((pl)->config->type == PHYLINK_DEV) \
87 dev_printk(level, (pl)->dev, fmt, ##__VA_ARGS__); \
88 } while (0)
89
90 #define phylink_err(pl, fmt, ...) \
91 phylink_printk(KERN_ERR, pl, fmt, ##__VA_ARGS__)
92 #define phylink_warn(pl, fmt, ...) \
93 phylink_printk(KERN_WARNING, pl, fmt, ##__VA_ARGS__)
94 #define phylink_info(pl, fmt, ...) \
95 phylink_printk(KERN_INFO, pl, fmt, ##__VA_ARGS__)
96 #if defined(CONFIG_DYNAMIC_DEBUG)
97 #define phylink_dbg(pl, fmt, ...) \
98 do { \
99 if ((pl)->config->type == PHYLINK_NETDEV) \
100 netdev_dbg((pl)->netdev, fmt, ##__VA_ARGS__); \
101 else if ((pl)->config->type == PHYLINK_DEV) \
102 dev_dbg((pl)->dev, fmt, ##__VA_ARGS__); \
103 } while (0)
104 #elif defined(DEBUG)
105 #define phylink_dbg(pl, fmt, ...) \
106 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__)
107 #else
108 #define phylink_dbg(pl, fmt, ...) \
109 ({ \
110 if (0) \
111 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__); \
112 })
113 #endif
114
115 /**
116 * phylink_set_port_modes() - set the port type modes in the ethtool mask
117 * @mask: ethtool link mode mask
118 *
119 * Sets all the port type modes in the ethtool mask. MAC drivers should
120 * use this in their 'validate' callback.
121 */
phylink_set_port_modes(unsigned long * mask)122 void phylink_set_port_modes(unsigned long *mask)
123 {
124 phylink_set(mask, TP);
125 phylink_set(mask, AUI);
126 phylink_set(mask, MII);
127 phylink_set(mask, FIBRE);
128 phylink_set(mask, BNC);
129 phylink_set(mask, Backplane);
130 }
131 EXPORT_SYMBOL_GPL(phylink_set_port_modes);
132
phylink_is_empty_linkmode(const unsigned long * linkmode)133 static int phylink_is_empty_linkmode(const unsigned long *linkmode)
134 {
135 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, };
136
137 phylink_set_port_modes(tmp);
138 phylink_set(tmp, Autoneg);
139 phylink_set(tmp, Pause);
140 phylink_set(tmp, Asym_Pause);
141
142 return linkmode_subset(linkmode, tmp);
143 }
144
phylink_an_mode_str(unsigned int mode)145 static const char *phylink_an_mode_str(unsigned int mode)
146 {
147 static const char *modestr[] = {
148 [MLO_AN_PHY] = "phy",
149 [MLO_AN_FIXED] = "fixed",
150 [MLO_AN_INBAND] = "inband",
151 };
152
153 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown";
154 }
155
phylink_validate(struct phylink * pl,unsigned long * supported,struct phylink_link_state * state)156 static int phylink_validate(struct phylink *pl, unsigned long *supported,
157 struct phylink_link_state *state)
158 {
159 pl->mac_ops->validate(pl->config, supported, state);
160
161 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0;
162 }
163
phylink_parse_fixedlink(struct phylink * pl,struct fwnode_handle * fwnode)164 static int phylink_parse_fixedlink(struct phylink *pl,
165 struct fwnode_handle *fwnode)
166 {
167 struct fwnode_handle *fixed_node;
168 const struct phy_setting *s;
169 struct gpio_desc *desc;
170 u32 speed;
171 int ret;
172
173 fixed_node = fwnode_get_named_child_node(fwnode, "fixed-link");
174 if (fixed_node) {
175 ret = fwnode_property_read_u32(fixed_node, "speed", &speed);
176
177 pl->link_config.speed = speed;
178 pl->link_config.duplex = DUPLEX_HALF;
179
180 if (fwnode_property_read_bool(fixed_node, "full-duplex"))
181 pl->link_config.duplex = DUPLEX_FULL;
182
183 /* We treat the "pause" and "asym-pause" terminology as
184 * defining the link partner's ability. */
185 if (fwnode_property_read_bool(fixed_node, "pause"))
186 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
187 pl->link_config.lp_advertising);
188 if (fwnode_property_read_bool(fixed_node, "asym-pause"))
189 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
190 pl->link_config.lp_advertising);
191
192 if (ret == 0) {
193 desc = fwnode_gpiod_get_index(fixed_node, "link", 0,
194 GPIOD_IN, "?");
195
196 if (!IS_ERR(desc))
197 pl->link_gpio = desc;
198 else if (desc == ERR_PTR(-EPROBE_DEFER))
199 ret = -EPROBE_DEFER;
200 }
201 fwnode_handle_put(fixed_node);
202
203 if (ret)
204 return ret;
205 } else {
206 u32 prop[5];
207
208 ret = fwnode_property_read_u32_array(fwnode, "fixed-link",
209 NULL, 0);
210 if (ret != ARRAY_SIZE(prop)) {
211 phylink_err(pl, "broken fixed-link?\n");
212 return -EINVAL;
213 }
214
215 ret = fwnode_property_read_u32_array(fwnode, "fixed-link",
216 prop, ARRAY_SIZE(prop));
217 if (!ret) {
218 pl->link_config.duplex = prop[1] ?
219 DUPLEX_FULL : DUPLEX_HALF;
220 pl->link_config.speed = prop[2];
221 if (prop[3])
222 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
223 pl->link_config.lp_advertising);
224 if (prop[4])
225 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
226 pl->link_config.lp_advertising);
227 }
228 }
229
230 if (pl->link_config.speed > SPEED_1000 &&
231 pl->link_config.duplex != DUPLEX_FULL)
232 phylink_warn(pl, "fixed link specifies half duplex for %dMbps link?\n",
233 pl->link_config.speed);
234
235 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
236 linkmode_copy(pl->link_config.advertising, pl->supported);
237 phylink_validate(pl, pl->supported, &pl->link_config);
238
239 s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex,
240 pl->supported, true);
241 linkmode_zero(pl->supported);
242 phylink_set(pl->supported, MII);
243 phylink_set(pl->supported, Pause);
244 phylink_set(pl->supported, Asym_Pause);
245 phylink_set(pl->supported, Autoneg);
246 if (s) {
247 __set_bit(s->bit, pl->supported);
248 __set_bit(s->bit, pl->link_config.lp_advertising);
249 } else {
250 phylink_warn(pl, "fixed link %s duplex %dMbps not recognised\n",
251 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half",
252 pl->link_config.speed);
253 }
254
255 linkmode_and(pl->link_config.advertising, pl->link_config.advertising,
256 pl->supported);
257
258 pl->link_config.link = 1;
259 pl->link_config.an_complete = 1;
260
261 return 0;
262 }
263
phylink_parse_mode(struct phylink * pl,struct fwnode_handle * fwnode)264 static int phylink_parse_mode(struct phylink *pl, struct fwnode_handle *fwnode)
265 {
266 struct fwnode_handle *dn;
267 const char *managed;
268
269 dn = fwnode_get_named_child_node(fwnode, "fixed-link");
270 if (dn || fwnode_property_present(fwnode, "fixed-link"))
271 pl->cfg_link_an_mode = MLO_AN_FIXED;
272 fwnode_handle_put(dn);
273
274 if (fwnode_property_read_string(fwnode, "managed", &managed) == 0 &&
275 strcmp(managed, "in-band-status") == 0) {
276 if (pl->cfg_link_an_mode == MLO_AN_FIXED) {
277 phylink_err(pl,
278 "can't use both fixed-link and in-band-status\n");
279 return -EINVAL;
280 }
281
282 linkmode_zero(pl->supported);
283 phylink_set(pl->supported, MII);
284 phylink_set(pl->supported, Autoneg);
285 phylink_set(pl->supported, Asym_Pause);
286 phylink_set(pl->supported, Pause);
287 pl->link_config.an_enabled = true;
288 pl->cfg_link_an_mode = MLO_AN_INBAND;
289
290 switch (pl->link_config.interface) {
291 case PHY_INTERFACE_MODE_SGMII:
292 case PHY_INTERFACE_MODE_QSGMII:
293 phylink_set(pl->supported, 10baseT_Half);
294 phylink_set(pl->supported, 10baseT_Full);
295 phylink_set(pl->supported, 100baseT_Half);
296 phylink_set(pl->supported, 100baseT_Full);
297 phylink_set(pl->supported, 1000baseT_Half);
298 phylink_set(pl->supported, 1000baseT_Full);
299 break;
300
301 case PHY_INTERFACE_MODE_1000BASEX:
302 phylink_set(pl->supported, 1000baseX_Full);
303 break;
304
305 case PHY_INTERFACE_MODE_2500BASEX:
306 phylink_set(pl->supported, 2500baseX_Full);
307 break;
308
309 case PHY_INTERFACE_MODE_USXGMII:
310 case PHY_INTERFACE_MODE_10GKR:
311 case PHY_INTERFACE_MODE_10GBASER:
312 phylink_set(pl->supported, 10baseT_Half);
313 phylink_set(pl->supported, 10baseT_Full);
314 phylink_set(pl->supported, 100baseT_Half);
315 phylink_set(pl->supported, 100baseT_Full);
316 phylink_set(pl->supported, 1000baseT_Half);
317 phylink_set(pl->supported, 1000baseT_Full);
318 phylink_set(pl->supported, 1000baseX_Full);
319 phylink_set(pl->supported, 1000baseKX_Full);
320 phylink_set(pl->supported, 2500baseT_Full);
321 phylink_set(pl->supported, 2500baseX_Full);
322 phylink_set(pl->supported, 5000baseT_Full);
323 phylink_set(pl->supported, 10000baseT_Full);
324 phylink_set(pl->supported, 10000baseKR_Full);
325 phylink_set(pl->supported, 10000baseKX4_Full);
326 phylink_set(pl->supported, 10000baseCR_Full);
327 phylink_set(pl->supported, 10000baseSR_Full);
328 phylink_set(pl->supported, 10000baseLR_Full);
329 phylink_set(pl->supported, 10000baseLRM_Full);
330 phylink_set(pl->supported, 10000baseER_Full);
331 break;
332
333 case PHY_INTERFACE_MODE_XLGMII:
334 phylink_set(pl->supported, 25000baseCR_Full);
335 phylink_set(pl->supported, 25000baseKR_Full);
336 phylink_set(pl->supported, 25000baseSR_Full);
337 phylink_set(pl->supported, 40000baseKR4_Full);
338 phylink_set(pl->supported, 40000baseCR4_Full);
339 phylink_set(pl->supported, 40000baseSR4_Full);
340 phylink_set(pl->supported, 40000baseLR4_Full);
341 phylink_set(pl->supported, 50000baseCR2_Full);
342 phylink_set(pl->supported, 50000baseKR2_Full);
343 phylink_set(pl->supported, 50000baseSR2_Full);
344 phylink_set(pl->supported, 50000baseKR_Full);
345 phylink_set(pl->supported, 50000baseSR_Full);
346 phylink_set(pl->supported, 50000baseCR_Full);
347 phylink_set(pl->supported, 50000baseLR_ER_FR_Full);
348 phylink_set(pl->supported, 50000baseDR_Full);
349 phylink_set(pl->supported, 100000baseKR4_Full);
350 phylink_set(pl->supported, 100000baseSR4_Full);
351 phylink_set(pl->supported, 100000baseCR4_Full);
352 phylink_set(pl->supported, 100000baseLR4_ER4_Full);
353 phylink_set(pl->supported, 100000baseKR2_Full);
354 phylink_set(pl->supported, 100000baseSR2_Full);
355 phylink_set(pl->supported, 100000baseCR2_Full);
356 phylink_set(pl->supported, 100000baseLR2_ER2_FR2_Full);
357 phylink_set(pl->supported, 100000baseDR2_Full);
358 break;
359
360 default:
361 phylink_err(pl,
362 "incorrect link mode %s for in-band status\n",
363 phy_modes(pl->link_config.interface));
364 return -EINVAL;
365 }
366
367 linkmode_copy(pl->link_config.advertising, pl->supported);
368
369 if (phylink_validate(pl, pl->supported, &pl->link_config)) {
370 phylink_err(pl,
371 "failed to validate link configuration for in-band status\n");
372 return -EINVAL;
373 }
374
375 /* Check if MAC/PCS also supports Autoneg. */
376 pl->link_config.an_enabled = phylink_test(pl->supported, Autoneg);
377 }
378
379 return 0;
380 }
381
phylink_apply_manual_flow(struct phylink * pl,struct phylink_link_state * state)382 static void phylink_apply_manual_flow(struct phylink *pl,
383 struct phylink_link_state *state)
384 {
385 /* If autoneg is disabled, pause AN is also disabled */
386 if (!state->an_enabled)
387 state->pause &= ~MLO_PAUSE_AN;
388
389 /* Manual configuration of pause modes */
390 if (!(pl->link_config.pause & MLO_PAUSE_AN))
391 state->pause = pl->link_config.pause;
392 }
393
phylink_resolve_flow(struct phylink_link_state * state)394 static void phylink_resolve_flow(struct phylink_link_state *state)
395 {
396 bool tx_pause, rx_pause;
397
398 state->pause = MLO_PAUSE_NONE;
399 if (state->duplex == DUPLEX_FULL) {
400 linkmode_resolve_pause(state->advertising,
401 state->lp_advertising,
402 &tx_pause, &rx_pause);
403 if (tx_pause)
404 state->pause |= MLO_PAUSE_TX;
405 if (rx_pause)
406 state->pause |= MLO_PAUSE_RX;
407 }
408 }
409
phylink_mac_config(struct phylink * pl,const struct phylink_link_state * state)410 static void phylink_mac_config(struct phylink *pl,
411 const struct phylink_link_state *state)
412 {
413 phylink_dbg(pl,
414 "%s: mode=%s/%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n",
415 __func__, phylink_an_mode_str(pl->cur_link_an_mode),
416 phy_modes(state->interface),
417 phy_speed_to_str(state->speed),
418 phy_duplex_to_str(state->duplex),
419 __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising,
420 state->pause, state->link, state->an_enabled);
421
422 pl->mac_ops->mac_config(pl->config, pl->cur_link_an_mode, state);
423 }
424
phylink_mac_pcs_an_restart(struct phylink * pl)425 static void phylink_mac_pcs_an_restart(struct phylink *pl)
426 {
427 if (pl->link_config.an_enabled &&
428 phy_interface_mode_is_8023z(pl->link_config.interface) &&
429 phylink_autoneg_inband(pl->cur_link_an_mode)) {
430 if (pl->pcs_ops)
431 pl->pcs_ops->pcs_an_restart(pl->pcs);
432 else
433 pl->mac_ops->mac_an_restart(pl->config);
434 }
435 }
436
phylink_major_config(struct phylink * pl,bool restart,const struct phylink_link_state * state)437 static void phylink_major_config(struct phylink *pl, bool restart,
438 const struct phylink_link_state *state)
439 {
440 int err;
441
442 phylink_dbg(pl, "major config %s\n", phy_modes(state->interface));
443
444 if (pl->mac_ops->mac_prepare) {
445 err = pl->mac_ops->mac_prepare(pl->config, pl->cur_link_an_mode,
446 state->interface);
447 if (err < 0) {
448 phylink_err(pl, "mac_prepare failed: %pe\n",
449 ERR_PTR(err));
450 return;
451 }
452 }
453
454 phylink_mac_config(pl, state);
455
456 if (pl->pcs_ops) {
457 err = pl->pcs_ops->pcs_config(pl->pcs, pl->cur_link_an_mode,
458 state->interface,
459 state->advertising,
460 !!(pl->link_config.pause &
461 MLO_PAUSE_AN));
462 if (err < 0)
463 phylink_err(pl, "pcs_config failed: %pe\n",
464 ERR_PTR(err));
465 if (err > 0)
466 restart = true;
467 }
468 if (restart)
469 phylink_mac_pcs_an_restart(pl);
470
471 if (pl->mac_ops->mac_finish) {
472 err = pl->mac_ops->mac_finish(pl->config, pl->cur_link_an_mode,
473 state->interface);
474 if (err < 0)
475 phylink_err(pl, "mac_finish failed: %pe\n",
476 ERR_PTR(err));
477 }
478 }
479
480 /*
481 * Reconfigure for a change of inband advertisement.
482 * If we have a separate PCS, we only need to call its pcs_config() method,
483 * and then restart AN if it indicates something changed. Otherwise, we do
484 * the full MAC reconfiguration.
485 */
phylink_change_inband_advert(struct phylink * pl)486 static int phylink_change_inband_advert(struct phylink *pl)
487 {
488 int ret;
489
490 if (test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state))
491 return 0;
492
493 if (!pl->pcs_ops) {
494 /* Legacy method */
495 phylink_mac_config(pl, &pl->link_config);
496 phylink_mac_pcs_an_restart(pl);
497 return 0;
498 }
499
500 phylink_dbg(pl, "%s: mode=%s/%s adv=%*pb pause=%02x\n", __func__,
501 phylink_an_mode_str(pl->cur_link_an_mode),
502 phy_modes(pl->link_config.interface),
503 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->link_config.advertising,
504 pl->link_config.pause);
505
506 /* Modern PCS-based method; update the advert at the PCS, and
507 * restart negotiation if the pcs_config() helper indicates that
508 * the programmed advertisement has changed.
509 */
510 ret = pl->pcs_ops->pcs_config(pl->pcs, pl->cur_link_an_mode,
511 pl->link_config.interface,
512 pl->link_config.advertising,
513 !!(pl->link_config.pause & MLO_PAUSE_AN));
514 if (ret < 0)
515 return ret;
516
517 if (ret > 0)
518 phylink_mac_pcs_an_restart(pl);
519
520 return 0;
521 }
522
phylink_mac_pcs_get_state(struct phylink * pl,struct phylink_link_state * state)523 static void phylink_mac_pcs_get_state(struct phylink *pl,
524 struct phylink_link_state *state)
525 {
526 linkmode_copy(state->advertising, pl->link_config.advertising);
527 linkmode_zero(state->lp_advertising);
528 state->interface = pl->link_config.interface;
529 state->an_enabled = pl->link_config.an_enabled;
530 state->speed = SPEED_UNKNOWN;
531 state->duplex = DUPLEX_UNKNOWN;
532 state->pause = MLO_PAUSE_NONE;
533 state->an_complete = 0;
534 state->link = 1;
535
536 if (pl->pcs_ops)
537 pl->pcs_ops->pcs_get_state(pl->pcs, state);
538 else if (pl->mac_ops->mac_pcs_get_state)
539 pl->mac_ops->mac_pcs_get_state(pl->config, state);
540 else
541 state->link = 0;
542 }
543
544 /* The fixed state is... fixed except for the link state,
545 * which may be determined by a GPIO or a callback.
546 */
phylink_get_fixed_state(struct phylink * pl,struct phylink_link_state * state)547 static void phylink_get_fixed_state(struct phylink *pl,
548 struct phylink_link_state *state)
549 {
550 *state = pl->link_config;
551 if (pl->config->get_fixed_state)
552 pl->config->get_fixed_state(pl->config, state);
553 else if (pl->link_gpio)
554 state->link = !!gpiod_get_value_cansleep(pl->link_gpio);
555
556 phylink_resolve_flow(state);
557 }
558
phylink_mac_initial_config(struct phylink * pl,bool force_restart)559 static void phylink_mac_initial_config(struct phylink *pl, bool force_restart)
560 {
561 struct phylink_link_state link_state;
562
563 switch (pl->cur_link_an_mode) {
564 case MLO_AN_PHY:
565 link_state = pl->phy_state;
566 break;
567
568 case MLO_AN_FIXED:
569 phylink_get_fixed_state(pl, &link_state);
570 break;
571
572 case MLO_AN_INBAND:
573 link_state = pl->link_config;
574 if (link_state.interface == PHY_INTERFACE_MODE_SGMII)
575 link_state.pause = MLO_PAUSE_NONE;
576 break;
577
578 default: /* can't happen */
579 return;
580 }
581
582 link_state.link = false;
583
584 phylink_apply_manual_flow(pl, &link_state);
585 phylink_major_config(pl, force_restart, &link_state);
586 }
587
phylink_pause_to_str(int pause)588 static const char *phylink_pause_to_str(int pause)
589 {
590 switch (pause & MLO_PAUSE_TXRX_MASK) {
591 case MLO_PAUSE_TX | MLO_PAUSE_RX:
592 return "rx/tx";
593 case MLO_PAUSE_TX:
594 return "tx";
595 case MLO_PAUSE_RX:
596 return "rx";
597 default:
598 return "off";
599 }
600 }
601
phylink_link_up(struct phylink * pl,struct phylink_link_state link_state)602 static void phylink_link_up(struct phylink *pl,
603 struct phylink_link_state link_state)
604 {
605 struct net_device *ndev = pl->netdev;
606
607 pl->cur_interface = link_state.interface;
608
609 if (pl->pcs_ops && pl->pcs_ops->pcs_link_up)
610 pl->pcs_ops->pcs_link_up(pl->pcs, pl->cur_link_an_mode,
611 pl->cur_interface,
612 link_state.speed, link_state.duplex);
613
614 pl->mac_ops->mac_link_up(pl->config, pl->phydev,
615 pl->cur_link_an_mode, pl->cur_interface,
616 link_state.speed, link_state.duplex,
617 !!(link_state.pause & MLO_PAUSE_TX),
618 !!(link_state.pause & MLO_PAUSE_RX));
619
620 if (ndev)
621 netif_carrier_on(ndev);
622
623 phylink_info(pl,
624 "Link is Up - %s/%s - flow control %s\n",
625 phy_speed_to_str(link_state.speed),
626 phy_duplex_to_str(link_state.duplex),
627 phylink_pause_to_str(link_state.pause));
628 }
629
phylink_link_down(struct phylink * pl)630 static void phylink_link_down(struct phylink *pl)
631 {
632 struct net_device *ndev = pl->netdev;
633
634 if (ndev)
635 netif_carrier_off(ndev);
636 pl->mac_ops->mac_link_down(pl->config, pl->cur_link_an_mode,
637 pl->cur_interface);
638 phylink_info(pl, "Link is Down\n");
639 }
640
phylink_resolve(struct work_struct * w)641 static void phylink_resolve(struct work_struct *w)
642 {
643 struct phylink *pl = container_of(w, struct phylink, resolve);
644 struct phylink_link_state link_state;
645 struct net_device *ndev = pl->netdev;
646 bool mac_config = false;
647 bool retrigger = false;
648 bool cur_link_state;
649
650 mutex_lock(&pl->state_mutex);
651 if (pl->netdev)
652 cur_link_state = netif_carrier_ok(ndev);
653 else
654 cur_link_state = pl->old_link_state;
655
656 if (pl->phylink_disable_state) {
657 pl->mac_link_dropped = false;
658 link_state.link = false;
659 } else if (pl->mac_link_dropped) {
660 link_state.link = false;
661 retrigger = true;
662 } else {
663 switch (pl->cur_link_an_mode) {
664 case MLO_AN_PHY:
665 link_state = pl->phy_state;
666 phylink_apply_manual_flow(pl, &link_state);
667 mac_config = link_state.link;
668 break;
669
670 case MLO_AN_FIXED:
671 phylink_get_fixed_state(pl, &link_state);
672 mac_config = link_state.link;
673 break;
674
675 case MLO_AN_INBAND:
676 phylink_mac_pcs_get_state(pl, &link_state);
677
678 /* The PCS may have a latching link-fail indicator.
679 * If the link was up, bring the link down and
680 * re-trigger the resolve. Otherwise, re-read the
681 * PCS state to get the current status of the link.
682 */
683 if (!link_state.link) {
684 if (cur_link_state)
685 retrigger = true;
686 else
687 phylink_mac_pcs_get_state(pl,
688 &link_state);
689 }
690
691 /* If we have a phy, the "up" state is the union of
692 * both the PHY and the MAC */
693 if (pl->phydev)
694 link_state.link &= pl->phy_state.link;
695
696 /* Only update if the PHY link is up */
697 if (pl->phydev && pl->phy_state.link) {
698 /* If the interface has changed, force a
699 * link down event if the link isn't already
700 * down, and re-resolve.
701 */
702 if (link_state.interface !=
703 pl->phy_state.interface) {
704 retrigger = true;
705 link_state.link = false;
706 }
707 link_state.interface = pl->phy_state.interface;
708
709 /* If we have a PHY, we need to update with
710 * the PHY flow control bits. */
711 link_state.pause = pl->phy_state.pause;
712 mac_config = true;
713 }
714 phylink_apply_manual_flow(pl, &link_state);
715 break;
716 }
717 }
718
719 if (mac_config) {
720 if (link_state.interface != pl->link_config.interface) {
721 /* The interface has changed, force the link down and
722 * then reconfigure.
723 */
724 if (cur_link_state) {
725 phylink_link_down(pl);
726 cur_link_state = false;
727 }
728 phylink_major_config(pl, false, &link_state);
729 pl->link_config.interface = link_state.interface;
730 } else if (!pl->pcs_ops) {
731 /* The interface remains unchanged, only the speed,
732 * duplex or pause settings have changed. Call the
733 * old mac_config() method to configure the MAC/PCS
734 * only if we do not have a PCS installed (an
735 * unconverted user.)
736 */
737 phylink_mac_config(pl, &link_state);
738 }
739 }
740
741 if (link_state.link != cur_link_state) {
742 pl->old_link_state = link_state.link;
743 if (!link_state.link)
744 phylink_link_down(pl);
745 else
746 phylink_link_up(pl, link_state);
747 }
748 if (!link_state.link && retrigger) {
749 pl->mac_link_dropped = false;
750 queue_work(system_power_efficient_wq, &pl->resolve);
751 }
752 mutex_unlock(&pl->state_mutex);
753 }
754
phylink_run_resolve(struct phylink * pl)755 static void phylink_run_resolve(struct phylink *pl)
756 {
757 if (!pl->phylink_disable_state)
758 queue_work(system_power_efficient_wq, &pl->resolve);
759 }
760
phylink_run_resolve_and_disable(struct phylink * pl,int bit)761 static void phylink_run_resolve_and_disable(struct phylink *pl, int bit)
762 {
763 unsigned long state = pl->phylink_disable_state;
764
765 set_bit(bit, &pl->phylink_disable_state);
766 if (state == 0) {
767 queue_work(system_power_efficient_wq, &pl->resolve);
768 flush_work(&pl->resolve);
769 }
770 }
771
phylink_fixed_poll(struct timer_list * t)772 static void phylink_fixed_poll(struct timer_list *t)
773 {
774 struct phylink *pl = container_of(t, struct phylink, link_poll);
775
776 mod_timer(t, jiffies + HZ);
777
778 phylink_run_resolve(pl);
779 }
780
781 static const struct sfp_upstream_ops sfp_phylink_ops;
782
phylink_register_sfp(struct phylink * pl,struct fwnode_handle * fwnode)783 static int phylink_register_sfp(struct phylink *pl,
784 struct fwnode_handle *fwnode)
785 {
786 struct sfp_bus *bus;
787 int ret;
788
789 if (!fwnode)
790 return 0;
791
792 bus = sfp_bus_find_fwnode(fwnode);
793 if (IS_ERR(bus)) {
794 ret = PTR_ERR(bus);
795 phylink_err(pl, "unable to attach SFP bus: %d\n", ret);
796 return ret;
797 }
798
799 pl->sfp_bus = bus;
800
801 ret = sfp_bus_add_upstream(bus, pl, &sfp_phylink_ops);
802 sfp_bus_put(bus);
803
804 return ret;
805 }
806
807 /**
808 * phylink_create() - create a phylink instance
809 * @config: a pointer to the target &struct phylink_config
810 * @fwnode: a pointer to a &struct fwnode_handle describing the network
811 * interface
812 * @iface: the desired link mode defined by &typedef phy_interface_t
813 * @mac_ops: a pointer to a &struct phylink_mac_ops for the MAC.
814 *
815 * Create a new phylink instance, and parse the link parameters found in @np.
816 * This will parse in-band modes, fixed-link or SFP configuration.
817 *
818 * Note: the rtnl lock must not be held when calling this function.
819 *
820 * Returns a pointer to a &struct phylink, or an error-pointer value. Users
821 * must use IS_ERR() to check for errors from this function.
822 */
phylink_create(struct phylink_config * config,struct fwnode_handle * fwnode,phy_interface_t iface,const struct phylink_mac_ops * mac_ops)823 struct phylink *phylink_create(struct phylink_config *config,
824 struct fwnode_handle *fwnode,
825 phy_interface_t iface,
826 const struct phylink_mac_ops *mac_ops)
827 {
828 struct phylink *pl;
829 int ret;
830
831 pl = kzalloc(sizeof(*pl), GFP_KERNEL);
832 if (!pl)
833 return ERR_PTR(-ENOMEM);
834
835 mutex_init(&pl->state_mutex);
836 INIT_WORK(&pl->resolve, phylink_resolve);
837
838 pl->config = config;
839 if (config->type == PHYLINK_NETDEV) {
840 pl->netdev = to_net_dev(config->dev);
841 } else if (config->type == PHYLINK_DEV) {
842 pl->dev = config->dev;
843 } else {
844 kfree(pl);
845 return ERR_PTR(-EINVAL);
846 }
847
848 pl->phy_state.interface = iface;
849 pl->link_interface = iface;
850 if (iface == PHY_INTERFACE_MODE_MOCA)
851 pl->link_port = PORT_BNC;
852 else
853 pl->link_port = PORT_MII;
854 pl->link_config.interface = iface;
855 pl->link_config.pause = MLO_PAUSE_AN;
856 pl->link_config.speed = SPEED_UNKNOWN;
857 pl->link_config.duplex = DUPLEX_UNKNOWN;
858 pl->link_config.an_enabled = true;
859 pl->mac_ops = mac_ops;
860 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
861 timer_setup(&pl->link_poll, phylink_fixed_poll, 0);
862
863 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
864 linkmode_copy(pl->link_config.advertising, pl->supported);
865 phylink_validate(pl, pl->supported, &pl->link_config);
866
867 ret = phylink_parse_mode(pl, fwnode);
868 if (ret < 0) {
869 kfree(pl);
870 return ERR_PTR(ret);
871 }
872
873 if (pl->cfg_link_an_mode == MLO_AN_FIXED) {
874 ret = phylink_parse_fixedlink(pl, fwnode);
875 if (ret < 0) {
876 kfree(pl);
877 return ERR_PTR(ret);
878 }
879 }
880
881 pl->cur_link_an_mode = pl->cfg_link_an_mode;
882
883 ret = phylink_register_sfp(pl, fwnode);
884 if (ret < 0) {
885 kfree(pl);
886 return ERR_PTR(ret);
887 }
888
889 return pl;
890 }
891 EXPORT_SYMBOL_GPL(phylink_create);
892
893 /**
894 * phylink_set_pcs() - set the current PCS for phylink to use
895 * @pl: a pointer to a &struct phylink returned from phylink_create()
896 * @pcs: a pointer to the &struct phylink_pcs
897 *
898 * Bind the MAC PCS to phylink. This may be called after phylink_create(),
899 * in mac_prepare() or mac_config() methods if it is desired to dynamically
900 * change the PCS.
901 *
902 * Please note that there are behavioural changes with the mac_config()
903 * callback if a PCS is present (denoting a newer setup) so removing a PCS
904 * is not supported, and if a PCS is going to be used, it must be registered
905 * by calling phylink_set_pcs() at the latest in the first mac_config() call.
906 */
phylink_set_pcs(struct phylink * pl,struct phylink_pcs * pcs)907 void phylink_set_pcs(struct phylink *pl, struct phylink_pcs *pcs)
908 {
909 pl->pcs = pcs;
910 pl->pcs_ops = pcs->ops;
911 }
912 EXPORT_SYMBOL_GPL(phylink_set_pcs);
913
914 /**
915 * phylink_destroy() - cleanup and destroy the phylink instance
916 * @pl: a pointer to a &struct phylink returned from phylink_create()
917 *
918 * Destroy a phylink instance. Any PHY that has been attached must have been
919 * cleaned up via phylink_disconnect_phy() prior to calling this function.
920 *
921 * Note: the rtnl lock must not be held when calling this function.
922 */
phylink_destroy(struct phylink * pl)923 void phylink_destroy(struct phylink *pl)
924 {
925 sfp_bus_del_upstream(pl->sfp_bus);
926 if (pl->link_gpio)
927 gpiod_put(pl->link_gpio);
928
929 cancel_work_sync(&pl->resolve);
930 kfree(pl);
931 }
932 EXPORT_SYMBOL_GPL(phylink_destroy);
933
phylink_phy_change(struct phy_device * phydev,bool up)934 static void phylink_phy_change(struct phy_device *phydev, bool up)
935 {
936 struct phylink *pl = phydev->phylink;
937 bool tx_pause, rx_pause;
938
939 phy_get_pause(phydev, &tx_pause, &rx_pause);
940
941 mutex_lock(&pl->state_mutex);
942 pl->phy_state.speed = phydev->speed;
943 pl->phy_state.duplex = phydev->duplex;
944 pl->phy_state.pause = MLO_PAUSE_NONE;
945 if (tx_pause)
946 pl->phy_state.pause |= MLO_PAUSE_TX;
947 if (rx_pause)
948 pl->phy_state.pause |= MLO_PAUSE_RX;
949 pl->phy_state.interface = phydev->interface;
950 pl->phy_state.link = up;
951 mutex_unlock(&pl->state_mutex);
952
953 phylink_run_resolve(pl);
954
955 phylink_dbg(pl, "phy link %s %s/%s/%s\n", up ? "up" : "down",
956 phy_modes(phydev->interface),
957 phy_speed_to_str(phydev->speed),
958 phy_duplex_to_str(phydev->duplex));
959 }
960
phylink_bringup_phy(struct phylink * pl,struct phy_device * phy,phy_interface_t interface)961 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy,
962 phy_interface_t interface)
963 {
964 struct phylink_link_state config;
965 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
966 char *irq_str;
967 int ret;
968
969 /*
970 * This is the new way of dealing with flow control for PHYs,
971 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
972 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
973 * using our validate call to the MAC, we rely upon the MAC
974 * clearing the bits from both supported and advertising fields.
975 */
976 phy_support_asym_pause(phy);
977
978 memset(&config, 0, sizeof(config));
979 linkmode_copy(supported, phy->supported);
980 linkmode_copy(config.advertising, phy->advertising);
981
982 /* Clause 45 PHYs switch their Serdes lane between several different
983 * modes, normally 10GBASE-R, SGMII. Some use 2500BASE-X for 2.5G
984 * speeds. We really need to know which interface modes the PHY and
985 * MAC supports to properly work out which linkmodes can be supported.
986 */
987 if (phy->is_c45 &&
988 interface != PHY_INTERFACE_MODE_RXAUI &&
989 interface != PHY_INTERFACE_MODE_XAUI &&
990 interface != PHY_INTERFACE_MODE_USXGMII)
991 config.interface = PHY_INTERFACE_MODE_NA;
992 else
993 config.interface = interface;
994
995 ret = phylink_validate(pl, supported, &config);
996 if (ret) {
997 phylink_warn(pl, "validation of %s with support %*pb and advertisement %*pb failed: %d\n",
998 phy_modes(config.interface),
999 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->supported,
1000 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising,
1001 ret);
1002 return ret;
1003 }
1004
1005 phy->phylink = pl;
1006 phy->phy_link_change = phylink_phy_change;
1007
1008 irq_str = phy_attached_info_irq(phy);
1009 phylink_info(pl,
1010 "PHY [%s] driver [%s] (irq=%s)\n",
1011 dev_name(&phy->mdio.dev), phy->drv->name, irq_str);
1012 kfree(irq_str);
1013
1014 mutex_lock(&phy->lock);
1015 mutex_lock(&pl->state_mutex);
1016 pl->phydev = phy;
1017 pl->phy_state.interface = interface;
1018 pl->phy_state.pause = MLO_PAUSE_NONE;
1019 pl->phy_state.speed = SPEED_UNKNOWN;
1020 pl->phy_state.duplex = DUPLEX_UNKNOWN;
1021 linkmode_copy(pl->supported, supported);
1022 linkmode_copy(pl->link_config.advertising, config.advertising);
1023
1024 /* Restrict the phy advertisement according to the MAC support. */
1025 linkmode_copy(phy->advertising, config.advertising);
1026 mutex_unlock(&pl->state_mutex);
1027 mutex_unlock(&phy->lock);
1028
1029 phylink_dbg(pl,
1030 "phy: setting supported %*pb advertising %*pb\n",
1031 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported,
1032 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->advertising);
1033
1034 if (phy_interrupt_is_valid(phy))
1035 phy_request_interrupt(phy);
1036
1037 return 0;
1038 }
1039
phylink_attach_phy(struct phylink * pl,struct phy_device * phy,phy_interface_t interface)1040 static int phylink_attach_phy(struct phylink *pl, struct phy_device *phy,
1041 phy_interface_t interface)
1042 {
1043 if (WARN_ON(pl->cfg_link_an_mode == MLO_AN_FIXED ||
1044 (pl->cfg_link_an_mode == MLO_AN_INBAND &&
1045 phy_interface_mode_is_8023z(interface))))
1046 return -EINVAL;
1047
1048 if (pl->phydev)
1049 return -EBUSY;
1050
1051 return phy_attach_direct(pl->netdev, phy, 0, interface);
1052 }
1053
1054 /**
1055 * phylink_connect_phy() - connect a PHY to the phylink instance
1056 * @pl: a pointer to a &struct phylink returned from phylink_create()
1057 * @phy: a pointer to a &struct phy_device.
1058 *
1059 * Connect @phy to the phylink instance specified by @pl by calling
1060 * phy_attach_direct(). Configure the @phy according to the MAC driver's
1061 * capabilities, start the PHYLIB state machine and enable any interrupts
1062 * that the PHY supports.
1063 *
1064 * This updates the phylink's ethtool supported and advertising link mode
1065 * masks.
1066 *
1067 * Returns 0 on success or a negative errno.
1068 */
phylink_connect_phy(struct phylink * pl,struct phy_device * phy)1069 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy)
1070 {
1071 int ret;
1072
1073 /* Use PHY device/driver interface */
1074 if (pl->link_interface == PHY_INTERFACE_MODE_NA) {
1075 pl->link_interface = phy->interface;
1076 pl->link_config.interface = pl->link_interface;
1077 }
1078
1079 ret = phylink_attach_phy(pl, phy, pl->link_interface);
1080 if (ret < 0)
1081 return ret;
1082
1083 ret = phylink_bringup_phy(pl, phy, pl->link_config.interface);
1084 if (ret)
1085 phy_detach(phy);
1086
1087 return ret;
1088 }
1089 EXPORT_SYMBOL_GPL(phylink_connect_phy);
1090
1091 /**
1092 * phylink_of_phy_connect() - connect the PHY specified in the DT mode.
1093 * @pl: a pointer to a &struct phylink returned from phylink_create()
1094 * @dn: a pointer to a &struct device_node.
1095 * @flags: PHY-specific flags to communicate to the PHY device driver
1096 *
1097 * Connect the phy specified in the device node @dn to the phylink instance
1098 * specified by @pl. Actions specified in phylink_connect_phy() will be
1099 * performed.
1100 *
1101 * Returns 0 on success or a negative errno.
1102 */
phylink_of_phy_connect(struct phylink * pl,struct device_node * dn,u32 flags)1103 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn,
1104 u32 flags)
1105 {
1106 struct device_node *phy_node;
1107 struct phy_device *phy_dev;
1108 int ret;
1109
1110 /* Fixed links and 802.3z are handled without needing a PHY */
1111 if (pl->cfg_link_an_mode == MLO_AN_FIXED ||
1112 (pl->cfg_link_an_mode == MLO_AN_INBAND &&
1113 phy_interface_mode_is_8023z(pl->link_interface)))
1114 return 0;
1115
1116 phy_node = of_parse_phandle(dn, "phy-handle", 0);
1117 if (!phy_node)
1118 phy_node = of_parse_phandle(dn, "phy", 0);
1119 if (!phy_node)
1120 phy_node = of_parse_phandle(dn, "phy-device", 0);
1121
1122 if (!phy_node) {
1123 if (pl->cfg_link_an_mode == MLO_AN_PHY)
1124 return -ENODEV;
1125 return 0;
1126 }
1127
1128 phy_dev = of_phy_find_device(phy_node);
1129 /* We're done with the phy_node handle */
1130 of_node_put(phy_node);
1131 if (!phy_dev)
1132 return -ENODEV;
1133
1134 ret = phy_attach_direct(pl->netdev, phy_dev, flags,
1135 pl->link_interface);
1136 if (ret)
1137 return ret;
1138
1139 ret = phylink_bringup_phy(pl, phy_dev, pl->link_config.interface);
1140 if (ret)
1141 phy_detach(phy_dev);
1142
1143 return ret;
1144 }
1145 EXPORT_SYMBOL_GPL(phylink_of_phy_connect);
1146
1147 /**
1148 * phylink_disconnect_phy() - disconnect any PHY attached to the phylink
1149 * instance.
1150 * @pl: a pointer to a &struct phylink returned from phylink_create()
1151 *
1152 * Disconnect any current PHY from the phylink instance described by @pl.
1153 */
phylink_disconnect_phy(struct phylink * pl)1154 void phylink_disconnect_phy(struct phylink *pl)
1155 {
1156 struct phy_device *phy;
1157
1158 ASSERT_RTNL();
1159
1160 phy = pl->phydev;
1161 if (phy) {
1162 mutex_lock(&phy->lock);
1163 mutex_lock(&pl->state_mutex);
1164 pl->phydev = NULL;
1165 mutex_unlock(&pl->state_mutex);
1166 mutex_unlock(&phy->lock);
1167 flush_work(&pl->resolve);
1168
1169 phy_disconnect(phy);
1170 }
1171 }
1172 EXPORT_SYMBOL_GPL(phylink_disconnect_phy);
1173
1174 /**
1175 * phylink_mac_change() - notify phylink of a change in MAC state
1176 * @pl: a pointer to a &struct phylink returned from phylink_create()
1177 * @up: indicates whether the link is currently up.
1178 *
1179 * The MAC driver should call this driver when the state of its link
1180 * changes (eg, link failure, new negotiation results, etc.)
1181 */
phylink_mac_change(struct phylink * pl,bool up)1182 void phylink_mac_change(struct phylink *pl, bool up)
1183 {
1184 if (!up)
1185 pl->mac_link_dropped = true;
1186 phylink_run_resolve(pl);
1187 phylink_dbg(pl, "mac link %s\n", up ? "up" : "down");
1188 }
1189 EXPORT_SYMBOL_GPL(phylink_mac_change);
1190
phylink_link_handler(int irq,void * data)1191 static irqreturn_t phylink_link_handler(int irq, void *data)
1192 {
1193 struct phylink *pl = data;
1194
1195 phylink_run_resolve(pl);
1196
1197 return IRQ_HANDLED;
1198 }
1199
1200 /**
1201 * phylink_start() - start a phylink instance
1202 * @pl: a pointer to a &struct phylink returned from phylink_create()
1203 *
1204 * Start the phylink instance specified by @pl, configuring the MAC for the
1205 * desired link mode(s) and negotiation style. This should be called from the
1206 * network device driver's &struct net_device_ops ndo_open() method.
1207 */
phylink_start(struct phylink * pl)1208 void phylink_start(struct phylink *pl)
1209 {
1210 bool poll = false;
1211
1212 ASSERT_RTNL();
1213
1214 phylink_info(pl, "configuring for %s/%s link mode\n",
1215 phylink_an_mode_str(pl->cur_link_an_mode),
1216 phy_modes(pl->link_config.interface));
1217
1218 /* Always set the carrier off */
1219 if (pl->netdev)
1220 netif_carrier_off(pl->netdev);
1221
1222 /* Apply the link configuration to the MAC when starting. This allows
1223 * a fixed-link to start with the correct parameters, and also
1224 * ensures that we set the appropriate advertisement for Serdes links.
1225 *
1226 * Restart autonegotiation if using 802.3z to ensure that the link
1227 * parameters are properly negotiated. This is necessary for DSA
1228 * switches using 802.3z negotiation to ensure they see our modes.
1229 */
1230 phylink_mac_initial_config(pl, true);
1231
1232 clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
1233 phylink_run_resolve(pl);
1234
1235 if (pl->cfg_link_an_mode == MLO_AN_FIXED && pl->link_gpio) {
1236 int irq = gpiod_to_irq(pl->link_gpio);
1237
1238 if (irq > 0) {
1239 if (!request_irq(irq, phylink_link_handler,
1240 IRQF_TRIGGER_RISING |
1241 IRQF_TRIGGER_FALLING,
1242 "netdev link", pl))
1243 pl->link_irq = irq;
1244 else
1245 irq = 0;
1246 }
1247 if (irq <= 0)
1248 poll = true;
1249 }
1250
1251 switch (pl->cfg_link_an_mode) {
1252 case MLO_AN_FIXED:
1253 poll |= pl->config->poll_fixed_state;
1254 break;
1255 case MLO_AN_INBAND:
1256 poll |= pl->config->pcs_poll;
1257 if (pl->pcs)
1258 poll |= pl->pcs->poll;
1259 break;
1260 }
1261 if (poll)
1262 mod_timer(&pl->link_poll, jiffies + HZ);
1263 if (pl->phydev)
1264 phy_start(pl->phydev);
1265 if (pl->sfp_bus)
1266 sfp_upstream_start(pl->sfp_bus);
1267 }
1268 EXPORT_SYMBOL_GPL(phylink_start);
1269
1270 /**
1271 * phylink_stop() - stop a phylink instance
1272 * @pl: a pointer to a &struct phylink returned from phylink_create()
1273 *
1274 * Stop the phylink instance specified by @pl. This should be called from the
1275 * network device driver's &struct net_device_ops ndo_stop() method. The
1276 * network device's carrier state should not be changed prior to calling this
1277 * function.
1278 */
phylink_stop(struct phylink * pl)1279 void phylink_stop(struct phylink *pl)
1280 {
1281 ASSERT_RTNL();
1282
1283 if (pl->sfp_bus)
1284 sfp_upstream_stop(pl->sfp_bus);
1285 if (pl->phydev)
1286 phy_stop(pl->phydev);
1287 del_timer_sync(&pl->link_poll);
1288 if (pl->link_irq) {
1289 free_irq(pl->link_irq, pl);
1290 pl->link_irq = 0;
1291 }
1292
1293 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED);
1294 }
1295 EXPORT_SYMBOL_GPL(phylink_stop);
1296
1297 /**
1298 * phylink_ethtool_get_wol() - get the wake on lan parameters for the PHY
1299 * @pl: a pointer to a &struct phylink returned from phylink_create()
1300 * @wol: a pointer to &struct ethtool_wolinfo to hold the read parameters
1301 *
1302 * Read the wake on lan parameters from the PHY attached to the phylink
1303 * instance specified by @pl. If no PHY is currently attached, report no
1304 * support for wake on lan.
1305 */
phylink_ethtool_get_wol(struct phylink * pl,struct ethtool_wolinfo * wol)1306 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
1307 {
1308 ASSERT_RTNL();
1309
1310 wol->supported = 0;
1311 wol->wolopts = 0;
1312
1313 if (pl->phydev)
1314 phy_ethtool_get_wol(pl->phydev, wol);
1315 }
1316 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol);
1317
1318 /**
1319 * phylink_ethtool_set_wol() - set wake on lan parameters
1320 * @pl: a pointer to a &struct phylink returned from phylink_create()
1321 * @wol: a pointer to &struct ethtool_wolinfo for the desired parameters
1322 *
1323 * Set the wake on lan parameters for the PHY attached to the phylink
1324 * instance specified by @pl. If no PHY is attached, returns %EOPNOTSUPP
1325 * error.
1326 *
1327 * Returns zero on success or negative errno code.
1328 */
phylink_ethtool_set_wol(struct phylink * pl,struct ethtool_wolinfo * wol)1329 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol)
1330 {
1331 int ret = -EOPNOTSUPP;
1332
1333 ASSERT_RTNL();
1334
1335 if (pl->phydev)
1336 ret = phy_ethtool_set_wol(pl->phydev, wol);
1337
1338 return ret;
1339 }
1340 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol);
1341
phylink_merge_link_mode(unsigned long * dst,const unsigned long * b)1342 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b)
1343 {
1344 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask);
1345
1346 linkmode_zero(mask);
1347 phylink_set_port_modes(mask);
1348
1349 linkmode_and(dst, dst, mask);
1350 linkmode_or(dst, dst, b);
1351 }
1352
phylink_get_ksettings(const struct phylink_link_state * state,struct ethtool_link_ksettings * kset)1353 static void phylink_get_ksettings(const struct phylink_link_state *state,
1354 struct ethtool_link_ksettings *kset)
1355 {
1356 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising);
1357 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising);
1358 kset->base.speed = state->speed;
1359 kset->base.duplex = state->duplex;
1360 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE :
1361 AUTONEG_DISABLE;
1362 }
1363
1364 /**
1365 * phylink_ethtool_ksettings_get() - get the current link settings
1366 * @pl: a pointer to a &struct phylink returned from phylink_create()
1367 * @kset: a pointer to a &struct ethtool_link_ksettings to hold link settings
1368 *
1369 * Read the current link settings for the phylink instance specified by @pl.
1370 * This will be the link settings read from the MAC, PHY or fixed link
1371 * settings depending on the current negotiation mode.
1372 */
phylink_ethtool_ksettings_get(struct phylink * pl,struct ethtool_link_ksettings * kset)1373 int phylink_ethtool_ksettings_get(struct phylink *pl,
1374 struct ethtool_link_ksettings *kset)
1375 {
1376 struct phylink_link_state link_state;
1377
1378 ASSERT_RTNL();
1379
1380 if (pl->phydev) {
1381 phy_ethtool_ksettings_get(pl->phydev, kset);
1382 } else {
1383 kset->base.port = pl->link_port;
1384 }
1385
1386 linkmode_copy(kset->link_modes.supported, pl->supported);
1387
1388 switch (pl->cur_link_an_mode) {
1389 case MLO_AN_FIXED:
1390 /* We are using fixed settings. Report these as the
1391 * current link settings - and note that these also
1392 * represent the supported speeds/duplex/pause modes.
1393 */
1394 phylink_get_fixed_state(pl, &link_state);
1395 phylink_get_ksettings(&link_state, kset);
1396 break;
1397
1398 case MLO_AN_INBAND:
1399 /* If there is a phy attached, then use the reported
1400 * settings from the phy with no modification.
1401 */
1402 if (pl->phydev)
1403 break;
1404
1405 phylink_mac_pcs_get_state(pl, &link_state);
1406
1407 /* The MAC is reporting the link results from its own PCS
1408 * layer via in-band status. Report these as the current
1409 * link settings.
1410 */
1411 phylink_get_ksettings(&link_state, kset);
1412 break;
1413 }
1414
1415 return 0;
1416 }
1417 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get);
1418
1419 /**
1420 * phylink_ethtool_ksettings_set() - set the link settings
1421 * @pl: a pointer to a &struct phylink returned from phylink_create()
1422 * @kset: a pointer to a &struct ethtool_link_ksettings for the desired modes
1423 */
phylink_ethtool_ksettings_set(struct phylink * pl,const struct ethtool_link_ksettings * kset)1424 int phylink_ethtool_ksettings_set(struct phylink *pl,
1425 const struct ethtool_link_ksettings *kset)
1426 {
1427 __ETHTOOL_DECLARE_LINK_MODE_MASK(support);
1428 struct phylink_link_state config;
1429 const struct phy_setting *s;
1430
1431 ASSERT_RTNL();
1432
1433 if (pl->phydev) {
1434 /* We can rely on phylib for this update; we also do not need
1435 * to update the pl->link_config settings:
1436 * - the configuration returned via ksettings_get() will come
1437 * from phylib whenever a PHY is present.
1438 * - link_config.interface will be updated by the PHY calling
1439 * back via phylink_phy_change() and a subsequent resolve.
1440 * - initial link configuration for PHY mode comes from the
1441 * last phy state updated via phylink_phy_change().
1442 * - other configuration changes (e.g. pause modes) are
1443 * performed directly via phylib.
1444 * - if in in-band mode with a PHY, the link configuration
1445 * is passed on the link from the PHY, and all of
1446 * link_config.{speed,duplex,an_enabled,pause} are not used.
1447 * - the only possible use would be link_config.advertising
1448 * pause modes when in 1000base-X mode with a PHY, but in
1449 * the presence of a PHY, this should not be changed as that
1450 * should be determined from the media side advertisement.
1451 */
1452 return phy_ethtool_ksettings_set(pl->phydev, kset);
1453 }
1454
1455 linkmode_copy(support, pl->supported);
1456 config = pl->link_config;
1457 config.an_enabled = kset->base.autoneg == AUTONEG_ENABLE;
1458
1459 /* Mask out unsupported advertisements, and force the autoneg bit */
1460 linkmode_and(config.advertising, kset->link_modes.advertising,
1461 support);
1462 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising,
1463 config.an_enabled);
1464
1465 /* FIXME: should we reject autoneg if phy/mac does not support it? */
1466 switch (kset->base.autoneg) {
1467 case AUTONEG_DISABLE:
1468 /* Autonegotiation disabled, select a suitable speed and
1469 * duplex.
1470 */
1471 s = phy_lookup_setting(kset->base.speed, kset->base.duplex,
1472 support, false);
1473 if (!s)
1474 return -EINVAL;
1475
1476 /* If we have a fixed link, refuse to change link parameters.
1477 * If the link parameters match, accept them but do nothing.
1478 */
1479 if (pl->cur_link_an_mode == MLO_AN_FIXED) {
1480 if (s->speed != pl->link_config.speed ||
1481 s->duplex != pl->link_config.duplex)
1482 return -EINVAL;
1483 return 0;
1484 }
1485
1486 config.speed = s->speed;
1487 config.duplex = s->duplex;
1488 break;
1489
1490 case AUTONEG_ENABLE:
1491 /* If we have a fixed link, allow autonegotiation (since that
1492 * is our default case) but do not allow the advertisement to
1493 * be changed. If the advertisement matches, simply return.
1494 */
1495 if (pl->cur_link_an_mode == MLO_AN_FIXED) {
1496 if (!linkmode_equal(config.advertising,
1497 pl->link_config.advertising))
1498 return -EINVAL;
1499 return 0;
1500 }
1501
1502 config.speed = SPEED_UNKNOWN;
1503 config.duplex = DUPLEX_UNKNOWN;
1504 break;
1505
1506 default:
1507 return -EINVAL;
1508 }
1509
1510 /* We have ruled out the case with a PHY attached, and the
1511 * fixed-link cases. All that is left are in-band links.
1512 */
1513 if (phylink_validate(pl, support, &config))
1514 return -EINVAL;
1515
1516 /* If autonegotiation is enabled, we must have an advertisement */
1517 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising))
1518 return -EINVAL;
1519
1520 /* If this link is with an SFP, ensure that changes to advertised modes
1521 * also cause the associated interface to be selected such that the
1522 * link can be configured correctly.
1523 */
1524 if (pl->sfp_port && pl->sfp_bus) {
1525 config.interface = sfp_select_interface(pl->sfp_bus,
1526 config.advertising);
1527 if (config.interface == PHY_INTERFACE_MODE_NA) {
1528 phylink_err(pl,
1529 "selection of interface failed, advertisement %*pb\n",
1530 __ETHTOOL_LINK_MODE_MASK_NBITS,
1531 config.advertising);
1532 return -EINVAL;
1533 }
1534
1535 /* Revalidate with the selected interface */
1536 linkmode_copy(support, pl->supported);
1537 if (phylink_validate(pl, support, &config)) {
1538 phylink_err(pl, "validation of %s/%s with support %*pb failed\n",
1539 phylink_an_mode_str(pl->cur_link_an_mode),
1540 phy_modes(config.interface),
1541 __ETHTOOL_LINK_MODE_MASK_NBITS, support);
1542 return -EINVAL;
1543 }
1544 }
1545
1546 mutex_lock(&pl->state_mutex);
1547 pl->link_config.speed = config.speed;
1548 pl->link_config.duplex = config.duplex;
1549 pl->link_config.an_enabled = config.an_enabled;
1550
1551 if (pl->link_config.interface != config.interface) {
1552 /* The interface changed, e.g. 1000base-X <-> 2500base-X */
1553 /* We need to force the link down, then change the interface */
1554 if (pl->old_link_state) {
1555 phylink_link_down(pl);
1556 pl->old_link_state = false;
1557 }
1558 if (!test_bit(PHYLINK_DISABLE_STOPPED,
1559 &pl->phylink_disable_state))
1560 phylink_major_config(pl, false, &config);
1561 pl->link_config.interface = config.interface;
1562 linkmode_copy(pl->link_config.advertising, config.advertising);
1563 } else if (!linkmode_equal(pl->link_config.advertising,
1564 config.advertising)) {
1565 linkmode_copy(pl->link_config.advertising, config.advertising);
1566 phylink_change_inband_advert(pl);
1567 }
1568 mutex_unlock(&pl->state_mutex);
1569
1570 return 0;
1571 }
1572 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set);
1573
1574 /**
1575 * phylink_ethtool_nway_reset() - restart negotiation
1576 * @pl: a pointer to a &struct phylink returned from phylink_create()
1577 *
1578 * Restart negotiation for the phylink instance specified by @pl. This will
1579 * cause any attached phy to restart negotiation with the link partner, and
1580 * if the MAC is in a BaseX mode, the MAC will also be requested to restart
1581 * negotiation.
1582 *
1583 * Returns zero on success, or negative error code.
1584 */
phylink_ethtool_nway_reset(struct phylink * pl)1585 int phylink_ethtool_nway_reset(struct phylink *pl)
1586 {
1587 int ret = 0;
1588
1589 ASSERT_RTNL();
1590
1591 if (pl->phydev)
1592 ret = phy_restart_aneg(pl->phydev);
1593 phylink_mac_pcs_an_restart(pl);
1594
1595 return ret;
1596 }
1597 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset);
1598
1599 /**
1600 * phylink_ethtool_get_pauseparam() - get the current pause parameters
1601 * @pl: a pointer to a &struct phylink returned from phylink_create()
1602 * @pause: a pointer to a &struct ethtool_pauseparam
1603 */
phylink_ethtool_get_pauseparam(struct phylink * pl,struct ethtool_pauseparam * pause)1604 void phylink_ethtool_get_pauseparam(struct phylink *pl,
1605 struct ethtool_pauseparam *pause)
1606 {
1607 ASSERT_RTNL();
1608
1609 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN);
1610 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX);
1611 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX);
1612 }
1613 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam);
1614
1615 /**
1616 * phylink_ethtool_set_pauseparam() - set the current pause parameters
1617 * @pl: a pointer to a &struct phylink returned from phylink_create()
1618 * @pause: a pointer to a &struct ethtool_pauseparam
1619 */
phylink_ethtool_set_pauseparam(struct phylink * pl,struct ethtool_pauseparam * pause)1620 int phylink_ethtool_set_pauseparam(struct phylink *pl,
1621 struct ethtool_pauseparam *pause)
1622 {
1623 struct phylink_link_state *config = &pl->link_config;
1624 bool manual_changed;
1625 int pause_state;
1626
1627 ASSERT_RTNL();
1628
1629 if (pl->cur_link_an_mode == MLO_AN_FIXED)
1630 return -EOPNOTSUPP;
1631
1632 if (!phylink_test(pl->supported, Pause) &&
1633 !phylink_test(pl->supported, Asym_Pause))
1634 return -EOPNOTSUPP;
1635
1636 if (!phylink_test(pl->supported, Asym_Pause) &&
1637 pause->rx_pause != pause->tx_pause)
1638 return -EINVAL;
1639
1640 pause_state = 0;
1641 if (pause->autoneg)
1642 pause_state |= MLO_PAUSE_AN;
1643 if (pause->rx_pause)
1644 pause_state |= MLO_PAUSE_RX;
1645 if (pause->tx_pause)
1646 pause_state |= MLO_PAUSE_TX;
1647
1648 mutex_lock(&pl->state_mutex);
1649 /*
1650 * See the comments for linkmode_set_pause(), wrt the deficiencies
1651 * with the current implementation. A solution to this issue would
1652 * be:
1653 * ethtool Local device
1654 * rx tx Pause AsymDir
1655 * 0 0 0 0
1656 * 1 0 1 1
1657 * 0 1 0 1
1658 * 1 1 1 1
1659 * and then use the ethtool rx/tx enablement status to mask the
1660 * rx/tx pause resolution.
1661 */
1662 linkmode_set_pause(config->advertising, pause->tx_pause,
1663 pause->rx_pause);
1664
1665 manual_changed = (config->pause ^ pause_state) & MLO_PAUSE_AN ||
1666 (!(pause_state & MLO_PAUSE_AN) &&
1667 (config->pause ^ pause_state) & MLO_PAUSE_TXRX_MASK);
1668
1669 config->pause = pause_state;
1670
1671 /* Update our in-band advertisement, triggering a renegotiation if
1672 * the advertisement changed.
1673 */
1674 if (!pl->phydev)
1675 phylink_change_inband_advert(pl);
1676
1677 mutex_unlock(&pl->state_mutex);
1678
1679 /* If we have a PHY, a change of the pause frame advertisement will
1680 * cause phylib to renegotiate (if AN is enabled) which will in turn
1681 * call our phylink_phy_change() and trigger a resolve. Note that
1682 * we can't hold our state mutex while calling phy_set_asym_pause().
1683 */
1684 if (pl->phydev)
1685 phy_set_asym_pause(pl->phydev, pause->rx_pause,
1686 pause->tx_pause);
1687
1688 /* If the manual pause settings changed, make sure we trigger a
1689 * resolve to update their state; we can not guarantee that the
1690 * link will cycle.
1691 */
1692 if (manual_changed) {
1693 pl->mac_link_dropped = true;
1694 phylink_run_resolve(pl);
1695 }
1696
1697 return 0;
1698 }
1699 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam);
1700
1701 /**
1702 * phylink_ethtool_get_eee_err() - read the energy efficient ethernet error
1703 * counter
1704 * @pl: a pointer to a &struct phylink returned from phylink_create().
1705 *
1706 * Read the Energy Efficient Ethernet error counter from the PHY associated
1707 * with the phylink instance specified by @pl.
1708 *
1709 * Returns positive error counter value, or negative error code.
1710 */
phylink_get_eee_err(struct phylink * pl)1711 int phylink_get_eee_err(struct phylink *pl)
1712 {
1713 int ret = 0;
1714
1715 ASSERT_RTNL();
1716
1717 if (pl->phydev)
1718 ret = phy_get_eee_err(pl->phydev);
1719
1720 return ret;
1721 }
1722 EXPORT_SYMBOL_GPL(phylink_get_eee_err);
1723
1724 /**
1725 * phylink_init_eee() - init and check the EEE features
1726 * @pl: a pointer to a &struct phylink returned from phylink_create()
1727 * @clk_stop_enable: allow PHY to stop receive clock
1728 *
1729 * Must be called either with RTNL held or within mac_link_up()
1730 */
phylink_init_eee(struct phylink * pl,bool clk_stop_enable)1731 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable)
1732 {
1733 int ret = -EOPNOTSUPP;
1734
1735 if (pl->phydev)
1736 ret = phy_init_eee(pl->phydev, clk_stop_enable);
1737
1738 return ret;
1739 }
1740 EXPORT_SYMBOL_GPL(phylink_init_eee);
1741
1742 /**
1743 * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters
1744 * @pl: a pointer to a &struct phylink returned from phylink_create()
1745 * @eee: a pointer to a &struct ethtool_eee for the read parameters
1746 */
phylink_ethtool_get_eee(struct phylink * pl,struct ethtool_eee * eee)1747 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee)
1748 {
1749 int ret = -EOPNOTSUPP;
1750
1751 ASSERT_RTNL();
1752
1753 if (pl->phydev)
1754 ret = phy_ethtool_get_eee(pl->phydev, eee);
1755
1756 return ret;
1757 }
1758 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee);
1759
1760 /**
1761 * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters
1762 * @pl: a pointer to a &struct phylink returned from phylink_create()
1763 * @eee: a pointer to a &struct ethtool_eee for the desired parameters
1764 */
phylink_ethtool_set_eee(struct phylink * pl,struct ethtool_eee * eee)1765 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee)
1766 {
1767 int ret = -EOPNOTSUPP;
1768
1769 ASSERT_RTNL();
1770
1771 if (pl->phydev)
1772 ret = phy_ethtool_set_eee(pl->phydev, eee);
1773
1774 return ret;
1775 }
1776 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee);
1777
1778 /* This emulates MII registers for a fixed-mode phy operating as per the
1779 * passed in state. "aneg" defines if we report negotiation is possible.
1780 *
1781 * FIXME: should deal with negotiation state too.
1782 */
phylink_mii_emul_read(unsigned int reg,struct phylink_link_state * state)1783 static int phylink_mii_emul_read(unsigned int reg,
1784 struct phylink_link_state *state)
1785 {
1786 struct fixed_phy_status fs;
1787 unsigned long *lpa = state->lp_advertising;
1788 int val;
1789
1790 fs.link = state->link;
1791 fs.speed = state->speed;
1792 fs.duplex = state->duplex;
1793 fs.pause = test_bit(ETHTOOL_LINK_MODE_Pause_BIT, lpa);
1794 fs.asym_pause = test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, lpa);
1795
1796 val = swphy_read_reg(reg, &fs);
1797 if (reg == MII_BMSR) {
1798 if (!state->an_complete)
1799 val &= ~BMSR_ANEGCOMPLETE;
1800 }
1801 return val;
1802 }
1803
phylink_phy_read(struct phylink * pl,unsigned int phy_id,unsigned int reg)1804 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id,
1805 unsigned int reg)
1806 {
1807 struct phy_device *phydev = pl->phydev;
1808 int prtad, devad;
1809
1810 if (mdio_phy_id_is_c45(phy_id)) {
1811 prtad = mdio_phy_id_prtad(phy_id);
1812 devad = mdio_phy_id_devad(phy_id);
1813 devad = mdiobus_c45_addr(devad, reg);
1814 } else if (phydev->is_c45) {
1815 switch (reg) {
1816 case MII_BMCR:
1817 case MII_BMSR:
1818 case MII_PHYSID1:
1819 case MII_PHYSID2:
1820 devad = __ffs(phydev->c45_ids.mmds_present);
1821 break;
1822 case MII_ADVERTISE:
1823 case MII_LPA:
1824 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN))
1825 return -EINVAL;
1826 devad = MDIO_MMD_AN;
1827 if (reg == MII_ADVERTISE)
1828 reg = MDIO_AN_ADVERTISE;
1829 else
1830 reg = MDIO_AN_LPA;
1831 break;
1832 default:
1833 return -EINVAL;
1834 }
1835 prtad = phy_id;
1836 devad = mdiobus_c45_addr(devad, reg);
1837 } else {
1838 prtad = phy_id;
1839 devad = reg;
1840 }
1841 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad);
1842 }
1843
phylink_phy_write(struct phylink * pl,unsigned int phy_id,unsigned int reg,unsigned int val)1844 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id,
1845 unsigned int reg, unsigned int val)
1846 {
1847 struct phy_device *phydev = pl->phydev;
1848 int prtad, devad;
1849
1850 if (mdio_phy_id_is_c45(phy_id)) {
1851 prtad = mdio_phy_id_prtad(phy_id);
1852 devad = mdio_phy_id_devad(phy_id);
1853 devad = mdiobus_c45_addr(devad, reg);
1854 } else if (phydev->is_c45) {
1855 switch (reg) {
1856 case MII_BMCR:
1857 case MII_BMSR:
1858 case MII_PHYSID1:
1859 case MII_PHYSID2:
1860 devad = __ffs(phydev->c45_ids.mmds_present);
1861 break;
1862 case MII_ADVERTISE:
1863 case MII_LPA:
1864 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN))
1865 return -EINVAL;
1866 devad = MDIO_MMD_AN;
1867 if (reg == MII_ADVERTISE)
1868 reg = MDIO_AN_ADVERTISE;
1869 else
1870 reg = MDIO_AN_LPA;
1871 break;
1872 default:
1873 return -EINVAL;
1874 }
1875 prtad = phy_id;
1876 devad = mdiobus_c45_addr(devad, reg);
1877 } else {
1878 prtad = phy_id;
1879 devad = reg;
1880 }
1881
1882 return mdiobus_write(phydev->mdio.bus, prtad, devad, val);
1883 }
1884
phylink_mii_read(struct phylink * pl,unsigned int phy_id,unsigned int reg)1885 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id,
1886 unsigned int reg)
1887 {
1888 struct phylink_link_state state;
1889 int val = 0xffff;
1890
1891 switch (pl->cur_link_an_mode) {
1892 case MLO_AN_FIXED:
1893 if (phy_id == 0) {
1894 phylink_get_fixed_state(pl, &state);
1895 val = phylink_mii_emul_read(reg, &state);
1896 }
1897 break;
1898
1899 case MLO_AN_PHY:
1900 return -EOPNOTSUPP;
1901
1902 case MLO_AN_INBAND:
1903 if (phy_id == 0) {
1904 phylink_mac_pcs_get_state(pl, &state);
1905 val = phylink_mii_emul_read(reg, &state);
1906 }
1907 break;
1908 }
1909
1910 return val & 0xffff;
1911 }
1912
phylink_mii_write(struct phylink * pl,unsigned int phy_id,unsigned int reg,unsigned int val)1913 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id,
1914 unsigned int reg, unsigned int val)
1915 {
1916 switch (pl->cur_link_an_mode) {
1917 case MLO_AN_FIXED:
1918 break;
1919
1920 case MLO_AN_PHY:
1921 return -EOPNOTSUPP;
1922
1923 case MLO_AN_INBAND:
1924 break;
1925 }
1926
1927 return 0;
1928 }
1929
1930 /**
1931 * phylink_mii_ioctl() - generic mii ioctl interface
1932 * @pl: a pointer to a &struct phylink returned from phylink_create()
1933 * @ifr: a pointer to a &struct ifreq for socket ioctls
1934 * @cmd: ioctl cmd to execute
1935 *
1936 * Perform the specified MII ioctl on the PHY attached to the phylink instance
1937 * specified by @pl. If no PHY is attached, emulate the presence of the PHY.
1938 *
1939 * Returns: zero on success or negative error code.
1940 *
1941 * %SIOCGMIIPHY:
1942 * read register from the current PHY.
1943 * %SIOCGMIIREG:
1944 * read register from the specified PHY.
1945 * %SIOCSMIIREG:
1946 * set a register on the specified PHY.
1947 */
phylink_mii_ioctl(struct phylink * pl,struct ifreq * ifr,int cmd)1948 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)
1949 {
1950 struct mii_ioctl_data *mii = if_mii(ifr);
1951 int ret;
1952
1953 ASSERT_RTNL();
1954
1955 if (pl->phydev) {
1956 /* PHYs only exist for MLO_AN_PHY and SGMII */
1957 switch (cmd) {
1958 case SIOCGMIIPHY:
1959 mii->phy_id = pl->phydev->mdio.addr;
1960 fallthrough;
1961
1962 case SIOCGMIIREG:
1963 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num);
1964 if (ret >= 0) {
1965 mii->val_out = ret;
1966 ret = 0;
1967 }
1968 break;
1969
1970 case SIOCSMIIREG:
1971 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num,
1972 mii->val_in);
1973 break;
1974
1975 default:
1976 ret = phy_mii_ioctl(pl->phydev, ifr, cmd);
1977 break;
1978 }
1979 } else {
1980 switch (cmd) {
1981 case SIOCGMIIPHY:
1982 mii->phy_id = 0;
1983 fallthrough;
1984
1985 case SIOCGMIIREG:
1986 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num);
1987 if (ret >= 0) {
1988 mii->val_out = ret;
1989 ret = 0;
1990 }
1991 break;
1992
1993 case SIOCSMIIREG:
1994 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num,
1995 mii->val_in);
1996 break;
1997
1998 default:
1999 ret = -EOPNOTSUPP;
2000 break;
2001 }
2002 }
2003
2004 return ret;
2005 }
2006 EXPORT_SYMBOL_GPL(phylink_mii_ioctl);
2007
2008 /**
2009 * phylink_speed_down() - set the non-SFP PHY to lowest speed supported by both
2010 * link partners
2011 * @pl: a pointer to a &struct phylink returned from phylink_create()
2012 * @sync: perform action synchronously
2013 *
2014 * If we have a PHY that is not part of a SFP module, then set the speed
2015 * as described in the phy_speed_down() function. Please see this function
2016 * for a description of the @sync parameter.
2017 *
2018 * Returns zero if there is no PHY, otherwise as per phy_speed_down().
2019 */
phylink_speed_down(struct phylink * pl,bool sync)2020 int phylink_speed_down(struct phylink *pl, bool sync)
2021 {
2022 int ret = 0;
2023
2024 ASSERT_RTNL();
2025
2026 if (!pl->sfp_bus && pl->phydev)
2027 ret = phy_speed_down(pl->phydev, sync);
2028
2029 return ret;
2030 }
2031 EXPORT_SYMBOL_GPL(phylink_speed_down);
2032
2033 /**
2034 * phylink_speed_up() - restore the advertised speeds prior to the call to
2035 * phylink_speed_down()
2036 * @pl: a pointer to a &struct phylink returned from phylink_create()
2037 *
2038 * If we have a PHY that is not part of a SFP module, then restore the
2039 * PHY speeds as per phy_speed_up().
2040 *
2041 * Returns zero if there is no PHY, otherwise as per phy_speed_up().
2042 */
phylink_speed_up(struct phylink * pl)2043 int phylink_speed_up(struct phylink *pl)
2044 {
2045 int ret = 0;
2046
2047 ASSERT_RTNL();
2048
2049 if (!pl->sfp_bus && pl->phydev)
2050 ret = phy_speed_up(pl->phydev);
2051
2052 return ret;
2053 }
2054 EXPORT_SYMBOL_GPL(phylink_speed_up);
2055
phylink_sfp_attach(void * upstream,struct sfp_bus * bus)2056 static void phylink_sfp_attach(void *upstream, struct sfp_bus *bus)
2057 {
2058 struct phylink *pl = upstream;
2059
2060 pl->netdev->sfp_bus = bus;
2061 }
2062
phylink_sfp_detach(void * upstream,struct sfp_bus * bus)2063 static void phylink_sfp_detach(void *upstream, struct sfp_bus *bus)
2064 {
2065 struct phylink *pl = upstream;
2066
2067 pl->netdev->sfp_bus = NULL;
2068 }
2069
phylink_sfp_config(struct phylink * pl,u8 mode,const unsigned long * supported,const unsigned long * advertising)2070 static int phylink_sfp_config(struct phylink *pl, u8 mode,
2071 const unsigned long *supported,
2072 const unsigned long *advertising)
2073 {
2074 __ETHTOOL_DECLARE_LINK_MODE_MASK(support1);
2075 __ETHTOOL_DECLARE_LINK_MODE_MASK(support);
2076 struct phylink_link_state config;
2077 phy_interface_t iface;
2078 bool changed;
2079 int ret;
2080
2081 linkmode_copy(support, supported);
2082
2083 memset(&config, 0, sizeof(config));
2084 linkmode_copy(config.advertising, advertising);
2085 config.interface = PHY_INTERFACE_MODE_NA;
2086 config.speed = SPEED_UNKNOWN;
2087 config.duplex = DUPLEX_UNKNOWN;
2088 config.pause = MLO_PAUSE_AN;
2089 config.an_enabled = pl->link_config.an_enabled;
2090
2091 /* Ignore errors if we're expecting a PHY to attach later */
2092 ret = phylink_validate(pl, support, &config);
2093 if (ret) {
2094 phylink_err(pl, "validation with support %*pb failed: %d\n",
2095 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret);
2096 return ret;
2097 }
2098
2099 iface = sfp_select_interface(pl->sfp_bus, config.advertising);
2100 if (iface == PHY_INTERFACE_MODE_NA) {
2101 phylink_err(pl,
2102 "selection of interface failed, advertisement %*pb\n",
2103 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising);
2104 return -EINVAL;
2105 }
2106
2107 config.interface = iface;
2108 linkmode_copy(support1, support);
2109 ret = phylink_validate(pl, support1, &config);
2110 if (ret) {
2111 phylink_err(pl, "validation of %s/%s with support %*pb failed: %d\n",
2112 phylink_an_mode_str(mode),
2113 phy_modes(config.interface),
2114 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret);
2115 return ret;
2116 }
2117
2118 phylink_dbg(pl, "requesting link mode %s/%s with support %*pb\n",
2119 phylink_an_mode_str(mode), phy_modes(config.interface),
2120 __ETHTOOL_LINK_MODE_MASK_NBITS, support);
2121
2122 if (phy_interface_mode_is_8023z(iface) && pl->phydev)
2123 return -EINVAL;
2124
2125 changed = !linkmode_equal(pl->supported, support) ||
2126 !linkmode_equal(pl->link_config.advertising,
2127 config.advertising);
2128 if (changed) {
2129 linkmode_copy(pl->supported, support);
2130 linkmode_copy(pl->link_config.advertising, config.advertising);
2131 }
2132
2133 if (pl->cur_link_an_mode != mode ||
2134 pl->link_config.interface != config.interface) {
2135 pl->link_config.interface = config.interface;
2136 pl->cur_link_an_mode = mode;
2137
2138 changed = true;
2139
2140 phylink_info(pl, "switched to %s/%s link mode\n",
2141 phylink_an_mode_str(mode),
2142 phy_modes(config.interface));
2143 }
2144
2145 pl->link_port = pl->sfp_port;
2146
2147 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED,
2148 &pl->phylink_disable_state))
2149 phylink_mac_initial_config(pl, false);
2150
2151 return ret;
2152 }
2153
phylink_sfp_module_insert(void * upstream,const struct sfp_eeprom_id * id)2154 static int phylink_sfp_module_insert(void *upstream,
2155 const struct sfp_eeprom_id *id)
2156 {
2157 struct phylink *pl = upstream;
2158 unsigned long *support = pl->sfp_support;
2159
2160 ASSERT_RTNL();
2161
2162 linkmode_zero(support);
2163 sfp_parse_support(pl->sfp_bus, id, support);
2164 pl->sfp_port = sfp_parse_port(pl->sfp_bus, id, support);
2165
2166 /* If this module may have a PHY connecting later, defer until later */
2167 pl->sfp_may_have_phy = sfp_may_have_phy(pl->sfp_bus, id);
2168 if (pl->sfp_may_have_phy)
2169 return 0;
2170
2171 return phylink_sfp_config(pl, MLO_AN_INBAND, support, support);
2172 }
2173
phylink_sfp_module_start(void * upstream)2174 static int phylink_sfp_module_start(void *upstream)
2175 {
2176 struct phylink *pl = upstream;
2177
2178 /* If this SFP module has a PHY, start the PHY now. */
2179 if (pl->phydev) {
2180 phy_start(pl->phydev);
2181 return 0;
2182 }
2183
2184 /* If the module may have a PHY but we didn't detect one we
2185 * need to configure the MAC here.
2186 */
2187 if (!pl->sfp_may_have_phy)
2188 return 0;
2189
2190 return phylink_sfp_config(pl, MLO_AN_INBAND,
2191 pl->sfp_support, pl->sfp_support);
2192 }
2193
phylink_sfp_module_stop(void * upstream)2194 static void phylink_sfp_module_stop(void *upstream)
2195 {
2196 struct phylink *pl = upstream;
2197
2198 /* If this SFP module has a PHY, stop it. */
2199 if (pl->phydev)
2200 phy_stop(pl->phydev);
2201 }
2202
phylink_sfp_link_down(void * upstream)2203 static void phylink_sfp_link_down(void *upstream)
2204 {
2205 struct phylink *pl = upstream;
2206
2207 ASSERT_RTNL();
2208
2209 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_LINK);
2210 }
2211
phylink_sfp_link_up(void * upstream)2212 static void phylink_sfp_link_up(void *upstream)
2213 {
2214 struct phylink *pl = upstream;
2215
2216 ASSERT_RTNL();
2217
2218 clear_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state);
2219 phylink_run_resolve(pl);
2220 }
2221
2222 /* The Broadcom BCM84881 in the Methode DM7052 is unable to provide a SGMII
2223 * or 802.3z control word, so inband will not work.
2224 */
phylink_phy_no_inband(struct phy_device * phy)2225 static bool phylink_phy_no_inband(struct phy_device *phy)
2226 {
2227 return phy->is_c45 &&
2228 (phy->c45_ids.device_ids[1] & 0xfffffff0) == 0xae025150;
2229 }
2230
phylink_sfp_connect_phy(void * upstream,struct phy_device * phy)2231 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy)
2232 {
2233 struct phylink *pl = upstream;
2234 phy_interface_t interface;
2235 u8 mode;
2236 int ret;
2237
2238 /*
2239 * This is the new way of dealing with flow control for PHYs,
2240 * as described by Timur Tabi in commit 529ed1275263 ("net: phy:
2241 * phy drivers should not set SUPPORTED_[Asym_]Pause") except
2242 * using our validate call to the MAC, we rely upon the MAC
2243 * clearing the bits from both supported and advertising fields.
2244 */
2245 phy_support_asym_pause(phy);
2246
2247 if (phylink_phy_no_inband(phy))
2248 mode = MLO_AN_PHY;
2249 else
2250 mode = MLO_AN_INBAND;
2251
2252 /* Do the initial configuration */
2253 ret = phylink_sfp_config(pl, mode, phy->supported, phy->advertising);
2254 if (ret < 0)
2255 return ret;
2256
2257 interface = pl->link_config.interface;
2258 ret = phylink_attach_phy(pl, phy, interface);
2259 if (ret < 0)
2260 return ret;
2261
2262 ret = phylink_bringup_phy(pl, phy, interface);
2263 if (ret)
2264 phy_detach(phy);
2265
2266 return ret;
2267 }
2268
phylink_sfp_disconnect_phy(void * upstream)2269 static void phylink_sfp_disconnect_phy(void *upstream)
2270 {
2271 phylink_disconnect_phy(upstream);
2272 }
2273
2274 static const struct sfp_upstream_ops sfp_phylink_ops = {
2275 .attach = phylink_sfp_attach,
2276 .detach = phylink_sfp_detach,
2277 .module_insert = phylink_sfp_module_insert,
2278 .module_start = phylink_sfp_module_start,
2279 .module_stop = phylink_sfp_module_stop,
2280 .link_up = phylink_sfp_link_up,
2281 .link_down = phylink_sfp_link_down,
2282 .connect_phy = phylink_sfp_connect_phy,
2283 .disconnect_phy = phylink_sfp_disconnect_phy,
2284 };
2285
2286 /* Helpers for MAC drivers */
2287
2288 /**
2289 * phylink_helper_basex_speed() - 1000BaseX/2500BaseX helper
2290 * @state: a pointer to a &struct phylink_link_state
2291 *
2292 * Inspect the interface mode, advertising mask or forced speed and
2293 * decide whether to run at 2.5Gbit or 1Gbit appropriately, switching
2294 * the interface mode to suit. @state->interface is appropriately
2295 * updated, and the advertising mask has the "other" baseX_Full flag
2296 * cleared.
2297 */
phylink_helper_basex_speed(struct phylink_link_state * state)2298 void phylink_helper_basex_speed(struct phylink_link_state *state)
2299 {
2300 if (phy_interface_mode_is_8023z(state->interface)) {
2301 bool want_2500 = state->an_enabled ?
2302 phylink_test(state->advertising, 2500baseX_Full) :
2303 state->speed == SPEED_2500;
2304
2305 if (want_2500) {
2306 phylink_clear(state->advertising, 1000baseX_Full);
2307 state->interface = PHY_INTERFACE_MODE_2500BASEX;
2308 } else {
2309 phylink_clear(state->advertising, 2500baseX_Full);
2310 state->interface = PHY_INTERFACE_MODE_1000BASEX;
2311 }
2312 }
2313 }
2314 EXPORT_SYMBOL_GPL(phylink_helper_basex_speed);
2315
phylink_decode_c37_word(struct phylink_link_state * state,uint16_t config_reg,int speed)2316 static void phylink_decode_c37_word(struct phylink_link_state *state,
2317 uint16_t config_reg, int speed)
2318 {
2319 bool tx_pause, rx_pause;
2320 int fd_bit;
2321
2322 if (speed == SPEED_2500)
2323 fd_bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT;
2324 else
2325 fd_bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT;
2326
2327 mii_lpa_mod_linkmode_x(state->lp_advertising, config_reg, fd_bit);
2328
2329 if (linkmode_test_bit(fd_bit, state->advertising) &&
2330 linkmode_test_bit(fd_bit, state->lp_advertising)) {
2331 state->speed = speed;
2332 state->duplex = DUPLEX_FULL;
2333 } else {
2334 /* negotiation failure */
2335 state->link = false;
2336 }
2337
2338 linkmode_resolve_pause(state->advertising, state->lp_advertising,
2339 &tx_pause, &rx_pause);
2340
2341 if (tx_pause)
2342 state->pause |= MLO_PAUSE_TX;
2343 if (rx_pause)
2344 state->pause |= MLO_PAUSE_RX;
2345 }
2346
phylink_decode_sgmii_word(struct phylink_link_state * state,uint16_t config_reg)2347 static void phylink_decode_sgmii_word(struct phylink_link_state *state,
2348 uint16_t config_reg)
2349 {
2350 if (!(config_reg & LPA_SGMII_LINK)) {
2351 state->link = false;
2352 return;
2353 }
2354
2355 switch (config_reg & LPA_SGMII_SPD_MASK) {
2356 case LPA_SGMII_10:
2357 state->speed = SPEED_10;
2358 break;
2359 case LPA_SGMII_100:
2360 state->speed = SPEED_100;
2361 break;
2362 case LPA_SGMII_1000:
2363 state->speed = SPEED_1000;
2364 break;
2365 default:
2366 state->link = false;
2367 return;
2368 }
2369 if (config_reg & LPA_SGMII_FULL_DUPLEX)
2370 state->duplex = DUPLEX_FULL;
2371 else
2372 state->duplex = DUPLEX_HALF;
2373 }
2374
2375 /**
2376 * phylink_decode_usxgmii_word() - decode the USXGMII word from a MAC PCS
2377 * @state: a pointer to a struct phylink_link_state.
2378 * @lpa: a 16 bit value which stores the USXGMII auto-negotiation word
2379 *
2380 * Helper for MAC PCS supporting the USXGMII protocol and the auto-negotiation
2381 * code word. Decode the USXGMII code word and populate the corresponding fields
2382 * (speed, duplex) into the phylink_link_state structure.
2383 */
phylink_decode_usxgmii_word(struct phylink_link_state * state,uint16_t lpa)2384 void phylink_decode_usxgmii_word(struct phylink_link_state *state,
2385 uint16_t lpa)
2386 {
2387 switch (lpa & MDIO_USXGMII_SPD_MASK) {
2388 case MDIO_USXGMII_10:
2389 state->speed = SPEED_10;
2390 break;
2391 case MDIO_USXGMII_100:
2392 state->speed = SPEED_100;
2393 break;
2394 case MDIO_USXGMII_1000:
2395 state->speed = SPEED_1000;
2396 break;
2397 case MDIO_USXGMII_2500:
2398 state->speed = SPEED_2500;
2399 break;
2400 case MDIO_USXGMII_5000:
2401 state->speed = SPEED_5000;
2402 break;
2403 case MDIO_USXGMII_10G:
2404 state->speed = SPEED_10000;
2405 break;
2406 default:
2407 state->link = false;
2408 return;
2409 }
2410
2411 if (lpa & MDIO_USXGMII_FULL_DUPLEX)
2412 state->duplex = DUPLEX_FULL;
2413 else
2414 state->duplex = DUPLEX_HALF;
2415 }
2416 EXPORT_SYMBOL_GPL(phylink_decode_usxgmii_word);
2417
2418 /**
2419 * phylink_mii_c22_pcs_get_state() - read the MAC PCS state
2420 * @pcs: a pointer to a &struct mdio_device.
2421 * @state: a pointer to a &struct phylink_link_state.
2422 *
2423 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
2424 * clause 37 negotiation and/or SGMII control.
2425 *
2426 * Read the MAC PCS state from the MII device configured in @config and
2427 * parse the Clause 37 or Cisco SGMII link partner negotiation word into
2428 * the phylink @state structure. This is suitable to be directly plugged
2429 * into the mac_pcs_get_state() member of the struct phylink_mac_ops
2430 * structure.
2431 */
phylink_mii_c22_pcs_get_state(struct mdio_device * pcs,struct phylink_link_state * state)2432 void phylink_mii_c22_pcs_get_state(struct mdio_device *pcs,
2433 struct phylink_link_state *state)
2434 {
2435 struct mii_bus *bus = pcs->bus;
2436 int addr = pcs->addr;
2437 int bmsr, lpa;
2438
2439 bmsr = mdiobus_read(bus, addr, MII_BMSR);
2440 lpa = mdiobus_read(bus, addr, MII_LPA);
2441 if (bmsr < 0 || lpa < 0) {
2442 state->link = false;
2443 return;
2444 }
2445
2446 state->link = !!(bmsr & BMSR_LSTATUS);
2447 state->an_complete = !!(bmsr & BMSR_ANEGCOMPLETE);
2448 if (!state->link)
2449 return;
2450
2451 switch (state->interface) {
2452 case PHY_INTERFACE_MODE_1000BASEX:
2453 phylink_decode_c37_word(state, lpa, SPEED_1000);
2454 break;
2455
2456 case PHY_INTERFACE_MODE_2500BASEX:
2457 phylink_decode_c37_word(state, lpa, SPEED_2500);
2458 break;
2459
2460 case PHY_INTERFACE_MODE_SGMII:
2461 case PHY_INTERFACE_MODE_QSGMII:
2462 phylink_decode_sgmii_word(state, lpa);
2463 break;
2464
2465 default:
2466 state->link = false;
2467 break;
2468 }
2469 }
2470 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_get_state);
2471
2472 /**
2473 * phylink_mii_c22_pcs_set_advertisement() - configure the clause 37 PCS
2474 * advertisement
2475 * @pcs: a pointer to a &struct mdio_device.
2476 * @interface: the PHY interface mode being configured
2477 * @advertising: the ethtool advertisement mask
2478 *
2479 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
2480 * clause 37 negotiation and/or SGMII control.
2481 *
2482 * Configure the clause 37 PCS advertisement as specified by @state. This
2483 * does not trigger a renegotiation; phylink will do that via the
2484 * mac_an_restart() method of the struct phylink_mac_ops structure.
2485 *
2486 * Returns negative error code on failure to configure the advertisement,
2487 * zero if no change has been made, or one if the advertisement has changed.
2488 */
phylink_mii_c22_pcs_set_advertisement(struct mdio_device * pcs,phy_interface_t interface,const unsigned long * advertising)2489 int phylink_mii_c22_pcs_set_advertisement(struct mdio_device *pcs,
2490 phy_interface_t interface,
2491 const unsigned long *advertising)
2492 {
2493 struct mii_bus *bus = pcs->bus;
2494 int addr = pcs->addr;
2495 int val, ret;
2496 u16 adv;
2497
2498 switch (interface) {
2499 case PHY_INTERFACE_MODE_1000BASEX:
2500 case PHY_INTERFACE_MODE_2500BASEX:
2501 adv = ADVERTISE_1000XFULL;
2502 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2503 advertising))
2504 adv |= ADVERTISE_1000XPAUSE;
2505 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2506 advertising))
2507 adv |= ADVERTISE_1000XPSE_ASYM;
2508
2509 val = mdiobus_read(bus, addr, MII_ADVERTISE);
2510 if (val < 0)
2511 return val;
2512
2513 if (val == adv)
2514 return 0;
2515
2516 ret = mdiobus_write(bus, addr, MII_ADVERTISE, adv);
2517 if (ret < 0)
2518 return ret;
2519
2520 return 1;
2521
2522 case PHY_INTERFACE_MODE_SGMII:
2523 val = mdiobus_read(bus, addr, MII_ADVERTISE);
2524 if (val < 0)
2525 return val;
2526
2527 if (val == 0x0001)
2528 return 0;
2529
2530 ret = mdiobus_write(bus, addr, MII_ADVERTISE, 0x0001);
2531 if (ret < 0)
2532 return ret;
2533
2534 return 1;
2535
2536 default:
2537 /* Nothing to do for other modes */
2538 return 0;
2539 }
2540 }
2541 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_set_advertisement);
2542
2543 /**
2544 * phylink_mii_c22_pcs_config() - configure clause 22 PCS
2545 * @pcs: a pointer to a &struct mdio_device.
2546 * @mode: link autonegotiation mode
2547 * @interface: the PHY interface mode being configured
2548 * @advertising: the ethtool advertisement mask
2549 *
2550 * Configure a Clause 22 PCS PHY with the appropriate negotiation
2551 * parameters for the @mode, @interface and @advertising parameters.
2552 * Returns negative error number on failure, zero if the advertisement
2553 * has not changed, or positive if there is a change.
2554 */
phylink_mii_c22_pcs_config(struct mdio_device * pcs,unsigned int mode,phy_interface_t interface,const unsigned long * advertising)2555 int phylink_mii_c22_pcs_config(struct mdio_device *pcs, unsigned int mode,
2556 phy_interface_t interface,
2557 const unsigned long *advertising)
2558 {
2559 bool changed;
2560 u16 bmcr;
2561 int ret;
2562
2563 ret = phylink_mii_c22_pcs_set_advertisement(pcs, interface,
2564 advertising);
2565 if (ret < 0)
2566 return ret;
2567
2568 changed = ret > 0;
2569
2570 bmcr = mode == MLO_AN_INBAND ? BMCR_ANENABLE : 0;
2571 ret = mdiobus_modify(pcs->bus, pcs->addr, MII_BMCR,
2572 BMCR_ANENABLE, bmcr);
2573 if (ret < 0)
2574 return ret;
2575
2576 return changed ? 1 : 0;
2577 }
2578 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_config);
2579
2580 /**
2581 * phylink_mii_c22_pcs_an_restart() - restart 802.3z autonegotiation
2582 * @pcs: a pointer to a &struct mdio_device.
2583 *
2584 * Helper for MAC PCS supporting the 802.3 clause 22 register set for
2585 * clause 37 negotiation.
2586 *
2587 * Restart the clause 37 negotiation with the link partner. This is
2588 * suitable to be directly plugged into the mac_pcs_get_state() member
2589 * of the struct phylink_mac_ops structure.
2590 */
phylink_mii_c22_pcs_an_restart(struct mdio_device * pcs)2591 void phylink_mii_c22_pcs_an_restart(struct mdio_device *pcs)
2592 {
2593 struct mii_bus *bus = pcs->bus;
2594 int val, addr = pcs->addr;
2595
2596 val = mdiobus_read(bus, addr, MII_BMCR);
2597 if (val >= 0) {
2598 val |= BMCR_ANRESTART;
2599
2600 mdiobus_write(bus, addr, MII_BMCR, val);
2601 }
2602 }
2603 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_an_restart);
2604
phylink_mii_c45_pcs_get_state(struct mdio_device * pcs,struct phylink_link_state * state)2605 void phylink_mii_c45_pcs_get_state(struct mdio_device *pcs,
2606 struct phylink_link_state *state)
2607 {
2608 struct mii_bus *bus = pcs->bus;
2609 int addr = pcs->addr;
2610 int stat;
2611
2612 stat = mdiobus_c45_read(bus, addr, MDIO_MMD_PCS, MDIO_STAT1);
2613 if (stat < 0) {
2614 state->link = false;
2615 return;
2616 }
2617
2618 state->link = !!(stat & MDIO_STAT1_LSTATUS);
2619 if (!state->link)
2620 return;
2621
2622 switch (state->interface) {
2623 case PHY_INTERFACE_MODE_10GBASER:
2624 state->speed = SPEED_10000;
2625 state->duplex = DUPLEX_FULL;
2626 break;
2627
2628 default:
2629 break;
2630 }
2631 }
2632 EXPORT_SYMBOL_GPL(phylink_mii_c45_pcs_get_state);
2633
2634 MODULE_LICENSE("GPL v2");
2635