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/acpi.h> 9 #include <linux/ethtool.h> 10 #include <linux/export.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/netdevice.h> 13 #include <linux/of.h> 14 #include <linux/of_mdio.h> 15 #include <linux/phy.h> 16 #include <linux/phy_fixed.h> 17 #include <linux/phylink.h> 18 #include <linux/rtnetlink.h> 19 #include <linux/spinlock.h> 20 #include <linux/timer.h> 21 #include <linux/workqueue.h> 22 23 #include "phy-caps.h" 24 #include "sfp.h" 25 #include "swphy.h" 26 27 #define SUPPORTED_INTERFACES \ 28 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \ 29 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane) 30 #define ADVERTISED_INTERFACES \ 31 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \ 32 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane) 33 34 enum { 35 PHYLINK_DISABLE_STOPPED, 36 PHYLINK_DISABLE_LINK, 37 PHYLINK_DISABLE_MAC_WOL, 38 39 PCS_STATE_DOWN = 0, 40 PCS_STATE_STARTING, 41 PCS_STATE_STARTED, 42 }; 43 44 /** 45 * struct phylink - internal data type for phylink 46 */ 47 struct phylink { 48 /* private: */ 49 struct net_device *netdev; 50 const struct phylink_mac_ops *mac_ops; 51 struct phylink_config *config; 52 struct phylink_pcs *pcs; 53 struct device *dev; 54 unsigned int old_link_state:1; 55 56 unsigned long phylink_disable_state; /* bitmask of disables */ 57 struct phy_device *phydev; 58 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */ 59 u8 cfg_link_an_mode; /* MLO_AN_xxx */ 60 u8 req_link_an_mode; /* Requested MLO_AN_xxx mode */ 61 u8 act_link_an_mode; /* Active MLO_AN_xxx mode */ 62 u8 link_port; /* The current non-phy ethtool port */ 63 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 64 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported_lpi); 65 66 /* The link configuration settings */ 67 struct phylink_link_state link_config; 68 69 /* The current settings */ 70 phy_interface_t cur_interface; 71 72 struct gpio_desc *link_gpio; 73 unsigned int link_irq; 74 struct timer_list link_poll; 75 76 struct mutex state_mutex; 77 struct phylink_link_state phy_state; 78 unsigned int phy_ib_mode; 79 struct work_struct resolve; 80 unsigned int pcs_neg_mode; 81 unsigned int pcs_state; 82 83 bool link_failed; 84 bool suspend_link_up; 85 bool major_config_failed; 86 bool mac_supports_eee_ops; 87 bool mac_supports_eee; 88 bool phy_enable_tx_lpi; 89 bool mac_enable_tx_lpi; 90 bool mac_tx_clk_stop; 91 u32 mac_tx_lpi_timer; 92 u8 mac_rx_clk_stop_blocked; 93 94 struct sfp_bus *sfp_bus; 95 bool sfp_may_have_phy; 96 DECLARE_PHY_INTERFACE_MASK(sfp_interfaces); 97 __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support); 98 u8 sfp_port; 99 100 struct eee_config eee_cfg; 101 }; 102 103 #define phylink_printk(level, pl, fmt, ...) \ 104 do { \ 105 if ((pl)->config->type == PHYLINK_NETDEV) \ 106 netdev_printk(level, (pl)->netdev, fmt, ##__VA_ARGS__); \ 107 else if ((pl)->config->type == PHYLINK_DEV) \ 108 dev_printk(level, (pl)->dev, fmt, ##__VA_ARGS__); \ 109 } while (0) 110 111 #define phylink_err(pl, fmt, ...) \ 112 phylink_printk(KERN_ERR, pl, fmt, ##__VA_ARGS__) 113 #define phylink_warn(pl, fmt, ...) \ 114 phylink_printk(KERN_WARNING, pl, fmt, ##__VA_ARGS__) 115 #define phylink_info(pl, fmt, ...) \ 116 phylink_printk(KERN_INFO, pl, fmt, ##__VA_ARGS__) 117 #if defined(CONFIG_DYNAMIC_DEBUG) 118 #define phylink_dbg(pl, fmt, ...) \ 119 do { \ 120 if ((pl)->config->type == PHYLINK_NETDEV) \ 121 netdev_dbg((pl)->netdev, fmt, ##__VA_ARGS__); \ 122 else if ((pl)->config->type == PHYLINK_DEV) \ 123 dev_dbg((pl)->dev, fmt, ##__VA_ARGS__); \ 124 } while (0) 125 #elif defined(DEBUG) 126 #define phylink_dbg(pl, fmt, ...) \ 127 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__) 128 #else 129 #define phylink_dbg(pl, fmt, ...) \ 130 ({ \ 131 if (0) \ 132 phylink_printk(KERN_DEBUG, pl, fmt, ##__VA_ARGS__); \ 133 }) 134 #endif 135 136 static const phy_interface_t phylink_sfp_interface_preference[] = { 137 PHY_INTERFACE_MODE_25GBASER, 138 PHY_INTERFACE_MODE_USXGMII, 139 PHY_INTERFACE_MODE_10GBASER, 140 PHY_INTERFACE_MODE_5GBASER, 141 PHY_INTERFACE_MODE_2500BASEX, 142 PHY_INTERFACE_MODE_SGMII, 143 PHY_INTERFACE_MODE_1000BASEX, 144 PHY_INTERFACE_MODE_100BASEX, 145 }; 146 147 static DECLARE_PHY_INTERFACE_MASK(phylink_sfp_interfaces); 148 149 /** 150 * phylink_set_port_modes() - set the port type modes in the ethtool mask 151 * @mask: ethtool link mode mask 152 * 153 * Sets all the port type modes in the ethtool mask. MAC drivers should 154 * use this in their 'validate' callback. 155 */ 156 void phylink_set_port_modes(unsigned long *mask) 157 { 158 phylink_set(mask, TP); 159 phylink_set(mask, AUI); 160 phylink_set(mask, MII); 161 phylink_set(mask, FIBRE); 162 phylink_set(mask, BNC); 163 phylink_set(mask, Backplane); 164 } 165 EXPORT_SYMBOL_GPL(phylink_set_port_modes); 166 167 static int phylink_is_empty_linkmode(const unsigned long *linkmode) 168 { 169 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, }; 170 171 phylink_set_port_modes(tmp); 172 phylink_set(tmp, Autoneg); 173 phylink_set(tmp, Pause); 174 phylink_set(tmp, Asym_Pause); 175 176 return linkmode_subset(linkmode, tmp); 177 } 178 179 static const char *phylink_an_mode_str(unsigned int mode) 180 { 181 static const char *modestr[] = { 182 [MLO_AN_PHY] = "phy", 183 [MLO_AN_FIXED] = "fixed", 184 [MLO_AN_INBAND] = "inband", 185 }; 186 187 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown"; 188 } 189 190 static const char *phylink_pcs_mode_str(unsigned int mode) 191 { 192 if (!mode) 193 return "none"; 194 195 if (mode & PHYLINK_PCS_NEG_OUTBAND) 196 return "outband"; 197 198 if (mode & PHYLINK_PCS_NEG_INBAND) { 199 if (mode & PHYLINK_PCS_NEG_ENABLED) 200 return "inband,an-enabled"; 201 else 202 return "inband,an-disabled"; 203 } 204 205 return "unknown"; 206 } 207 208 static unsigned int phylink_interface_signal_rate(phy_interface_t interface) 209 { 210 switch (interface) { 211 case PHY_INTERFACE_MODE_SGMII: 212 case PHY_INTERFACE_MODE_1000BASEX: /* 1.25Mbd */ 213 return 1250; 214 case PHY_INTERFACE_MODE_2500BASEX: /* 3.125Mbd */ 215 return 3125; 216 case PHY_INTERFACE_MODE_5GBASER: /* 5.15625Mbd */ 217 return 5156; 218 case PHY_INTERFACE_MODE_10GBASER: /* 10.3125Mbd */ 219 return 10313; 220 default: 221 return 0; 222 } 223 } 224 225 /** 226 * phylink_interface_max_speed() - get the maximum speed of a phy interface 227 * @interface: phy interface mode defined by &typedef phy_interface_t 228 * 229 * Determine the maximum speed of a phy interface. This is intended to help 230 * determine the correct speed to pass to the MAC when the phy is performing 231 * rate matching. 232 * 233 * Return: The maximum speed of @interface 234 */ 235 static int phylink_interface_max_speed(phy_interface_t interface) 236 { 237 switch (interface) { 238 case PHY_INTERFACE_MODE_100BASEX: 239 case PHY_INTERFACE_MODE_REVRMII: 240 case PHY_INTERFACE_MODE_RMII: 241 case PHY_INTERFACE_MODE_SMII: 242 case PHY_INTERFACE_MODE_REVMII: 243 case PHY_INTERFACE_MODE_MII: 244 return SPEED_100; 245 246 case PHY_INTERFACE_MODE_TBI: 247 case PHY_INTERFACE_MODE_MOCA: 248 case PHY_INTERFACE_MODE_RTBI: 249 case PHY_INTERFACE_MODE_1000BASEX: 250 case PHY_INTERFACE_MODE_1000BASEKX: 251 case PHY_INTERFACE_MODE_TRGMII: 252 case PHY_INTERFACE_MODE_RGMII_TXID: 253 case PHY_INTERFACE_MODE_RGMII_RXID: 254 case PHY_INTERFACE_MODE_RGMII_ID: 255 case PHY_INTERFACE_MODE_RGMII: 256 case PHY_INTERFACE_MODE_PSGMII: 257 case PHY_INTERFACE_MODE_QSGMII: 258 case PHY_INTERFACE_MODE_QUSGMII: 259 case PHY_INTERFACE_MODE_SGMII: 260 case PHY_INTERFACE_MODE_GMII: 261 return SPEED_1000; 262 263 case PHY_INTERFACE_MODE_2500BASEX: 264 case PHY_INTERFACE_MODE_10G_QXGMII: 265 return SPEED_2500; 266 267 case PHY_INTERFACE_MODE_5GBASER: 268 return SPEED_5000; 269 270 case PHY_INTERFACE_MODE_XGMII: 271 case PHY_INTERFACE_MODE_RXAUI: 272 case PHY_INTERFACE_MODE_XAUI: 273 case PHY_INTERFACE_MODE_10GBASER: 274 case PHY_INTERFACE_MODE_10GKR: 275 case PHY_INTERFACE_MODE_USXGMII: 276 return SPEED_10000; 277 278 case PHY_INTERFACE_MODE_25GBASER: 279 return SPEED_25000; 280 281 case PHY_INTERFACE_MODE_XLGMII: 282 return SPEED_40000; 283 284 case PHY_INTERFACE_MODE_INTERNAL: 285 case PHY_INTERFACE_MODE_NA: 286 case PHY_INTERFACE_MODE_MAX: 287 /* No idea! Garbage in, unknown out */ 288 return SPEED_UNKNOWN; 289 } 290 291 /* If we get here, someone forgot to add an interface mode above */ 292 WARN_ON_ONCE(1); 293 return SPEED_UNKNOWN; 294 } 295 296 static struct { 297 unsigned long mask; 298 int speed; 299 unsigned int duplex; 300 unsigned int caps_bit; 301 } phylink_caps_params[] = { 302 { MAC_400000FD, SPEED_400000, DUPLEX_FULL, BIT(LINK_CAPA_400000FD) }, 303 { MAC_200000FD, SPEED_200000, DUPLEX_FULL, BIT(LINK_CAPA_200000FD) }, 304 { MAC_100000FD, SPEED_100000, DUPLEX_FULL, BIT(LINK_CAPA_100000FD) }, 305 { MAC_56000FD, SPEED_56000, DUPLEX_FULL, BIT(LINK_CAPA_56000FD) }, 306 { MAC_50000FD, SPEED_50000, DUPLEX_FULL, BIT(LINK_CAPA_50000FD) }, 307 { MAC_40000FD, SPEED_40000, DUPLEX_FULL, BIT(LINK_CAPA_40000FD) }, 308 { MAC_25000FD, SPEED_25000, DUPLEX_FULL, BIT(LINK_CAPA_25000FD) }, 309 { MAC_20000FD, SPEED_20000, DUPLEX_FULL, BIT(LINK_CAPA_20000FD) }, 310 { MAC_10000FD, SPEED_10000, DUPLEX_FULL, BIT(LINK_CAPA_10000FD) }, 311 { MAC_5000FD, SPEED_5000, DUPLEX_FULL, BIT(LINK_CAPA_5000FD) }, 312 { MAC_2500FD, SPEED_2500, DUPLEX_FULL, BIT(LINK_CAPA_2500FD) }, 313 { MAC_1000FD, SPEED_1000, DUPLEX_FULL, BIT(LINK_CAPA_1000FD) }, 314 { MAC_1000HD, SPEED_1000, DUPLEX_HALF, BIT(LINK_CAPA_1000HD) }, 315 { MAC_100FD, SPEED_100, DUPLEX_FULL, BIT(LINK_CAPA_100FD) }, 316 { MAC_100HD, SPEED_100, DUPLEX_HALF, BIT(LINK_CAPA_100HD) }, 317 { MAC_10FD, SPEED_10, DUPLEX_FULL, BIT(LINK_CAPA_10FD) }, 318 { MAC_10HD, SPEED_10, DUPLEX_HALF, BIT(LINK_CAPA_10HD) }, 319 }; 320 321 /** 322 * phylink_caps_to_link_caps() - Convert a set of MAC capabilities LINK caps 323 * @caps: A set of MAC capabilities 324 * 325 * Returns: The corresponding set of LINK_CAPA as defined in phy-caps.h 326 */ 327 static unsigned long phylink_caps_to_link_caps(unsigned long caps) 328 { 329 unsigned long link_caps = 0; 330 int i; 331 332 for (i = 0; i < ARRAY_SIZE(phylink_caps_params); i++) 333 if (caps & phylink_caps_params[i].mask) 334 link_caps |= phylink_caps_params[i].caps_bit; 335 336 return link_caps; 337 } 338 339 static unsigned long phylink_link_caps_to_mac_caps(unsigned long link_caps) 340 { 341 unsigned long caps = 0; 342 int i; 343 344 for (i = 0; i < ARRAY_SIZE(phylink_caps_params); i++) 345 if (link_caps & phylink_caps_params[i].caps_bit) 346 caps |= phylink_caps_params[i].mask; 347 348 return caps; 349 } 350 351 /** 352 * phylink_caps_to_linkmodes() - Convert capabilities to ethtool link modes 353 * @linkmodes: ethtool linkmode mask (must be already initialised) 354 * @caps: bitmask of MAC capabilities 355 * 356 * Set all possible pause, speed and duplex linkmodes in @linkmodes that are 357 * supported by the @caps. @linkmodes must have been initialised previously. 358 */ 359 static void phylink_caps_to_linkmodes(unsigned long *linkmodes, 360 unsigned long caps) 361 { 362 unsigned long link_caps = phylink_caps_to_link_caps(caps); 363 364 if (caps & MAC_SYM_PAUSE) 365 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT, linkmodes); 366 367 if (caps & MAC_ASYM_PAUSE) 368 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, linkmodes); 369 370 phy_caps_linkmodes(link_caps, linkmodes); 371 } 372 373 /** 374 * phylink_limit_mac_speed - limit the phylink_config to a maximum speed 375 * @config: pointer to a &struct phylink_config 376 * @max_speed: maximum speed 377 * 378 * Mask off MAC capabilities for speeds higher than the @max_speed parameter. 379 * Any further motifications of config.mac_capabilities will override this. 380 */ 381 void phylink_limit_mac_speed(struct phylink_config *config, u32 max_speed) 382 { 383 int i; 384 385 for (i = 0; i < ARRAY_SIZE(phylink_caps_params) && 386 phylink_caps_params[i].speed > max_speed; i++) 387 config->mac_capabilities &= ~phylink_caps_params[i].mask; 388 } 389 EXPORT_SYMBOL_GPL(phylink_limit_mac_speed); 390 391 /** 392 * phylink_cap_from_speed_duplex - Get mac capability from speed/duplex 393 * @speed: the speed to search for 394 * @duplex: the duplex to search for 395 * 396 * Find the mac capability for a given speed and duplex. 397 * 398 * Return: A mask with the mac capability patching @speed and @duplex, or 0 if 399 * there were no matches. 400 */ 401 static unsigned long phylink_cap_from_speed_duplex(int speed, 402 unsigned int duplex) 403 { 404 int i; 405 406 for (i = 0; i < ARRAY_SIZE(phylink_caps_params); i++) { 407 if (speed == phylink_caps_params[i].speed && 408 duplex == phylink_caps_params[i].duplex) 409 return phylink_caps_params[i].mask; 410 } 411 412 return 0; 413 } 414 415 /** 416 * phylink_get_capabilities() - get capabilities for a given MAC 417 * @interface: phy interface mode defined by &typedef phy_interface_t 418 * @mac_capabilities: bitmask of MAC capabilities 419 * @rate_matching: type of rate matching being performed 420 * 421 * Get the MAC capabilities that are supported by the @interface mode and 422 * @mac_capabilities. 423 */ 424 static unsigned long phylink_get_capabilities(phy_interface_t interface, 425 unsigned long mac_capabilities, 426 int rate_matching) 427 { 428 unsigned long link_caps = phy_caps_from_interface(interface); 429 int max_speed = phylink_interface_max_speed(interface); 430 unsigned long caps = MAC_SYM_PAUSE | MAC_ASYM_PAUSE; 431 unsigned long matched_caps = 0; 432 433 caps |= phylink_link_caps_to_mac_caps(link_caps); 434 435 switch (rate_matching) { 436 case RATE_MATCH_OPEN_LOOP: 437 /* TODO */ 438 fallthrough; 439 case RATE_MATCH_NONE: 440 matched_caps = 0; 441 break; 442 case RATE_MATCH_PAUSE: { 443 /* The MAC must support asymmetric pause towards the local 444 * device for this. We could allow just symmetric pause, but 445 * then we might have to renegotiate if the link partner 446 * doesn't support pause. This is because there's no way to 447 * accept pause frames without transmitting them if we only 448 * support symmetric pause. 449 */ 450 if (!(mac_capabilities & MAC_SYM_PAUSE) || 451 !(mac_capabilities & MAC_ASYM_PAUSE)) 452 break; 453 454 /* We can't adapt if the MAC doesn't support the interface's 455 * max speed at full duplex. 456 */ 457 if (mac_capabilities & 458 phylink_cap_from_speed_duplex(max_speed, DUPLEX_FULL)) 459 matched_caps = GENMASK(__fls(caps), __fls(MAC_10HD)); 460 break; 461 } 462 case RATE_MATCH_CRS: 463 /* The MAC must support half duplex at the interface's max 464 * speed. 465 */ 466 if (mac_capabilities & 467 phylink_cap_from_speed_duplex(max_speed, DUPLEX_HALF)) { 468 matched_caps = GENMASK(__fls(caps), __fls(MAC_10HD)); 469 matched_caps &= mac_capabilities; 470 } 471 break; 472 } 473 474 return (caps & mac_capabilities) | matched_caps; 475 } 476 477 /** 478 * phylink_validate_mask_caps() - Restrict link modes based on caps 479 * @supported: ethtool bitmask for supported link modes. 480 * @state: pointer to a &struct phylink_link_state. 481 * @mac_capabilities: bitmask of MAC capabilities 482 * 483 * Calculate the supported link modes based on @mac_capabilities, and restrict 484 * @supported and @state based on that. Use this function if your capabiliies 485 * aren't constant, such as if they vary depending on the interface. 486 */ 487 static void phylink_validate_mask_caps(unsigned long *supported, 488 struct phylink_link_state *state, 489 unsigned long mac_capabilities) 490 { 491 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, }; 492 unsigned long caps; 493 494 phylink_set_port_modes(mask); 495 phylink_set(mask, Autoneg); 496 caps = phylink_get_capabilities(state->interface, mac_capabilities, 497 state->rate_matching); 498 phylink_caps_to_linkmodes(mask, caps); 499 500 linkmode_and(supported, supported, mask); 501 linkmode_and(state->advertising, state->advertising, mask); 502 } 503 504 static int phylink_validate_mac_and_pcs(struct phylink *pl, 505 unsigned long *supported, 506 struct phylink_link_state *state) 507 { 508 struct phylink_pcs *pcs = NULL; 509 unsigned long capabilities; 510 int ret; 511 512 /* Get the PCS for this interface mode */ 513 if (pl->mac_ops->mac_select_pcs) { 514 pcs = pl->mac_ops->mac_select_pcs(pl->config, state->interface); 515 if (IS_ERR(pcs)) 516 return PTR_ERR(pcs); 517 } 518 519 if (pcs) { 520 /* The PCS, if present, must be setup before phylink_create() 521 * has been called. If the ops is not initialised, print an 522 * error and backtrace rather than oopsing the kernel. 523 */ 524 if (!pcs->ops) { 525 phylink_err(pl, "interface %s: uninitialised PCS\n", 526 phy_modes(state->interface)); 527 dump_stack(); 528 return -EINVAL; 529 } 530 531 /* Ensure that this PCS supports the interface which the MAC 532 * returned it for. It is an error for the MAC to return a PCS 533 * that does not support the interface mode. 534 */ 535 if (!phy_interface_empty(pcs->supported_interfaces) && 536 !test_bit(state->interface, pcs->supported_interfaces)) { 537 phylink_err(pl, "MAC returned PCS which does not support %s\n", 538 phy_modes(state->interface)); 539 return -EINVAL; 540 } 541 542 /* Validate the link parameters with the PCS */ 543 if (pcs->ops->pcs_validate) { 544 ret = pcs->ops->pcs_validate(pcs, supported, state); 545 if (ret < 0 || phylink_is_empty_linkmode(supported)) 546 return -EINVAL; 547 548 /* Ensure the advertising mask is a subset of the 549 * supported mask. 550 */ 551 linkmode_and(state->advertising, state->advertising, 552 supported); 553 } 554 } 555 556 /* Then validate the link parameters with the MAC */ 557 if (pl->mac_ops->mac_get_caps) 558 capabilities = pl->mac_ops->mac_get_caps(pl->config, 559 state->interface); 560 else 561 capabilities = pl->config->mac_capabilities; 562 563 phylink_validate_mask_caps(supported, state, capabilities); 564 565 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0; 566 } 567 568 static void phylink_validate_one(struct phylink *pl, struct phy_device *phy, 569 const unsigned long *supported, 570 const struct phylink_link_state *state, 571 phy_interface_t interface, 572 unsigned long *accum_supported, 573 unsigned long *accum_advertising) 574 { 575 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp_supported); 576 struct phylink_link_state tmp_state; 577 578 linkmode_copy(tmp_supported, supported); 579 580 tmp_state = *state; 581 tmp_state.interface = interface; 582 583 if (phy) 584 tmp_state.rate_matching = phy_get_rate_matching(phy, interface); 585 586 if (!phylink_validate_mac_and_pcs(pl, tmp_supported, &tmp_state)) { 587 phylink_dbg(pl, " interface %u (%s) rate match %s supports %*pbl\n", 588 interface, phy_modes(interface), 589 phy_rate_matching_to_str(tmp_state.rate_matching), 590 __ETHTOOL_LINK_MODE_MASK_NBITS, tmp_supported); 591 592 linkmode_or(accum_supported, accum_supported, tmp_supported); 593 linkmode_or(accum_advertising, accum_advertising, 594 tmp_state.advertising); 595 } 596 } 597 598 static int phylink_validate_mask(struct phylink *pl, struct phy_device *phy, 599 unsigned long *supported, 600 struct phylink_link_state *state, 601 const unsigned long *interfaces) 602 { 603 __ETHTOOL_DECLARE_LINK_MODE_MASK(all_adv) = { 0, }; 604 __ETHTOOL_DECLARE_LINK_MODE_MASK(all_s) = { 0, }; 605 int interface; 606 607 for_each_set_bit(interface, interfaces, PHY_INTERFACE_MODE_MAX) 608 phylink_validate_one(pl, phy, supported, state, interface, 609 all_s, all_adv); 610 611 linkmode_copy(supported, all_s); 612 linkmode_copy(state->advertising, all_adv); 613 614 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0; 615 } 616 617 static int phylink_validate(struct phylink *pl, unsigned long *supported, 618 struct phylink_link_state *state) 619 { 620 const unsigned long *interfaces = pl->config->supported_interfaces; 621 622 if (state->interface == PHY_INTERFACE_MODE_NA) 623 return phylink_validate_mask(pl, NULL, supported, state, 624 interfaces); 625 626 if (!test_bit(state->interface, interfaces)) 627 return -EINVAL; 628 629 return phylink_validate_mac_and_pcs(pl, supported, state); 630 } 631 632 static void phylink_fill_fixedlink_supported(unsigned long *supported) 633 { 634 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, supported); 635 linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, supported); 636 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, supported); 637 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, supported); 638 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, supported); 639 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, supported); 640 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, supported); 641 linkmode_set_bit(ETHTOOL_LINK_MODE_5000baseT_Full_BIT, supported); 642 linkmode_set_bit(ETHTOOL_LINK_MODE_10000baseT_Full_BIT, supported); 643 } 644 645 static int phylink_parse_fixedlink(struct phylink *pl, 646 const struct fwnode_handle *fwnode) 647 { 648 __ETHTOOL_DECLARE_LINK_MODE_MASK(match) = { 0, }; 649 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, }; 650 const struct link_capabilities *c; 651 struct fwnode_handle *fixed_node; 652 struct gpio_desc *desc; 653 u32 speed; 654 int ret; 655 656 fixed_node = fwnode_get_named_child_node(fwnode, "fixed-link"); 657 if (fixed_node) { 658 ret = fwnode_property_read_u32(fixed_node, "speed", &speed); 659 660 pl->link_config.speed = speed; 661 pl->link_config.duplex = DUPLEX_HALF; 662 663 if (fwnode_property_read_bool(fixed_node, "full-duplex")) 664 pl->link_config.duplex = DUPLEX_FULL; 665 666 /* We treat the "pause" and "asym-pause" terminology as 667 * defining the link partner's ability. 668 */ 669 if (fwnode_property_read_bool(fixed_node, "pause")) 670 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 671 pl->link_config.lp_advertising); 672 if (fwnode_property_read_bool(fixed_node, "asym-pause")) 673 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 674 pl->link_config.lp_advertising); 675 676 if (ret == 0) { 677 desc = fwnode_gpiod_get_index(fixed_node, "link", 0, 678 GPIOD_IN, "?"); 679 680 if (!IS_ERR(desc)) 681 pl->link_gpio = desc; 682 else if (desc == ERR_PTR(-EPROBE_DEFER)) 683 ret = -EPROBE_DEFER; 684 } 685 fwnode_handle_put(fixed_node); 686 687 if (ret) 688 return ret; 689 } else { 690 u32 prop[5]; 691 692 ret = fwnode_property_read_u32_array(fwnode, "fixed-link", 693 NULL, 0); 694 if (ret != ARRAY_SIZE(prop)) { 695 phylink_err(pl, "broken fixed-link?\n"); 696 return -EINVAL; 697 } 698 699 ret = fwnode_property_read_u32_array(fwnode, "fixed-link", 700 prop, ARRAY_SIZE(prop)); 701 if (!ret) { 702 pl->link_config.duplex = prop[1] ? 703 DUPLEX_FULL : DUPLEX_HALF; 704 pl->link_config.speed = prop[2]; 705 if (prop[3]) 706 __set_bit(ETHTOOL_LINK_MODE_Pause_BIT, 707 pl->link_config.lp_advertising); 708 if (prop[4]) 709 __set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 710 pl->link_config.lp_advertising); 711 } 712 } 713 714 if (pl->link_config.speed > SPEED_1000 && 715 pl->link_config.duplex != DUPLEX_FULL) 716 phylink_warn(pl, "fixed link specifies half duplex for %dMbps link?\n", 717 pl->link_config.speed); 718 719 linkmode_zero(pl->supported); 720 phylink_fill_fixedlink_supported(pl->supported); 721 722 linkmode_copy(pl->link_config.advertising, pl->supported); 723 phylink_validate(pl, pl->supported, &pl->link_config); 724 725 c = phy_caps_lookup(pl->link_config.speed, pl->link_config.duplex, 726 pl->supported, true); 727 if (c) 728 linkmode_and(match, pl->supported, c->linkmodes); 729 730 linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, mask); 731 linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, mask); 732 linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, mask); 733 linkmode_and(pl->supported, pl->supported, mask); 734 735 phylink_set(pl->supported, MII); 736 737 if (c) { 738 linkmode_or(pl->supported, pl->supported, match); 739 linkmode_or(pl->link_config.lp_advertising, 740 pl->link_config.lp_advertising, match); 741 } else { 742 phylink_warn(pl, "fixed link %s duplex %dMbps not recognised\n", 743 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half", 744 pl->link_config.speed); 745 } 746 747 linkmode_and(pl->link_config.advertising, pl->link_config.advertising, 748 pl->supported); 749 750 pl->link_config.link = 1; 751 pl->link_config.an_complete = 1; 752 753 return 0; 754 } 755 756 static int phylink_parse_mode(struct phylink *pl, 757 const struct fwnode_handle *fwnode) 758 { 759 struct fwnode_handle *dn; 760 const char *managed; 761 unsigned long caps; 762 763 if (pl->config->default_an_inband) 764 pl->cfg_link_an_mode = MLO_AN_INBAND; 765 766 dn = fwnode_get_named_child_node(fwnode, "fixed-link"); 767 if (dn || fwnode_property_present(fwnode, "fixed-link")) 768 pl->cfg_link_an_mode = MLO_AN_FIXED; 769 fwnode_handle_put(dn); 770 771 if ((fwnode_property_read_string(fwnode, "managed", &managed) == 0 && 772 strcmp(managed, "in-band-status") == 0)) { 773 if (pl->cfg_link_an_mode == MLO_AN_FIXED) { 774 phylink_err(pl, 775 "can't use both fixed-link and in-band-status\n"); 776 return -EINVAL; 777 } 778 779 pl->cfg_link_an_mode = MLO_AN_INBAND; 780 } 781 782 if (pl->cfg_link_an_mode == MLO_AN_INBAND) { 783 linkmode_zero(pl->supported); 784 phylink_set(pl->supported, MII); 785 phylink_set(pl->supported, Autoneg); 786 phylink_set(pl->supported, Asym_Pause); 787 phylink_set(pl->supported, Pause); 788 789 switch (pl->link_config.interface) { 790 case PHY_INTERFACE_MODE_SGMII: 791 case PHY_INTERFACE_MODE_PSGMII: 792 case PHY_INTERFACE_MODE_QSGMII: 793 case PHY_INTERFACE_MODE_QUSGMII: 794 case PHY_INTERFACE_MODE_RGMII: 795 case PHY_INTERFACE_MODE_RGMII_ID: 796 case PHY_INTERFACE_MODE_RGMII_RXID: 797 case PHY_INTERFACE_MODE_RGMII_TXID: 798 case PHY_INTERFACE_MODE_RTBI: 799 case PHY_INTERFACE_MODE_1000BASEX: 800 case PHY_INTERFACE_MODE_2500BASEX: 801 case PHY_INTERFACE_MODE_5GBASER: 802 case PHY_INTERFACE_MODE_25GBASER: 803 case PHY_INTERFACE_MODE_USXGMII: 804 case PHY_INTERFACE_MODE_10G_QXGMII: 805 case PHY_INTERFACE_MODE_10GKR: 806 case PHY_INTERFACE_MODE_10GBASER: 807 case PHY_INTERFACE_MODE_XLGMII: 808 caps = ~(MAC_SYM_PAUSE | MAC_ASYM_PAUSE); 809 caps = phylink_get_capabilities(pl->link_config.interface, caps, 810 RATE_MATCH_NONE); 811 phylink_caps_to_linkmodes(pl->supported, caps); 812 break; 813 814 default: 815 phylink_err(pl, 816 "incorrect link mode %s for in-band status\n", 817 phy_modes(pl->link_config.interface)); 818 return -EINVAL; 819 } 820 821 linkmode_copy(pl->link_config.advertising, pl->supported); 822 823 if (phylink_validate(pl, pl->supported, &pl->link_config)) { 824 phylink_err(pl, 825 "failed to validate link configuration for in-band status\n"); 826 return -EINVAL; 827 } 828 } 829 830 return 0; 831 } 832 833 static void phylink_apply_manual_flow(struct phylink *pl, 834 struct phylink_link_state *state) 835 { 836 /* If autoneg is disabled, pause AN is also disabled */ 837 if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 838 state->advertising)) 839 state->pause &= ~MLO_PAUSE_AN; 840 841 /* Manual configuration of pause modes */ 842 if (!(pl->link_config.pause & MLO_PAUSE_AN)) 843 state->pause = pl->link_config.pause; 844 } 845 846 static void phylink_resolve_an_pause(struct phylink_link_state *state) 847 { 848 bool tx_pause, rx_pause; 849 850 if (state->duplex == DUPLEX_FULL) { 851 linkmode_resolve_pause(state->advertising, 852 state->lp_advertising, 853 &tx_pause, &rx_pause); 854 if (tx_pause) 855 state->pause |= MLO_PAUSE_TX; 856 if (rx_pause) 857 state->pause |= MLO_PAUSE_RX; 858 } 859 } 860 861 static unsigned int phylink_pcs_inband_caps(struct phylink_pcs *pcs, 862 phy_interface_t interface) 863 { 864 if (pcs && pcs->ops->pcs_inband_caps) 865 return pcs->ops->pcs_inband_caps(pcs, interface); 866 867 return 0; 868 } 869 870 static void phylink_pcs_pre_config(struct phylink_pcs *pcs, 871 phy_interface_t interface) 872 { 873 if (pcs && pcs->ops->pcs_pre_config) 874 pcs->ops->pcs_pre_config(pcs, interface); 875 } 876 877 static int phylink_pcs_post_config(struct phylink_pcs *pcs, 878 phy_interface_t interface) 879 { 880 int err = 0; 881 882 if (pcs && pcs->ops->pcs_post_config) 883 err = pcs->ops->pcs_post_config(pcs, interface); 884 885 return err; 886 } 887 888 static void phylink_pcs_disable(struct phylink_pcs *pcs) 889 { 890 if (pcs && pcs->ops->pcs_disable) 891 pcs->ops->pcs_disable(pcs); 892 } 893 894 static int phylink_pcs_enable(struct phylink_pcs *pcs) 895 { 896 int err = 0; 897 898 if (pcs && pcs->ops->pcs_enable) 899 err = pcs->ops->pcs_enable(pcs); 900 901 return err; 902 } 903 904 static int phylink_pcs_config(struct phylink_pcs *pcs, unsigned int neg_mode, 905 const struct phylink_link_state *state, 906 bool permit_pause_to_mac) 907 { 908 if (!pcs) 909 return 0; 910 911 return pcs->ops->pcs_config(pcs, neg_mode, state->interface, 912 state->advertising, permit_pause_to_mac); 913 } 914 915 static void phylink_pcs_link_up(struct phylink_pcs *pcs, unsigned int neg_mode, 916 phy_interface_t interface, int speed, 917 int duplex) 918 { 919 if (pcs && pcs->ops->pcs_link_up) 920 pcs->ops->pcs_link_up(pcs, neg_mode, interface, speed, duplex); 921 } 922 923 static void phylink_pcs_disable_eee(struct phylink_pcs *pcs) 924 { 925 if (pcs && pcs->ops->pcs_disable_eee) 926 pcs->ops->pcs_disable_eee(pcs); 927 } 928 929 static void phylink_pcs_enable_eee(struct phylink_pcs *pcs) 930 { 931 if (pcs && pcs->ops->pcs_enable_eee) 932 pcs->ops->pcs_enable_eee(pcs); 933 } 934 935 /* Query inband for a specific interface mode, asking the MAC for the 936 * PCS which will be used to handle the interface mode. 937 */ 938 static unsigned int phylink_inband_caps(struct phylink *pl, 939 phy_interface_t interface) 940 { 941 struct phylink_pcs *pcs; 942 943 if (!pl->mac_ops->mac_select_pcs) 944 return 0; 945 946 pcs = pl->mac_ops->mac_select_pcs(pl->config, interface); 947 if (!pcs) 948 return 0; 949 950 return phylink_pcs_inband_caps(pcs, interface); 951 } 952 953 static void phylink_pcs_poll_stop(struct phylink *pl) 954 { 955 if (pl->cfg_link_an_mode == MLO_AN_INBAND) 956 timer_delete(&pl->link_poll); 957 } 958 959 static void phylink_pcs_poll_start(struct phylink *pl) 960 { 961 if (pl->pcs && pl->pcs->poll && pl->cfg_link_an_mode == MLO_AN_INBAND) 962 mod_timer(&pl->link_poll, jiffies + HZ); 963 } 964 965 int phylink_pcs_pre_init(struct phylink *pl, struct phylink_pcs *pcs) 966 { 967 int ret = 0; 968 969 /* Signal to PCS driver that MAC requires RX clock for init */ 970 if (pl->config->mac_requires_rxc) 971 pcs->rxc_always_on = true; 972 973 if (pcs->ops->pcs_pre_init) 974 ret = pcs->ops->pcs_pre_init(pcs); 975 976 return ret; 977 } 978 EXPORT_SYMBOL_GPL(phylink_pcs_pre_init); 979 980 static void phylink_mac_config(struct phylink *pl, 981 const struct phylink_link_state *state) 982 { 983 struct phylink_link_state st = *state; 984 985 /* Stop drivers incorrectly using these */ 986 linkmode_zero(st.lp_advertising); 987 st.speed = SPEED_UNKNOWN; 988 st.duplex = DUPLEX_UNKNOWN; 989 st.an_complete = false; 990 st.link = false; 991 992 phylink_dbg(pl, 993 "%s: mode=%s/%s/%s adv=%*pb pause=%02x\n", 994 __func__, phylink_an_mode_str(pl->act_link_an_mode), 995 phy_modes(st.interface), 996 phy_rate_matching_to_str(st.rate_matching), 997 __ETHTOOL_LINK_MODE_MASK_NBITS, st.advertising, 998 st.pause); 999 1000 pl->mac_ops->mac_config(pl->config, pl->act_link_an_mode, &st); 1001 } 1002 1003 static void phylink_pcs_an_restart(struct phylink *pl) 1004 { 1005 if (pl->pcs && linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 1006 pl->link_config.advertising) && 1007 phy_interface_mode_is_8023z(pl->link_config.interface) && 1008 phylink_autoneg_inband(pl->act_link_an_mode)) 1009 pl->pcs->ops->pcs_an_restart(pl->pcs); 1010 } 1011 1012 /** 1013 * phylink_pcs_neg_mode() - helper to determine PCS inband mode 1014 * @pl: a pointer to a &struct phylink returned from phylink_create() 1015 * @pcs: a pointer to &struct phylink_pcs 1016 * @interface: interface mode to be used 1017 * @advertising: adertisement ethtool link mode mask 1018 * 1019 * Determines the negotiation mode to be used by the PCS, and returns 1020 * one of: 1021 * 1022 * - %PHYLINK_PCS_NEG_NONE: interface mode does not support inband 1023 * - %PHYLINK_PCS_NEG_OUTBAND: an out of band mode (e.g. reading the PHY) 1024 * will be used. 1025 * - %PHYLINK_PCS_NEG_INBAND_DISABLED: inband mode selected but autoneg 1026 * disabled 1027 * - %PHYLINK_PCS_NEG_INBAND_ENABLED: inband mode selected and autoneg enabled 1028 * 1029 * Note: this is for cases where the PCS itself is involved in negotiation 1030 * (e.g. Clause 37, SGMII and similar) not Clause 73. 1031 */ 1032 static void phylink_pcs_neg_mode(struct phylink *pl, struct phylink_pcs *pcs, 1033 phy_interface_t interface, 1034 const unsigned long *advertising) 1035 { 1036 unsigned int pcs_ib_caps = 0; 1037 unsigned int phy_ib_caps = 0; 1038 unsigned int neg_mode, mode; 1039 enum { 1040 INBAND_CISCO_SGMII, 1041 INBAND_BASEX, 1042 } type; 1043 1044 mode = pl->req_link_an_mode; 1045 1046 pl->phy_ib_mode = 0; 1047 1048 switch (interface) { 1049 case PHY_INTERFACE_MODE_SGMII: 1050 case PHY_INTERFACE_MODE_QSGMII: 1051 case PHY_INTERFACE_MODE_QUSGMII: 1052 case PHY_INTERFACE_MODE_USXGMII: 1053 case PHY_INTERFACE_MODE_10G_QXGMII: 1054 /* These protocols are designed for use with a PHY which 1055 * communicates its negotiation result back to the MAC via 1056 * inband communication. Note: there exist PHYs that run 1057 * with SGMII but do not send the inband data. 1058 */ 1059 type = INBAND_CISCO_SGMII; 1060 break; 1061 1062 case PHY_INTERFACE_MODE_1000BASEX: 1063 case PHY_INTERFACE_MODE_2500BASEX: 1064 /* 1000base-X is designed for use media-side for Fibre 1065 * connections, and thus the Autoneg bit needs to be 1066 * taken into account. We also do this for 2500base-X 1067 * as well, but drivers may not support this, so may 1068 * need to override this. 1069 */ 1070 type = INBAND_BASEX; 1071 break; 1072 1073 default: 1074 pl->pcs_neg_mode = PHYLINK_PCS_NEG_NONE; 1075 pl->act_link_an_mode = mode; 1076 return; 1077 } 1078 1079 if (pcs) 1080 pcs_ib_caps = phylink_pcs_inband_caps(pcs, interface); 1081 1082 if (pl->phydev) 1083 phy_ib_caps = phy_inband_caps(pl->phydev, interface); 1084 1085 phylink_dbg(pl, "interface %s inband modes: pcs=%02x phy=%02x\n", 1086 phy_modes(interface), pcs_ib_caps, phy_ib_caps); 1087 1088 if (!phylink_autoneg_inband(mode)) { 1089 bool pcs_ib_only = false; 1090 bool phy_ib_only = false; 1091 1092 if (pcs_ib_caps && pcs_ib_caps != LINK_INBAND_DISABLE) { 1093 /* PCS supports reporting in-band capabilities, and 1094 * supports more than disable mode. 1095 */ 1096 if (pcs_ib_caps & LINK_INBAND_DISABLE) 1097 neg_mode = PHYLINK_PCS_NEG_OUTBAND; 1098 else if (pcs_ib_caps & LINK_INBAND_ENABLE) 1099 pcs_ib_only = true; 1100 } 1101 1102 if (phy_ib_caps && phy_ib_caps != LINK_INBAND_DISABLE) { 1103 /* PHY supports in-band capabilities, and supports 1104 * more than disable mode. 1105 */ 1106 if (phy_ib_caps & LINK_INBAND_DISABLE) 1107 pl->phy_ib_mode = LINK_INBAND_DISABLE; 1108 else if (phy_ib_caps & LINK_INBAND_BYPASS) 1109 pl->phy_ib_mode = LINK_INBAND_BYPASS; 1110 else if (phy_ib_caps & LINK_INBAND_ENABLE) 1111 phy_ib_only = true; 1112 } 1113 1114 /* If either the PCS or PHY requires inband to be enabled, 1115 * this is an invalid configuration. Provide a diagnostic 1116 * message for this case, but don't try to force the issue. 1117 */ 1118 if (pcs_ib_only || phy_ib_only) 1119 phylink_warn(pl, 1120 "firmware wants %s mode, but %s%s%s requires inband\n", 1121 phylink_an_mode_str(mode), 1122 pcs_ib_only ? "PCS" : "", 1123 pcs_ib_only && phy_ib_only ? " and " : "", 1124 phy_ib_only ? "PHY" : ""); 1125 1126 neg_mode = PHYLINK_PCS_NEG_OUTBAND; 1127 } else if (type == INBAND_CISCO_SGMII || pl->phydev) { 1128 /* For SGMII modes which are designed to be used with PHYs, or 1129 * Base-X with a PHY, we try to use in-band mode where-ever 1130 * possible. However, there are some PHYs e.g. BCM84881 which 1131 * do not support in-band. 1132 */ 1133 const unsigned int inband_ok = LINK_INBAND_ENABLE | 1134 LINK_INBAND_BYPASS; 1135 const unsigned int outband_ok = LINK_INBAND_DISABLE | 1136 LINK_INBAND_BYPASS; 1137 /* PCS PHY 1138 * D E D E 1139 * 0 0 0 0 no information inband enabled 1140 * 1 0 0 0 pcs doesn't support outband 1141 * 0 1 0 0 pcs required inband enabled 1142 * 1 1 0 0 pcs optional inband enabled 1143 * 0 0 1 0 phy doesn't support outband 1144 * 1 0 1 0 pcs+phy doesn't support outband 1145 * 0 1 1 0 pcs required, phy doesn't support, invalid 1146 * 1 1 1 0 pcs optional, phy doesn't support, outband 1147 * 0 0 0 1 phy required inband enabled 1148 * 1 0 0 1 pcs doesn't support, phy required, invalid 1149 * 0 1 0 1 pcs+phy required inband enabled 1150 * 1 1 0 1 pcs optional, phy required inband enabled 1151 * 0 0 1 1 phy optional inband enabled 1152 * 1 0 1 1 pcs doesn't support, phy optional, outband 1153 * 0 1 1 1 pcs required, phy optional inband enabled 1154 * 1 1 1 1 pcs+phy optional inband enabled 1155 */ 1156 if ((!pcs_ib_caps || pcs_ib_caps & inband_ok) && 1157 (!phy_ib_caps || phy_ib_caps & inband_ok)) { 1158 /* In-band supported or unknown at both ends. Enable 1159 * in-band mode with or without bypass at the PHY. 1160 */ 1161 if (phy_ib_caps & LINK_INBAND_ENABLE) 1162 pl->phy_ib_mode = LINK_INBAND_ENABLE; 1163 else if (phy_ib_caps & LINK_INBAND_BYPASS) 1164 pl->phy_ib_mode = LINK_INBAND_BYPASS; 1165 1166 neg_mode = PHYLINK_PCS_NEG_INBAND_ENABLED; 1167 } else if ((!pcs_ib_caps || pcs_ib_caps & outband_ok) && 1168 (!phy_ib_caps || phy_ib_caps & outband_ok)) { 1169 /* Either in-band not supported at at least one end. 1170 * In-band bypass at the other end is possible. 1171 */ 1172 if (phy_ib_caps & LINK_INBAND_DISABLE) 1173 pl->phy_ib_mode = LINK_INBAND_DISABLE; 1174 else if (phy_ib_caps & LINK_INBAND_BYPASS) 1175 pl->phy_ib_mode = LINK_INBAND_BYPASS; 1176 1177 neg_mode = PHYLINK_PCS_NEG_OUTBAND; 1178 if (pl->phydev) 1179 mode = MLO_AN_PHY; 1180 } else { 1181 /* invalid */ 1182 phylink_warn(pl, "%s: incompatible in-band capabilities, trying in-band", 1183 phy_modes(interface)); 1184 neg_mode = PHYLINK_PCS_NEG_INBAND_ENABLED; 1185 } 1186 } else { 1187 /* For Base-X without a PHY */ 1188 if (pcs_ib_caps == LINK_INBAND_DISABLE) 1189 /* If the PCS doesn't support inband, then inband must 1190 * be disabled. 1191 */ 1192 neg_mode = PHYLINK_PCS_NEG_INBAND_DISABLED; 1193 else if (pcs_ib_caps == LINK_INBAND_ENABLE) 1194 /* If the PCS requires inband, then inband must always 1195 * be enabled. 1196 */ 1197 neg_mode = PHYLINK_PCS_NEG_INBAND_ENABLED; 1198 else if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 1199 advertising)) 1200 neg_mode = PHYLINK_PCS_NEG_INBAND_ENABLED; 1201 else 1202 neg_mode = PHYLINK_PCS_NEG_INBAND_DISABLED; 1203 } 1204 1205 pl->pcs_neg_mode = neg_mode; 1206 pl->act_link_an_mode = mode; 1207 } 1208 1209 static void phylink_major_config(struct phylink *pl, bool restart, 1210 const struct phylink_link_state *state) 1211 { 1212 struct phylink_pcs *pcs = NULL; 1213 bool pcs_changed = false; 1214 unsigned int rate_kbd; 1215 int err; 1216 1217 phylink_dbg(pl, "major config, requested %s/%s\n", 1218 phylink_an_mode_str(pl->req_link_an_mode), 1219 phy_modes(state->interface)); 1220 1221 pl->major_config_failed = false; 1222 1223 if (pl->mac_ops->mac_select_pcs) { 1224 pcs = pl->mac_ops->mac_select_pcs(pl->config, state->interface); 1225 if (IS_ERR(pcs)) { 1226 phylink_err(pl, 1227 "mac_select_pcs unexpectedly failed: %pe\n", 1228 pcs); 1229 1230 pl->major_config_failed = true; 1231 return; 1232 } 1233 1234 pcs_changed = pl->pcs != pcs; 1235 } 1236 1237 phylink_pcs_neg_mode(pl, pcs, state->interface, state->advertising); 1238 1239 phylink_dbg(pl, "major config, active %s/%s/%s\n", 1240 phylink_an_mode_str(pl->act_link_an_mode), 1241 phylink_pcs_mode_str(pl->pcs_neg_mode), 1242 phy_modes(state->interface)); 1243 1244 phylink_pcs_poll_stop(pl); 1245 1246 if (pl->mac_ops->mac_prepare) { 1247 err = pl->mac_ops->mac_prepare(pl->config, pl->act_link_an_mode, 1248 state->interface); 1249 if (err < 0) { 1250 phylink_err(pl, "mac_prepare failed: %pe\n", 1251 ERR_PTR(err)); 1252 pl->major_config_failed = true; 1253 return; 1254 } 1255 } 1256 1257 /* If we have a new PCS, switch to the new PCS after preparing the MAC 1258 * for the change. 1259 */ 1260 if (pcs_changed) { 1261 phylink_pcs_disable(pl->pcs); 1262 1263 if (pl->pcs) 1264 pl->pcs->phylink = NULL; 1265 1266 pcs->phylink = pl; 1267 1268 pl->pcs = pcs; 1269 } 1270 1271 if (pl->pcs) 1272 phylink_pcs_pre_config(pl->pcs, state->interface); 1273 1274 phylink_mac_config(pl, state); 1275 1276 if (pl->pcs) { 1277 err = phylink_pcs_post_config(pl->pcs, state->interface); 1278 if (err < 0) { 1279 phylink_err(pl, "pcs_post_config failed: %pe\n", 1280 ERR_PTR(err)); 1281 1282 pl->major_config_failed = true; 1283 } 1284 } 1285 1286 if (pl->pcs_state == PCS_STATE_STARTING || pcs_changed) 1287 phylink_pcs_enable(pl->pcs); 1288 1289 err = phylink_pcs_config(pl->pcs, pl->pcs_neg_mode, state, 1290 !!(pl->link_config.pause & MLO_PAUSE_AN)); 1291 if (err < 0) { 1292 phylink_err(pl, "pcs_config failed: %pe\n", ERR_PTR(err)); 1293 pl->major_config_failed = true; 1294 } else if (err > 0) { 1295 restart = true; 1296 } 1297 1298 if (restart) 1299 phylink_pcs_an_restart(pl); 1300 1301 if (pl->mac_ops->mac_finish) { 1302 err = pl->mac_ops->mac_finish(pl->config, pl->act_link_an_mode, 1303 state->interface); 1304 if (err < 0) { 1305 phylink_err(pl, "mac_finish failed: %pe\n", 1306 ERR_PTR(err)); 1307 1308 pl->major_config_failed = true; 1309 } 1310 } 1311 1312 if (pl->phydev && pl->phy_ib_mode) { 1313 err = phy_config_inband(pl->phydev, pl->phy_ib_mode); 1314 if (err < 0) { 1315 phylink_err(pl, "phy_config_inband: %pe\n", 1316 ERR_PTR(err)); 1317 1318 pl->major_config_failed = true; 1319 } 1320 } 1321 1322 if (pl->sfp_bus) { 1323 rate_kbd = phylink_interface_signal_rate(state->interface); 1324 if (rate_kbd) 1325 sfp_upstream_set_signal_rate(pl->sfp_bus, rate_kbd); 1326 } 1327 1328 phylink_pcs_poll_start(pl); 1329 } 1330 1331 /* 1332 * Reconfigure for a change of inband advertisement. 1333 * If we have a separate PCS, we only need to call its pcs_config() method, 1334 * and then restart AN if it indicates something changed. Otherwise, we do 1335 * the full MAC reconfiguration. 1336 */ 1337 static int phylink_change_inband_advert(struct phylink *pl) 1338 { 1339 int ret; 1340 1341 if (test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) 1342 return 0; 1343 1344 phylink_dbg(pl, "%s: mode=%s/%s adv=%*pb pause=%02x\n", __func__, 1345 phylink_an_mode_str(pl->req_link_an_mode), 1346 phy_modes(pl->link_config.interface), 1347 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->link_config.advertising, 1348 pl->link_config.pause); 1349 1350 /* Recompute the PCS neg mode */ 1351 phylink_pcs_neg_mode(pl, pl->pcs, pl->link_config.interface, 1352 pl->link_config.advertising); 1353 1354 /* Modern PCS-based method; update the advert at the PCS, and 1355 * restart negotiation if the pcs_config() helper indicates that 1356 * the programmed advertisement has changed. 1357 */ 1358 ret = phylink_pcs_config(pl->pcs, pl->pcs_neg_mode, &pl->link_config, 1359 !!(pl->link_config.pause & MLO_PAUSE_AN)); 1360 if (ret < 0) 1361 return ret; 1362 1363 if (ret > 0) 1364 phylink_pcs_an_restart(pl); 1365 1366 return 0; 1367 } 1368 1369 static void phylink_mac_pcs_get_state(struct phylink *pl, 1370 struct phylink_link_state *state) 1371 { 1372 struct phylink_pcs *pcs; 1373 bool autoneg; 1374 1375 linkmode_copy(state->advertising, pl->link_config.advertising); 1376 linkmode_zero(state->lp_advertising); 1377 state->interface = pl->link_config.interface; 1378 state->rate_matching = pl->link_config.rate_matching; 1379 state->an_complete = 0; 1380 state->link = 1; 1381 1382 autoneg = pl->pcs_neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED; 1383 if (autoneg) { 1384 state->speed = SPEED_UNKNOWN; 1385 state->duplex = DUPLEX_UNKNOWN; 1386 state->pause = MLO_PAUSE_NONE; 1387 } else { 1388 state->speed = pl->link_config.speed; 1389 state->duplex = pl->link_config.duplex; 1390 state->pause = pl->link_config.pause; 1391 } 1392 1393 pcs = pl->pcs; 1394 if (pcs) 1395 pcs->ops->pcs_get_state(pcs, pl->pcs_neg_mode, state); 1396 else 1397 state->link = 0; 1398 } 1399 1400 /* The fixed state is... fixed except for the link state, 1401 * which may be determined by a GPIO or a callback. 1402 */ 1403 static void phylink_get_fixed_state(struct phylink *pl, 1404 struct phylink_link_state *state) 1405 { 1406 *state = pl->link_config; 1407 if (pl->config->get_fixed_state) 1408 pl->config->get_fixed_state(pl->config, state); 1409 else if (pl->link_gpio) 1410 state->link = !!gpiod_get_value_cansleep(pl->link_gpio); 1411 1412 state->pause = MLO_PAUSE_NONE; 1413 phylink_resolve_an_pause(state); 1414 } 1415 1416 static void phylink_mac_initial_config(struct phylink *pl, bool force_restart) 1417 { 1418 struct phylink_link_state link_state; 1419 1420 switch (pl->req_link_an_mode) { 1421 case MLO_AN_PHY: 1422 link_state = pl->phy_state; 1423 break; 1424 1425 case MLO_AN_FIXED: 1426 phylink_get_fixed_state(pl, &link_state); 1427 break; 1428 1429 case MLO_AN_INBAND: 1430 link_state = pl->link_config; 1431 if (link_state.interface == PHY_INTERFACE_MODE_SGMII) 1432 link_state.pause = MLO_PAUSE_NONE; 1433 break; 1434 1435 default: /* can't happen */ 1436 return; 1437 } 1438 1439 link_state.link = false; 1440 1441 phylink_apply_manual_flow(pl, &link_state); 1442 phylink_major_config(pl, force_restart, &link_state); 1443 } 1444 1445 static const char *phylink_pause_to_str(int pause) 1446 { 1447 switch (pause & MLO_PAUSE_TXRX_MASK) { 1448 case MLO_PAUSE_TX | MLO_PAUSE_RX: 1449 return "rx/tx"; 1450 case MLO_PAUSE_TX: 1451 return "tx"; 1452 case MLO_PAUSE_RX: 1453 return "rx"; 1454 default: 1455 return "off"; 1456 } 1457 } 1458 1459 static void phylink_deactivate_lpi(struct phylink *pl) 1460 { 1461 if (pl->mac_enable_tx_lpi) { 1462 pl->mac_enable_tx_lpi = false; 1463 1464 phylink_dbg(pl, "disabling LPI\n"); 1465 1466 pl->mac_ops->mac_disable_tx_lpi(pl->config); 1467 1468 phylink_pcs_disable_eee(pl->pcs); 1469 } 1470 } 1471 1472 static void phylink_activate_lpi(struct phylink *pl) 1473 { 1474 int err; 1475 1476 if (!test_bit(pl->cur_interface, pl->config->lpi_interfaces)) { 1477 phylink_dbg(pl, "MAC does not support LPI with %s\n", 1478 phy_modes(pl->cur_interface)); 1479 return; 1480 } 1481 1482 phylink_dbg(pl, "LPI timer %uus, tx clock stop %u\n", 1483 pl->mac_tx_lpi_timer, pl->mac_tx_clk_stop); 1484 1485 phylink_pcs_enable_eee(pl->pcs); 1486 1487 err = pl->mac_ops->mac_enable_tx_lpi(pl->config, pl->mac_tx_lpi_timer, 1488 pl->mac_tx_clk_stop); 1489 if (err) { 1490 phylink_pcs_disable_eee(pl->pcs); 1491 phylink_err(pl, "%ps() failed: %pe\n", 1492 pl->mac_ops->mac_enable_tx_lpi, ERR_PTR(err)); 1493 return; 1494 } 1495 1496 pl->mac_enable_tx_lpi = true; 1497 } 1498 1499 static void phylink_link_up(struct phylink *pl, 1500 struct phylink_link_state link_state) 1501 { 1502 struct net_device *ndev = pl->netdev; 1503 int speed, duplex; 1504 bool rx_pause; 1505 1506 speed = link_state.speed; 1507 duplex = link_state.duplex; 1508 rx_pause = !!(link_state.pause & MLO_PAUSE_RX); 1509 1510 switch (link_state.rate_matching) { 1511 case RATE_MATCH_PAUSE: 1512 /* The PHY is doing rate matchion from the media rate (in 1513 * the link_state) to the interface speed, and will send 1514 * pause frames to the MAC to limit its transmission speed. 1515 */ 1516 speed = phylink_interface_max_speed(link_state.interface); 1517 duplex = DUPLEX_FULL; 1518 rx_pause = true; 1519 break; 1520 1521 case RATE_MATCH_CRS: 1522 /* The PHY is doing rate matchion from the media rate (in 1523 * the link_state) to the interface speed, and will cause 1524 * collisions to the MAC to limit its transmission speed. 1525 */ 1526 speed = phylink_interface_max_speed(link_state.interface); 1527 duplex = DUPLEX_HALF; 1528 break; 1529 } 1530 1531 pl->cur_interface = link_state.interface; 1532 1533 phylink_pcs_link_up(pl->pcs, pl->pcs_neg_mode, pl->cur_interface, speed, 1534 duplex); 1535 1536 pl->mac_ops->mac_link_up(pl->config, pl->phydev, pl->act_link_an_mode, 1537 pl->cur_interface, speed, duplex, 1538 !!(link_state.pause & MLO_PAUSE_TX), rx_pause); 1539 1540 if (pl->mac_supports_eee && pl->phy_enable_tx_lpi) 1541 phylink_activate_lpi(pl); 1542 1543 if (ndev) 1544 netif_carrier_on(ndev); 1545 1546 phylink_info(pl, 1547 "Link is Up - %s/%s - flow control %s\n", 1548 phy_speed_to_str(link_state.speed), 1549 phy_duplex_to_str(link_state.duplex), 1550 phylink_pause_to_str(link_state.pause)); 1551 } 1552 1553 static void phylink_link_down(struct phylink *pl) 1554 { 1555 struct net_device *ndev = pl->netdev; 1556 1557 if (ndev) 1558 netif_carrier_off(ndev); 1559 1560 phylink_deactivate_lpi(pl); 1561 1562 pl->mac_ops->mac_link_down(pl->config, pl->act_link_an_mode, 1563 pl->cur_interface); 1564 phylink_info(pl, "Link is Down\n"); 1565 } 1566 1567 static bool phylink_link_is_up(struct phylink *pl) 1568 { 1569 return pl->netdev ? netif_carrier_ok(pl->netdev) : pl->old_link_state; 1570 } 1571 1572 static void phylink_resolve(struct work_struct *w) 1573 { 1574 struct phylink *pl = container_of(w, struct phylink, resolve); 1575 struct phylink_link_state link_state; 1576 bool mac_config = false; 1577 bool retrigger = false; 1578 bool cur_link_state; 1579 1580 mutex_lock(&pl->state_mutex); 1581 cur_link_state = phylink_link_is_up(pl); 1582 1583 if (pl->phylink_disable_state) { 1584 pl->link_failed = false; 1585 link_state.link = false; 1586 } else if (pl->link_failed) { 1587 link_state.link = false; 1588 retrigger = true; 1589 } else if (pl->act_link_an_mode == MLO_AN_FIXED) { 1590 phylink_get_fixed_state(pl, &link_state); 1591 mac_config = link_state.link; 1592 } else if (pl->act_link_an_mode == MLO_AN_PHY) { 1593 link_state = pl->phy_state; 1594 mac_config = link_state.link; 1595 } else { 1596 phylink_mac_pcs_get_state(pl, &link_state); 1597 1598 /* The PCS may have a latching link-fail indicator. If the link 1599 * was up, bring the link down and re-trigger the resolve. 1600 * Otherwise, re-read the PCS state to get the current status 1601 * of the link. 1602 */ 1603 if (!link_state.link) { 1604 if (cur_link_state) 1605 retrigger = true; 1606 else 1607 phylink_mac_pcs_get_state(pl, &link_state); 1608 } 1609 1610 /* If we have a phy, the "up" state is the union of both the 1611 * PHY and the MAC 1612 */ 1613 if (pl->phydev) 1614 link_state.link &= pl->phy_state.link; 1615 1616 /* Only update if the PHY link is up */ 1617 if (pl->phydev && pl->phy_state.link) { 1618 /* If the interface has changed, force a link down 1619 * event if the link isn't already down, and re-resolve. 1620 */ 1621 if (link_state.interface != pl->phy_state.interface) { 1622 retrigger = true; 1623 link_state.link = false; 1624 } 1625 1626 link_state.interface = pl->phy_state.interface; 1627 1628 /* If we are doing rate matching, then the link 1629 * speed/duplex comes from the PHY 1630 */ 1631 if (pl->phy_state.rate_matching) { 1632 link_state.rate_matching = 1633 pl->phy_state.rate_matching; 1634 link_state.speed = pl->phy_state.speed; 1635 link_state.duplex = pl->phy_state.duplex; 1636 } 1637 1638 /* If we have a PHY, we need to update with the PHY 1639 * flow control bits. 1640 */ 1641 link_state.pause = pl->phy_state.pause; 1642 mac_config = true; 1643 } 1644 } 1645 1646 if (pl->act_link_an_mode != MLO_AN_FIXED) 1647 phylink_apply_manual_flow(pl, &link_state); 1648 1649 if (mac_config) { 1650 if (link_state.interface != pl->link_config.interface) { 1651 /* The interface has changed, force the link down and 1652 * then reconfigure. 1653 */ 1654 if (cur_link_state) { 1655 phylink_link_down(pl); 1656 cur_link_state = false; 1657 } 1658 phylink_major_config(pl, false, &link_state); 1659 pl->link_config.interface = link_state.interface; 1660 } 1661 } 1662 1663 /* If configuration of the interface failed, force the link down 1664 * until we get a successful configuration. 1665 */ 1666 if (pl->major_config_failed) 1667 link_state.link = false; 1668 1669 if (link_state.link != cur_link_state) { 1670 pl->old_link_state = link_state.link; 1671 if (!link_state.link) 1672 phylink_link_down(pl); 1673 else 1674 phylink_link_up(pl, link_state); 1675 } 1676 if (!link_state.link && retrigger) { 1677 pl->link_failed = false; 1678 queue_work(system_power_efficient_wq, &pl->resolve); 1679 } 1680 mutex_unlock(&pl->state_mutex); 1681 } 1682 1683 static void phylink_run_resolve(struct phylink *pl) 1684 { 1685 if (!pl->phylink_disable_state) 1686 queue_work(system_power_efficient_wq, &pl->resolve); 1687 } 1688 1689 static void phylink_run_resolve_and_disable(struct phylink *pl, int bit) 1690 { 1691 unsigned long state = pl->phylink_disable_state; 1692 1693 set_bit(bit, &pl->phylink_disable_state); 1694 if (state == 0) { 1695 queue_work(system_power_efficient_wq, &pl->resolve); 1696 flush_work(&pl->resolve); 1697 } 1698 } 1699 1700 static void phylink_enable_and_run_resolve(struct phylink *pl, int bit) 1701 { 1702 clear_bit(bit, &pl->phylink_disable_state); 1703 phylink_run_resolve(pl); 1704 } 1705 1706 static void phylink_fixed_poll(struct timer_list *t) 1707 { 1708 struct phylink *pl = container_of(t, struct phylink, link_poll); 1709 1710 mod_timer(t, jiffies + HZ); 1711 1712 phylink_run_resolve(pl); 1713 } 1714 1715 static const struct sfp_upstream_ops sfp_phylink_ops; 1716 1717 static int phylink_register_sfp(struct phylink *pl, 1718 const struct fwnode_handle *fwnode) 1719 { 1720 struct sfp_bus *bus; 1721 int ret; 1722 1723 if (!fwnode) 1724 return 0; 1725 1726 bus = sfp_bus_find_fwnode(fwnode); 1727 if (IS_ERR(bus)) { 1728 phylink_err(pl, "unable to attach SFP bus: %pe\n", bus); 1729 return PTR_ERR(bus); 1730 } 1731 1732 pl->sfp_bus = bus; 1733 1734 ret = sfp_bus_add_upstream(bus, pl, &sfp_phylink_ops); 1735 sfp_bus_put(bus); 1736 1737 return ret; 1738 } 1739 1740 /** 1741 * phylink_set_fixed_link() - set the fixed link 1742 * @pl: a pointer to a &struct phylink returned from phylink_create() 1743 * @state: a pointer to a struct phylink_link_state. 1744 * 1745 * This function is used when the link parameters are known and do not change, 1746 * making it suitable for certain types of network connections. 1747 * 1748 * Returns: zero on success or negative error code. 1749 */ 1750 int phylink_set_fixed_link(struct phylink *pl, 1751 const struct phylink_link_state *state) 1752 { 1753 const struct link_capabilities *c; 1754 unsigned long *adv; 1755 1756 if (pl->cfg_link_an_mode != MLO_AN_PHY || !state || 1757 !test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) 1758 return -EINVAL; 1759 1760 c = phy_caps_lookup(state->speed, state->duplex, 1761 pl->supported, true); 1762 if (!c) 1763 return -EINVAL; 1764 1765 adv = pl->link_config.advertising; 1766 linkmode_and(adv, pl->supported, c->linkmodes); 1767 linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, adv); 1768 1769 pl->link_config.speed = state->speed; 1770 pl->link_config.duplex = state->duplex; 1771 pl->link_config.link = 1; 1772 pl->link_config.an_complete = 1; 1773 1774 pl->cfg_link_an_mode = MLO_AN_FIXED; 1775 pl->req_link_an_mode = pl->cfg_link_an_mode; 1776 1777 return 0; 1778 } 1779 EXPORT_SYMBOL_GPL(phylink_set_fixed_link); 1780 1781 /** 1782 * phylink_create() - create a phylink instance 1783 * @config: a pointer to the target &struct phylink_config 1784 * @fwnode: a pointer to a &struct fwnode_handle describing the network 1785 * interface 1786 * @iface: the desired link mode defined by &typedef phy_interface_t 1787 * @mac_ops: a pointer to a &struct phylink_mac_ops for the MAC. 1788 * 1789 * Create a new phylink instance, and parse the link parameters found in @np. 1790 * This will parse in-band modes, fixed-link or SFP configuration. 1791 * 1792 * Note: the rtnl lock must not be held when calling this function. 1793 * 1794 * Returns a pointer to a &struct phylink, or an error-pointer value. Users 1795 * must use IS_ERR() to check for errors from this function. 1796 */ 1797 struct phylink *phylink_create(struct phylink_config *config, 1798 const struct fwnode_handle *fwnode, 1799 phy_interface_t iface, 1800 const struct phylink_mac_ops *mac_ops) 1801 { 1802 struct phylink *pl; 1803 int ret; 1804 1805 /* Validate the supplied configuration */ 1806 if (phy_interface_empty(config->supported_interfaces)) { 1807 dev_err(config->dev, 1808 "phylink: error: empty supported_interfaces\n"); 1809 return ERR_PTR(-EINVAL); 1810 } 1811 1812 pl = kzalloc(sizeof(*pl), GFP_KERNEL); 1813 if (!pl) 1814 return ERR_PTR(-ENOMEM); 1815 1816 mutex_init(&pl->state_mutex); 1817 INIT_WORK(&pl->resolve, phylink_resolve); 1818 1819 pl->config = config; 1820 if (config->type == PHYLINK_NETDEV) { 1821 pl->netdev = to_net_dev(config->dev); 1822 netif_carrier_off(pl->netdev); 1823 } else if (config->type == PHYLINK_DEV) { 1824 pl->dev = config->dev; 1825 } else { 1826 kfree(pl); 1827 return ERR_PTR(-EINVAL); 1828 } 1829 1830 pl->mac_supports_eee_ops = phylink_mac_implements_lpi(mac_ops); 1831 pl->mac_supports_eee = pl->mac_supports_eee_ops && 1832 pl->config->lpi_capabilities && 1833 !phy_interface_empty(pl->config->lpi_interfaces); 1834 1835 /* Set the default EEE configuration */ 1836 pl->eee_cfg.eee_enabled = pl->config->eee_enabled_default; 1837 pl->eee_cfg.tx_lpi_enabled = pl->eee_cfg.eee_enabled; 1838 pl->eee_cfg.tx_lpi_timer = pl->config->lpi_timer_default; 1839 1840 pl->phy_state.interface = iface; 1841 pl->link_interface = iface; 1842 if (iface == PHY_INTERFACE_MODE_MOCA) 1843 pl->link_port = PORT_BNC; 1844 else 1845 pl->link_port = PORT_MII; 1846 pl->link_config.interface = iface; 1847 pl->link_config.pause = MLO_PAUSE_AN; 1848 pl->link_config.speed = SPEED_UNKNOWN; 1849 pl->link_config.duplex = DUPLEX_UNKNOWN; 1850 pl->pcs_state = PCS_STATE_DOWN; 1851 pl->mac_ops = mac_ops; 1852 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 1853 timer_setup(&pl->link_poll, phylink_fixed_poll, 0); 1854 1855 linkmode_fill(pl->supported); 1856 linkmode_copy(pl->link_config.advertising, pl->supported); 1857 phylink_validate(pl, pl->supported, &pl->link_config); 1858 1859 ret = phylink_parse_mode(pl, fwnode); 1860 if (ret < 0) { 1861 kfree(pl); 1862 return ERR_PTR(ret); 1863 } 1864 1865 if (pl->cfg_link_an_mode == MLO_AN_FIXED) { 1866 ret = phylink_parse_fixedlink(pl, fwnode); 1867 if (ret < 0) { 1868 kfree(pl); 1869 return ERR_PTR(ret); 1870 } 1871 } 1872 1873 pl->req_link_an_mode = pl->cfg_link_an_mode; 1874 1875 ret = phylink_register_sfp(pl, fwnode); 1876 if (ret < 0) { 1877 kfree(pl); 1878 return ERR_PTR(ret); 1879 } 1880 1881 return pl; 1882 } 1883 EXPORT_SYMBOL_GPL(phylink_create); 1884 1885 /** 1886 * phylink_destroy() - cleanup and destroy the phylink instance 1887 * @pl: a pointer to a &struct phylink returned from phylink_create() 1888 * 1889 * Destroy a phylink instance. Any PHY that has been attached must have been 1890 * cleaned up via phylink_disconnect_phy() prior to calling this function. 1891 * 1892 * Note: the rtnl lock must not be held when calling this function. 1893 */ 1894 void phylink_destroy(struct phylink *pl) 1895 { 1896 sfp_bus_del_upstream(pl->sfp_bus); 1897 if (pl->link_gpio) 1898 gpiod_put(pl->link_gpio); 1899 1900 cancel_work_sync(&pl->resolve); 1901 kfree(pl); 1902 } 1903 EXPORT_SYMBOL_GPL(phylink_destroy); 1904 1905 /** 1906 * phylink_expects_phy() - Determine if phylink expects a phy to be attached 1907 * @pl: a pointer to a &struct phylink returned from phylink_create() 1908 * 1909 * When using fixed-link mode, or in-band mode with 1000base-X or 2500base-X, 1910 * no PHY is needed. 1911 * 1912 * Returns true if phylink will be expecting a PHY. 1913 */ 1914 bool phylink_expects_phy(struct phylink *pl) 1915 { 1916 if (pl->cfg_link_an_mode == MLO_AN_FIXED || 1917 (pl->cfg_link_an_mode == MLO_AN_INBAND && 1918 phy_interface_mode_is_8023z(pl->link_interface))) 1919 return false; 1920 return true; 1921 } 1922 EXPORT_SYMBOL_GPL(phylink_expects_phy); 1923 1924 static void phylink_phy_change(struct phy_device *phydev, bool up) 1925 { 1926 struct phylink *pl = phydev->phylink; 1927 bool tx_pause, rx_pause; 1928 1929 phy_get_pause(phydev, &tx_pause, &rx_pause); 1930 1931 mutex_lock(&pl->state_mutex); 1932 pl->phy_state.speed = phydev->speed; 1933 pl->phy_state.duplex = phydev->duplex; 1934 pl->phy_state.rate_matching = phydev->rate_matching; 1935 pl->phy_state.pause = MLO_PAUSE_NONE; 1936 if (tx_pause) 1937 pl->phy_state.pause |= MLO_PAUSE_TX; 1938 if (rx_pause) 1939 pl->phy_state.pause |= MLO_PAUSE_RX; 1940 pl->phy_state.interface = phydev->interface; 1941 pl->phy_state.link = up; 1942 if (!up) 1943 pl->link_failed = true; 1944 1945 /* Get the LPI state from phylib */ 1946 pl->phy_enable_tx_lpi = phydev->enable_tx_lpi; 1947 pl->mac_tx_lpi_timer = phydev->eee_cfg.tx_lpi_timer; 1948 mutex_unlock(&pl->state_mutex); 1949 1950 phylink_run_resolve(pl); 1951 1952 phylink_dbg(pl, "phy link %s %s/%s/%s/%s/%s/%slpi\n", 1953 up ? "up" : "down", 1954 phy_modes(phydev->interface), 1955 phy_speed_to_str(phydev->speed), 1956 phy_duplex_to_str(phydev->duplex), 1957 phy_rate_matching_to_str(phydev->rate_matching), 1958 phylink_pause_to_str(pl->phy_state.pause), 1959 phydev->enable_tx_lpi ? "" : "no"); 1960 } 1961 1962 static int phylink_validate_phy(struct phylink *pl, struct phy_device *phy, 1963 unsigned long *supported, 1964 struct phylink_link_state *state) 1965 { 1966 DECLARE_PHY_INTERFACE_MASK(interfaces); 1967 1968 /* If the PHY provides a bitmap of the interfaces it will be using 1969 * depending on the negotiated media speeds, use this to validate 1970 * which ethtool link modes can be used. 1971 */ 1972 if (!phy_interface_empty(phy->possible_interfaces)) { 1973 /* We only care about the union of the PHY's interfaces and 1974 * those which the host supports. 1975 */ 1976 phy_interface_and(interfaces, phy->possible_interfaces, 1977 pl->config->supported_interfaces); 1978 1979 if (phy_interface_empty(interfaces)) { 1980 phylink_err(pl, "PHY has no common interfaces\n"); 1981 return -EINVAL; 1982 } 1983 1984 if (phy_on_sfp(phy)) { 1985 /* If the PHY is on a SFP, limit the interfaces to 1986 * those that can be used with a SFP module. 1987 */ 1988 phy_interface_and(interfaces, interfaces, 1989 phylink_sfp_interfaces); 1990 1991 if (phy_interface_empty(interfaces)) { 1992 phylink_err(pl, "SFP PHY's possible interfaces becomes empty\n"); 1993 return -EINVAL; 1994 } 1995 } 1996 1997 phylink_dbg(pl, "PHY %s uses interfaces %*pbl, validating %*pbl\n", 1998 phydev_name(phy), 1999 (int)PHY_INTERFACE_MODE_MAX, 2000 phy->possible_interfaces, 2001 (int)PHY_INTERFACE_MODE_MAX, interfaces); 2002 2003 return phylink_validate_mask(pl, phy, supported, state, 2004 interfaces); 2005 } 2006 2007 phylink_dbg(pl, "PHY %s doesn't supply possible interfaces\n", 2008 phydev_name(phy)); 2009 2010 /* Check whether we would use rate matching for the proposed interface 2011 * mode. 2012 */ 2013 state->rate_matching = phy_get_rate_matching(phy, state->interface); 2014 2015 /* Clause 45 PHYs may switch their Serdes lane between, e.g. 10GBASE-R, 2016 * 5GBASE-R, 2500BASE-X and SGMII if they are not using rate matching. 2017 * For some interface modes (e.g. RXAUI, XAUI and USXGMII) switching 2018 * their Serdes is either unnecessary or not reasonable. 2019 * 2020 * For these which switch interface modes, we really need to know which 2021 * interface modes the PHY supports to properly work out which ethtool 2022 * linkmodes can be supported. For now, as a work-around, we validate 2023 * against all interface modes, which may lead to more ethtool link 2024 * modes being advertised than are actually supported. 2025 */ 2026 if (phy->is_c45 && state->rate_matching == RATE_MATCH_NONE && 2027 state->interface != PHY_INTERFACE_MODE_RXAUI && 2028 state->interface != PHY_INTERFACE_MODE_XAUI && 2029 state->interface != PHY_INTERFACE_MODE_USXGMII) 2030 state->interface = PHY_INTERFACE_MODE_NA; 2031 2032 return phylink_validate(pl, supported, state); 2033 } 2034 2035 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy, 2036 phy_interface_t interface) 2037 { 2038 struct phylink_link_state config; 2039 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 2040 char *irq_str; 2041 int ret; 2042 2043 /* 2044 * This is the new way of dealing with flow control for PHYs, 2045 * as described by Timur Tabi in commit 529ed1275263 ("net: phy: 2046 * phy drivers should not set SUPPORTED_[Asym_]Pause") except 2047 * using our validate call to the MAC, we rely upon the MAC 2048 * clearing the bits from both supported and advertising fields. 2049 */ 2050 phy_support_asym_pause(phy); 2051 2052 memset(&config, 0, sizeof(config)); 2053 linkmode_copy(supported, phy->supported); 2054 linkmode_copy(config.advertising, phy->advertising); 2055 config.interface = interface; 2056 2057 ret = phylink_validate_phy(pl, phy, supported, &config); 2058 if (ret) { 2059 phylink_warn(pl, "validation of %s with support %*pb and advertisement %*pb failed: %pe\n", 2060 phy_modes(config.interface), 2061 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->supported, 2062 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising, 2063 ERR_PTR(ret)); 2064 return ret; 2065 } 2066 2067 phy->phylink = pl; 2068 phy->phy_link_change = phylink_phy_change; 2069 2070 irq_str = phy_attached_info_irq(phy); 2071 phylink_info(pl, 2072 "PHY [%s] driver [%s] (irq=%s)\n", 2073 dev_name(&phy->mdio.dev), phy->drv->name, irq_str); 2074 kfree(irq_str); 2075 2076 mutex_lock(&phy->lock); 2077 mutex_lock(&pl->state_mutex); 2078 pl->phydev = phy; 2079 pl->phy_state.interface = interface; 2080 pl->phy_state.pause = MLO_PAUSE_NONE; 2081 pl->phy_state.speed = SPEED_UNKNOWN; 2082 pl->phy_state.duplex = DUPLEX_UNKNOWN; 2083 pl->phy_state.rate_matching = RATE_MATCH_NONE; 2084 linkmode_copy(pl->supported, supported); 2085 linkmode_copy(pl->link_config.advertising, config.advertising); 2086 2087 /* Restrict the phy advertisement according to the MAC support. */ 2088 linkmode_copy(phy->advertising, config.advertising); 2089 2090 /* If the MAC supports phylink managed EEE, restrict the EEE 2091 * advertisement according to the MAC's LPI capabilities. 2092 */ 2093 if (pl->mac_supports_eee) { 2094 /* If EEE is enabled, then we need to call phy_support_eee() 2095 * to ensure that the advertising mask is appropriately set. 2096 * This also enables EEE at the PHY. 2097 */ 2098 if (pl->eee_cfg.eee_enabled) 2099 phy_support_eee(phy); 2100 2101 phy->eee_cfg.tx_lpi_enabled = pl->eee_cfg.tx_lpi_enabled; 2102 phy->eee_cfg.tx_lpi_timer = pl->eee_cfg.tx_lpi_timer; 2103 2104 /* Convert the MAC's LPI capabilities to linkmodes */ 2105 linkmode_zero(pl->supported_lpi); 2106 phylink_caps_to_linkmodes(pl->supported_lpi, 2107 pl->config->lpi_capabilities); 2108 2109 /* Restrict the PHYs EEE support/advertisement to the modes 2110 * that the MAC supports. 2111 */ 2112 linkmode_and(phy->advertising_eee, phy->advertising_eee, 2113 pl->supported_lpi); 2114 } else if (pl->mac_supports_eee_ops) { 2115 /* MAC supports phylink EEE, but wants EEE always disabled. */ 2116 phy_disable_eee(phy); 2117 } 2118 2119 mutex_unlock(&pl->state_mutex); 2120 mutex_unlock(&phy->lock); 2121 2122 phylink_dbg(pl, 2123 "phy: %s setting supported %*pb advertising %*pb\n", 2124 phy_modes(interface), 2125 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported, 2126 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->advertising); 2127 2128 if (phy_interrupt_is_valid(phy)) 2129 phy_request_interrupt(phy); 2130 2131 if (pl->config->mac_managed_pm) 2132 phy->mac_managed_pm = true; 2133 2134 /* Allow the MAC to stop its clock if the PHY has the capability */ 2135 pl->mac_tx_clk_stop = phy_eee_tx_clock_stop_capable(phy) > 0; 2136 2137 if (pl->mac_supports_eee_ops) { 2138 /* Explicitly configure whether the PHY is allowed to stop it's 2139 * receive clock. 2140 */ 2141 ret = phy_eee_rx_clock_stop(phy, 2142 pl->config->eee_rx_clk_stop_enable); 2143 if (ret == -EOPNOTSUPP) 2144 ret = 0; 2145 } 2146 2147 return ret; 2148 } 2149 2150 static int phylink_attach_phy(struct phylink *pl, struct phy_device *phy, 2151 phy_interface_t interface) 2152 { 2153 u32 flags = 0; 2154 2155 if (WARN_ON(pl->cfg_link_an_mode == MLO_AN_FIXED || 2156 (pl->cfg_link_an_mode == MLO_AN_INBAND && 2157 phy_interface_mode_is_8023z(interface) && !pl->sfp_bus))) 2158 return -EINVAL; 2159 2160 if (pl->phydev) 2161 return -EBUSY; 2162 2163 if (pl->config->mac_requires_rxc) 2164 flags |= PHY_F_RXC_ALWAYS_ON; 2165 2166 return phy_attach_direct(pl->netdev, phy, flags, interface); 2167 } 2168 2169 /** 2170 * phylink_connect_phy() - connect a PHY to the phylink instance 2171 * @pl: a pointer to a &struct phylink returned from phylink_create() 2172 * @phy: a pointer to a &struct phy_device. 2173 * 2174 * Connect @phy to the phylink instance specified by @pl by calling 2175 * phy_attach_direct(). Configure the @phy according to the MAC driver's 2176 * capabilities, start the PHYLIB state machine and enable any interrupts 2177 * that the PHY supports. 2178 * 2179 * This updates the phylink's ethtool supported and advertising link mode 2180 * masks. 2181 * 2182 * Returns 0 on success or a negative errno. 2183 */ 2184 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy) 2185 { 2186 int ret; 2187 2188 /* Use PHY device/driver interface */ 2189 if (pl->link_interface == PHY_INTERFACE_MODE_NA) { 2190 pl->link_interface = phy->interface; 2191 pl->link_config.interface = pl->link_interface; 2192 } 2193 2194 ret = phylink_attach_phy(pl, phy, pl->link_interface); 2195 if (ret < 0) 2196 return ret; 2197 2198 ret = phylink_bringup_phy(pl, phy, pl->link_config.interface); 2199 if (ret) 2200 phy_detach(phy); 2201 2202 return ret; 2203 } 2204 EXPORT_SYMBOL_GPL(phylink_connect_phy); 2205 2206 /** 2207 * phylink_of_phy_connect() - connect the PHY specified in the DT mode. 2208 * @pl: a pointer to a &struct phylink returned from phylink_create() 2209 * @dn: a pointer to a &struct device_node. 2210 * @flags: PHY-specific flags to communicate to the PHY device driver 2211 * 2212 * Connect the phy specified in the device node @dn to the phylink instance 2213 * specified by @pl. Actions specified in phylink_connect_phy() will be 2214 * performed. 2215 * 2216 * Returns 0 on success or a negative errno. 2217 */ 2218 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn, 2219 u32 flags) 2220 { 2221 return phylink_fwnode_phy_connect(pl, of_fwnode_handle(dn), flags); 2222 } 2223 EXPORT_SYMBOL_GPL(phylink_of_phy_connect); 2224 2225 /** 2226 * phylink_fwnode_phy_connect() - connect the PHY specified in the fwnode. 2227 * @pl: a pointer to a &struct phylink returned from phylink_create() 2228 * @fwnode: a pointer to a &struct fwnode_handle. 2229 * @flags: PHY-specific flags to communicate to the PHY device driver 2230 * 2231 * Connect the phy specified @fwnode to the phylink instance specified 2232 * by @pl. 2233 * 2234 * Returns 0 on success or a negative errno. 2235 */ 2236 int phylink_fwnode_phy_connect(struct phylink *pl, 2237 const struct fwnode_handle *fwnode, 2238 u32 flags) 2239 { 2240 struct fwnode_handle *phy_fwnode; 2241 struct phy_device *phy_dev; 2242 int ret; 2243 2244 /* Fixed links and 802.3z are handled without needing a PHY */ 2245 if (pl->cfg_link_an_mode == MLO_AN_FIXED || 2246 (pl->cfg_link_an_mode == MLO_AN_INBAND && 2247 phy_interface_mode_is_8023z(pl->link_interface))) 2248 return 0; 2249 2250 phy_fwnode = fwnode_get_phy_node(fwnode); 2251 if (IS_ERR(phy_fwnode)) { 2252 if (pl->cfg_link_an_mode == MLO_AN_PHY) 2253 return -ENODEV; 2254 return 0; 2255 } 2256 2257 phy_dev = fwnode_phy_find_device(phy_fwnode); 2258 /* We're done with the phy_node handle */ 2259 fwnode_handle_put(phy_fwnode); 2260 if (!phy_dev) 2261 return -ENODEV; 2262 2263 /* Use PHY device/driver interface */ 2264 if (pl->link_interface == PHY_INTERFACE_MODE_NA) { 2265 pl->link_interface = phy_dev->interface; 2266 pl->link_config.interface = pl->link_interface; 2267 } 2268 2269 if (pl->config->mac_requires_rxc) 2270 flags |= PHY_F_RXC_ALWAYS_ON; 2271 2272 ret = phy_attach_direct(pl->netdev, phy_dev, flags, 2273 pl->link_interface); 2274 phy_device_free(phy_dev); 2275 if (ret) 2276 return ret; 2277 2278 ret = phylink_bringup_phy(pl, phy_dev, pl->link_config.interface); 2279 if (ret) 2280 phy_detach(phy_dev); 2281 2282 return ret; 2283 } 2284 EXPORT_SYMBOL_GPL(phylink_fwnode_phy_connect); 2285 2286 /** 2287 * phylink_disconnect_phy() - disconnect any PHY attached to the phylink 2288 * instance. 2289 * @pl: a pointer to a &struct phylink returned from phylink_create() 2290 * 2291 * Disconnect any current PHY from the phylink instance described by @pl. 2292 */ 2293 void phylink_disconnect_phy(struct phylink *pl) 2294 { 2295 struct phy_device *phy; 2296 2297 ASSERT_RTNL(); 2298 2299 phy = pl->phydev; 2300 if (phy) { 2301 mutex_lock(&phy->lock); 2302 mutex_lock(&pl->state_mutex); 2303 pl->phydev = NULL; 2304 pl->phy_enable_tx_lpi = false; 2305 pl->mac_tx_clk_stop = false; 2306 mutex_unlock(&pl->state_mutex); 2307 mutex_unlock(&phy->lock); 2308 flush_work(&pl->resolve); 2309 2310 phy_disconnect(phy); 2311 } 2312 } 2313 EXPORT_SYMBOL_GPL(phylink_disconnect_phy); 2314 2315 static void phylink_link_changed(struct phylink *pl, bool up, const char *what) 2316 { 2317 if (!up) 2318 pl->link_failed = true; 2319 phylink_run_resolve(pl); 2320 phylink_dbg(pl, "%s link %s\n", what, up ? "up" : "down"); 2321 } 2322 2323 /** 2324 * phylink_mac_change() - notify phylink of a change in MAC state 2325 * @pl: a pointer to a &struct phylink returned from phylink_create() 2326 * @up: indicates whether the link is currently up. 2327 * 2328 * The MAC driver should call this driver when the state of its link 2329 * changes (eg, link failure, new negotiation results, etc.) 2330 */ 2331 void phylink_mac_change(struct phylink *pl, bool up) 2332 { 2333 phylink_link_changed(pl, up, "mac"); 2334 } 2335 EXPORT_SYMBOL_GPL(phylink_mac_change); 2336 2337 /** 2338 * phylink_pcs_change() - notify phylink of a change to PCS link state 2339 * @pcs: pointer to &struct phylink_pcs 2340 * @up: indicates whether the link is currently up. 2341 * 2342 * The PCS driver should call this when the state of its link changes 2343 * (e.g. link failure, new negotiation results, etc.) Note: it should 2344 * not determine "up" by reading the BMSR. If in doubt about the link 2345 * state at interrupt time, then pass true if pcs_get_state() returns 2346 * the latched link-down state, otherwise pass false. 2347 */ 2348 void phylink_pcs_change(struct phylink_pcs *pcs, bool up) 2349 { 2350 struct phylink *pl = pcs->phylink; 2351 2352 if (pl) 2353 phylink_link_changed(pl, up, "pcs"); 2354 } 2355 EXPORT_SYMBOL_GPL(phylink_pcs_change); 2356 2357 static irqreturn_t phylink_link_handler(int irq, void *data) 2358 { 2359 struct phylink *pl = data; 2360 2361 phylink_run_resolve(pl); 2362 2363 return IRQ_HANDLED; 2364 } 2365 2366 /** 2367 * phylink_start() - start a phylink instance 2368 * @pl: a pointer to a &struct phylink returned from phylink_create() 2369 * 2370 * Start the phylink instance specified by @pl, configuring the MAC for the 2371 * desired link mode(s) and negotiation style. This should be called from the 2372 * network device driver's &struct net_device_ops ndo_open() method. 2373 */ 2374 void phylink_start(struct phylink *pl) 2375 { 2376 bool poll = false; 2377 2378 ASSERT_RTNL(); 2379 2380 phylink_info(pl, "configuring for %s/%s link mode\n", 2381 phylink_an_mode_str(pl->req_link_an_mode), 2382 phy_modes(pl->link_config.interface)); 2383 2384 /* Always set the carrier off */ 2385 if (pl->netdev) 2386 netif_carrier_off(pl->netdev); 2387 2388 pl->pcs_state = PCS_STATE_STARTING; 2389 2390 /* Apply the link configuration to the MAC when starting. This allows 2391 * a fixed-link to start with the correct parameters, and also 2392 * ensures that we set the appropriate advertisement for Serdes links. 2393 * 2394 * Restart autonegotiation if using 802.3z to ensure that the link 2395 * parameters are properly negotiated. This is necessary for DSA 2396 * switches using 802.3z negotiation to ensure they see our modes. 2397 */ 2398 phylink_mac_initial_config(pl, true); 2399 2400 pl->pcs_state = PCS_STATE_STARTED; 2401 2402 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_STOPPED); 2403 2404 if (pl->cfg_link_an_mode == MLO_AN_FIXED && pl->link_gpio) { 2405 int irq = gpiod_to_irq(pl->link_gpio); 2406 2407 if (irq > 0) { 2408 if (!request_irq(irq, phylink_link_handler, 2409 IRQF_TRIGGER_RISING | 2410 IRQF_TRIGGER_FALLING, 2411 "netdev link", pl)) 2412 pl->link_irq = irq; 2413 else 2414 irq = 0; 2415 } 2416 if (irq <= 0) 2417 poll = true; 2418 } 2419 2420 if (pl->cfg_link_an_mode == MLO_AN_FIXED) 2421 poll |= pl->config->poll_fixed_state; 2422 2423 if (poll) 2424 mod_timer(&pl->link_poll, jiffies + HZ); 2425 if (pl->phydev) 2426 phy_start(pl->phydev); 2427 if (pl->sfp_bus) 2428 sfp_upstream_start(pl->sfp_bus); 2429 } 2430 EXPORT_SYMBOL_GPL(phylink_start); 2431 2432 /** 2433 * phylink_stop() - stop a phylink instance 2434 * @pl: a pointer to a &struct phylink returned from phylink_create() 2435 * 2436 * Stop the phylink instance specified by @pl. This should be called from the 2437 * network device driver's &struct net_device_ops ndo_stop() method. The 2438 * network device's carrier state should not be changed prior to calling this 2439 * function. 2440 * 2441 * This will synchronously bring down the link if the link is not already 2442 * down (in other words, it will trigger a mac_link_down() method call.) 2443 */ 2444 void phylink_stop(struct phylink *pl) 2445 { 2446 ASSERT_RTNL(); 2447 2448 if (pl->sfp_bus) 2449 sfp_upstream_stop(pl->sfp_bus); 2450 if (pl->phydev) 2451 phy_stop(pl->phydev); 2452 timer_delete_sync(&pl->link_poll); 2453 if (pl->link_irq) { 2454 free_irq(pl->link_irq, pl); 2455 pl->link_irq = 0; 2456 } 2457 2458 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED); 2459 2460 pl->pcs_state = PCS_STATE_DOWN; 2461 2462 phylink_pcs_disable(pl->pcs); 2463 } 2464 EXPORT_SYMBOL_GPL(phylink_stop); 2465 2466 /** 2467 * phylink_rx_clk_stop_block() - block PHY ability to stop receive clock in LPI 2468 * @pl: a pointer to a &struct phylink returned from phylink_create() 2469 * 2470 * Disable the PHY's ability to stop the receive clock while the receive path 2471 * is in EEE LPI state, until the number of calls to phylink_rx_clk_stop_block() 2472 * are balanced by calls to phylink_rx_clk_stop_unblock(). 2473 */ 2474 void phylink_rx_clk_stop_block(struct phylink *pl) 2475 { 2476 ASSERT_RTNL(); 2477 2478 if (pl->mac_rx_clk_stop_blocked == U8_MAX) { 2479 phylink_warn(pl, "%s called too many times - ignoring\n", 2480 __func__); 2481 dump_stack(); 2482 return; 2483 } 2484 2485 /* Disable PHY receive clock stop if this is the first time this 2486 * function has been called and clock-stop was previously enabled. 2487 */ 2488 if (pl->mac_rx_clk_stop_blocked++ == 0 && 2489 pl->mac_supports_eee_ops && pl->phydev && 2490 pl->config->eee_rx_clk_stop_enable) 2491 phy_eee_rx_clock_stop(pl->phydev, false); 2492 } 2493 EXPORT_SYMBOL_GPL(phylink_rx_clk_stop_block); 2494 2495 /** 2496 * phylink_rx_clk_stop_unblock() - unblock PHY ability to stop receive clock 2497 * @pl: a pointer to a &struct phylink returned from phylink_create() 2498 * 2499 * All calls to phylink_rx_clk_stop_block() must be balanced with a 2500 * corresponding call to phylink_rx_clk_stop_unblock() to restore the PHYs 2501 * ability to stop the receive clock when the receive path is in EEE LPI mode. 2502 */ 2503 void phylink_rx_clk_stop_unblock(struct phylink *pl) 2504 { 2505 ASSERT_RTNL(); 2506 2507 if (pl->mac_rx_clk_stop_blocked == 0) { 2508 phylink_warn(pl, "%s called too many times - ignoring\n", 2509 __func__); 2510 dump_stack(); 2511 return; 2512 } 2513 2514 /* Re-enable PHY receive clock stop if the number of unblocks matches 2515 * the number of calls to the block function above. 2516 */ 2517 if (--pl->mac_rx_clk_stop_blocked == 0 && 2518 pl->mac_supports_eee_ops && pl->phydev && 2519 pl->config->eee_rx_clk_stop_enable) 2520 phy_eee_rx_clock_stop(pl->phydev, true); 2521 } 2522 EXPORT_SYMBOL_GPL(phylink_rx_clk_stop_unblock); 2523 2524 /** 2525 * phylink_suspend() - handle a network device suspend event 2526 * @pl: a pointer to a &struct phylink returned from phylink_create() 2527 * @mac_wol: true if the MAC needs to receive packets for Wake-on-Lan 2528 * 2529 * Handle a network device suspend event. There are several cases: 2530 * 2531 * - If Wake-on-Lan is not active, we can bring down the link between 2532 * the MAC and PHY by calling phylink_stop(). 2533 * - If Wake-on-Lan is active, and being handled only by the PHY, we 2534 * can also bring down the link between the MAC and PHY. 2535 * - If Wake-on-Lan is active, but being handled by the MAC, the MAC 2536 * still needs to receive packets, so we can not bring the link down. 2537 */ 2538 void phylink_suspend(struct phylink *pl, bool mac_wol) 2539 { 2540 ASSERT_RTNL(); 2541 2542 if (mac_wol && (!pl->netdev || pl->netdev->ethtool->wol_enabled)) { 2543 /* Wake-on-Lan enabled, MAC handling */ 2544 mutex_lock(&pl->state_mutex); 2545 2546 /* Stop the resolver bringing the link up */ 2547 __set_bit(PHYLINK_DISABLE_MAC_WOL, &pl->phylink_disable_state); 2548 2549 pl->suspend_link_up = phylink_link_is_up(pl); 2550 if (pl->suspend_link_up) { 2551 /* Disable the carrier, to prevent transmit timeouts, 2552 * but one would hope all packets have been sent. This 2553 * also means phylink_resolve() will do nothing. 2554 */ 2555 if (pl->netdev) 2556 netif_carrier_off(pl->netdev); 2557 pl->old_link_state = false; 2558 } 2559 2560 /* We do not call mac_link_down() here as we want the 2561 * link to remain up to receive the WoL packets. 2562 */ 2563 mutex_unlock(&pl->state_mutex); 2564 } else { 2565 phylink_stop(pl); 2566 } 2567 } 2568 EXPORT_SYMBOL_GPL(phylink_suspend); 2569 2570 /** 2571 * phylink_prepare_resume() - prepare to resume a network device 2572 * @pl: a pointer to a &struct phylink returned from phylink_create() 2573 * 2574 * Optional, but if called must be called prior to phylink_resume(). 2575 * 2576 * Prepare to resume a network device, preparing the PHY as necessary. 2577 */ 2578 void phylink_prepare_resume(struct phylink *pl) 2579 { 2580 struct phy_device *phydev = pl->phydev; 2581 2582 ASSERT_RTNL(); 2583 2584 /* IEEE 802.3 22.2.4.1.5 allows PHYs to stop their receive clock 2585 * when PDOWN is set. However, some MACs require RXC to be running 2586 * in order to resume. If the MAC requires RXC, and we have a PHY, 2587 * then resume the PHY. Note that 802.3 allows PHYs 500ms before 2588 * the clock meets requirements. We do not implement this delay. 2589 */ 2590 if (pl->config->mac_requires_rxc && phydev && phydev->suspended) 2591 phy_resume(phydev); 2592 } 2593 EXPORT_SYMBOL_GPL(phylink_prepare_resume); 2594 2595 /** 2596 * phylink_resume() - handle a network device resume event 2597 * @pl: a pointer to a &struct phylink returned from phylink_create() 2598 * 2599 * Undo the effects of phylink_suspend(), returning the link to an 2600 * operational state. 2601 */ 2602 void phylink_resume(struct phylink *pl) 2603 { 2604 ASSERT_RTNL(); 2605 2606 if (test_bit(PHYLINK_DISABLE_MAC_WOL, &pl->phylink_disable_state)) { 2607 /* Wake-on-Lan enabled, MAC handling */ 2608 2609 if (pl->suspend_link_up) { 2610 /* Call mac_link_down() so we keep the overall state 2611 * balanced. Do this under the state_mutex lock for 2612 * consistency. This will cause a "Link Down" message 2613 * to be printed during resume, which is harmless - 2614 * the true link state will be printed when we run a 2615 * resolve. 2616 */ 2617 mutex_lock(&pl->state_mutex); 2618 phylink_link_down(pl); 2619 mutex_unlock(&pl->state_mutex); 2620 } 2621 2622 /* Re-apply the link parameters so that all the settings get 2623 * restored to the MAC. 2624 */ 2625 phylink_mac_initial_config(pl, true); 2626 2627 /* Re-enable and re-resolve the link parameters */ 2628 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_MAC_WOL); 2629 } else { 2630 phylink_start(pl); 2631 } 2632 } 2633 EXPORT_SYMBOL_GPL(phylink_resume); 2634 2635 /** 2636 * phylink_ethtool_get_wol() - get the wake on lan parameters for the PHY 2637 * @pl: a pointer to a &struct phylink returned from phylink_create() 2638 * @wol: a pointer to &struct ethtool_wolinfo to hold the read parameters 2639 * 2640 * Read the wake on lan parameters from the PHY attached to the phylink 2641 * instance specified by @pl. If no PHY is currently attached, report no 2642 * support for wake on lan. 2643 */ 2644 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 2645 { 2646 ASSERT_RTNL(); 2647 2648 wol->supported = 0; 2649 wol->wolopts = 0; 2650 2651 if (pl->phydev) 2652 phy_ethtool_get_wol(pl->phydev, wol); 2653 } 2654 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol); 2655 2656 /** 2657 * phylink_ethtool_set_wol() - set wake on lan parameters 2658 * @pl: a pointer to a &struct phylink returned from phylink_create() 2659 * @wol: a pointer to &struct ethtool_wolinfo for the desired parameters 2660 * 2661 * Set the wake on lan parameters for the PHY attached to the phylink 2662 * instance specified by @pl. If no PHY is attached, returns %EOPNOTSUPP 2663 * error. 2664 * 2665 * Returns zero on success or negative errno code. 2666 */ 2667 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 2668 { 2669 int ret = -EOPNOTSUPP; 2670 2671 ASSERT_RTNL(); 2672 2673 if (pl->phydev) 2674 ret = phy_ethtool_set_wol(pl->phydev, wol); 2675 2676 return ret; 2677 } 2678 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol); 2679 2680 static phy_interface_t phylink_sfp_select_interface(struct phylink *pl, 2681 const unsigned long *link_modes) 2682 { 2683 phy_interface_t interface; 2684 2685 interface = sfp_select_interface(pl->sfp_bus, link_modes); 2686 if (interface == PHY_INTERFACE_MODE_NA) { 2687 phylink_err(pl, 2688 "selection of interface failed, advertisement %*pb\n", 2689 __ETHTOOL_LINK_MODE_MASK_NBITS, 2690 link_modes); 2691 return interface; 2692 } 2693 2694 if (!test_bit(interface, pl->config->supported_interfaces)) { 2695 phylink_err(pl, 2696 "selection of interface failed, SFP selected %s (%u) but MAC supports %*pbl\n", 2697 phy_modes(interface), interface, 2698 (int)PHY_INTERFACE_MODE_MAX, 2699 pl->config->supported_interfaces); 2700 return PHY_INTERFACE_MODE_NA; 2701 } 2702 2703 return interface; 2704 } 2705 2706 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b) 2707 { 2708 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask); 2709 2710 linkmode_zero(mask); 2711 phylink_set_port_modes(mask); 2712 2713 linkmode_and(dst, dst, mask); 2714 linkmode_or(dst, dst, b); 2715 } 2716 2717 static void phylink_get_ksettings(const struct phylink_link_state *state, 2718 struct ethtool_link_ksettings *kset) 2719 { 2720 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising); 2721 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising); 2722 if (kset->base.rate_matching == RATE_MATCH_NONE) { 2723 kset->base.speed = state->speed; 2724 kset->base.duplex = state->duplex; 2725 } 2726 kset->base.autoneg = linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 2727 state->advertising) ? 2728 AUTONEG_ENABLE : AUTONEG_DISABLE; 2729 } 2730 2731 /** 2732 * phylink_ethtool_ksettings_get() - get the current link settings 2733 * @pl: a pointer to a &struct phylink returned from phylink_create() 2734 * @kset: a pointer to a &struct ethtool_link_ksettings to hold link settings 2735 * 2736 * Read the current link settings for the phylink instance specified by @pl. 2737 * This will be the link settings read from the MAC, PHY or fixed link 2738 * settings depending on the current negotiation mode. 2739 */ 2740 int phylink_ethtool_ksettings_get(struct phylink *pl, 2741 struct ethtool_link_ksettings *kset) 2742 { 2743 struct phylink_link_state link_state; 2744 2745 ASSERT_RTNL(); 2746 2747 if (pl->phydev) 2748 phy_ethtool_ksettings_get(pl->phydev, kset); 2749 else 2750 kset->base.port = pl->link_port; 2751 2752 linkmode_copy(kset->link_modes.supported, pl->supported); 2753 2754 switch (pl->act_link_an_mode) { 2755 case MLO_AN_FIXED: 2756 /* We are using fixed settings. Report these as the 2757 * current link settings - and note that these also 2758 * represent the supported speeds/duplex/pause modes. 2759 */ 2760 phylink_get_fixed_state(pl, &link_state); 2761 phylink_get_ksettings(&link_state, kset); 2762 break; 2763 2764 case MLO_AN_INBAND: 2765 /* If there is a phy attached, then use the reported 2766 * settings from the phy with no modification. 2767 */ 2768 if (pl->phydev) 2769 break; 2770 2771 phylink_mac_pcs_get_state(pl, &link_state); 2772 2773 /* The MAC is reporting the link results from its own PCS 2774 * layer via in-band status. Report these as the current 2775 * link settings. 2776 */ 2777 phylink_get_ksettings(&link_state, kset); 2778 break; 2779 } 2780 2781 return 0; 2782 } 2783 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get); 2784 2785 static bool phylink_validate_pcs_inband_autoneg(struct phylink *pl, 2786 phy_interface_t interface, 2787 unsigned long *adv) 2788 { 2789 unsigned int inband = phylink_inband_caps(pl, interface); 2790 unsigned int mask; 2791 2792 /* If the PCS doesn't implement inband support, be permissive. */ 2793 if (!inband) 2794 return true; 2795 2796 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, adv)) 2797 mask = LINK_INBAND_ENABLE; 2798 else 2799 mask = LINK_INBAND_DISABLE; 2800 2801 /* Check whether the PCS implements the required mode */ 2802 return !!(inband & mask); 2803 } 2804 2805 /** 2806 * phylink_ethtool_ksettings_set() - set the link settings 2807 * @pl: a pointer to a &struct phylink returned from phylink_create() 2808 * @kset: a pointer to a &struct ethtool_link_ksettings for the desired modes 2809 */ 2810 int phylink_ethtool_ksettings_set(struct phylink *pl, 2811 const struct ethtool_link_ksettings *kset) 2812 { 2813 __ETHTOOL_DECLARE_LINK_MODE_MASK(support); 2814 const struct link_capabilities *c; 2815 struct phylink_link_state config; 2816 2817 ASSERT_RTNL(); 2818 2819 if (pl->phydev) { 2820 struct ethtool_link_ksettings phy_kset = *kset; 2821 2822 linkmode_and(phy_kset.link_modes.advertising, 2823 phy_kset.link_modes.advertising, 2824 pl->supported); 2825 2826 /* We can rely on phylib for this update; we also do not need 2827 * to update the pl->link_config settings: 2828 * - the configuration returned via ksettings_get() will come 2829 * from phylib whenever a PHY is present. 2830 * - link_config.interface will be updated by the PHY calling 2831 * back via phylink_phy_change() and a subsequent resolve. 2832 * - initial link configuration for PHY mode comes from the 2833 * last phy state updated via phylink_phy_change(). 2834 * - other configuration changes (e.g. pause modes) are 2835 * performed directly via phylib. 2836 * - if in in-band mode with a PHY, the link configuration 2837 * is passed on the link from the PHY, and all of 2838 * link_config.{speed,duplex,an_enabled,pause} are not used. 2839 * - the only possible use would be link_config.advertising 2840 * pause modes when in 1000base-X mode with a PHY, but in 2841 * the presence of a PHY, this should not be changed as that 2842 * should be determined from the media side advertisement. 2843 */ 2844 return phy_ethtool_ksettings_set(pl->phydev, &phy_kset); 2845 } 2846 2847 config = pl->link_config; 2848 /* Mask out unsupported advertisements */ 2849 linkmode_and(config.advertising, kset->link_modes.advertising, 2850 pl->supported); 2851 2852 /* FIXME: should we reject autoneg if phy/mac does not support it? */ 2853 switch (kset->base.autoneg) { 2854 case AUTONEG_DISABLE: 2855 /* Autonegotiation disabled, select a suitable speed and 2856 * duplex. 2857 */ 2858 c = phy_caps_lookup(kset->base.speed, kset->base.duplex, 2859 pl->supported, false); 2860 if (!c) 2861 return -EINVAL; 2862 2863 /* If we have a fixed link, refuse to change link parameters. 2864 * If the link parameters match, accept them but do nothing. 2865 */ 2866 if (pl->req_link_an_mode == MLO_AN_FIXED) { 2867 if (c->speed != pl->link_config.speed || 2868 c->duplex != pl->link_config.duplex) 2869 return -EINVAL; 2870 return 0; 2871 } 2872 2873 config.speed = c->speed; 2874 config.duplex = c->duplex; 2875 break; 2876 2877 case AUTONEG_ENABLE: 2878 /* If we have a fixed link, allow autonegotiation (since that 2879 * is our default case) but do not allow the advertisement to 2880 * be changed. If the advertisement matches, simply return. 2881 */ 2882 if (pl->req_link_an_mode == MLO_AN_FIXED) { 2883 if (!linkmode_equal(config.advertising, 2884 pl->link_config.advertising)) 2885 return -EINVAL; 2886 return 0; 2887 } 2888 2889 config.speed = SPEED_UNKNOWN; 2890 config.duplex = DUPLEX_UNKNOWN; 2891 break; 2892 2893 default: 2894 return -EINVAL; 2895 } 2896 2897 /* We have ruled out the case with a PHY attached, and the 2898 * fixed-link cases. All that is left are in-band links. 2899 */ 2900 linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising, 2901 kset->base.autoneg == AUTONEG_ENABLE); 2902 2903 /* If this link is with an SFP, ensure that changes to advertised modes 2904 * also cause the associated interface to be selected such that the 2905 * link can be configured correctly. 2906 */ 2907 if (pl->sfp_bus) { 2908 config.interface = phylink_sfp_select_interface(pl, 2909 config.advertising); 2910 if (config.interface == PHY_INTERFACE_MODE_NA) 2911 return -EINVAL; 2912 2913 /* Revalidate with the selected interface */ 2914 linkmode_copy(support, pl->supported); 2915 if (phylink_validate(pl, support, &config)) { 2916 phylink_err(pl, "validation of %s/%s with support %*pb failed\n", 2917 phylink_an_mode_str(pl->req_link_an_mode), 2918 phy_modes(config.interface), 2919 __ETHTOOL_LINK_MODE_MASK_NBITS, support); 2920 return -EINVAL; 2921 } 2922 } else { 2923 /* Validate without changing the current supported mask. */ 2924 linkmode_copy(support, pl->supported); 2925 if (phylink_validate(pl, support, &config)) 2926 return -EINVAL; 2927 } 2928 2929 /* If autonegotiation is enabled, we must have an advertisement */ 2930 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 2931 config.advertising) && 2932 phylink_is_empty_linkmode(config.advertising)) 2933 return -EINVAL; 2934 2935 /* Validate the autonegotiation state. We don't have a PHY in this 2936 * situation, so the PCS is the media-facing entity. 2937 */ 2938 if (!phylink_validate_pcs_inband_autoneg(pl, config.interface, 2939 config.advertising)) 2940 return -EINVAL; 2941 2942 mutex_lock(&pl->state_mutex); 2943 pl->link_config.speed = config.speed; 2944 pl->link_config.duplex = config.duplex; 2945 2946 if (pl->link_config.interface != config.interface) { 2947 /* The interface changed, e.g. 1000base-X <-> 2500base-X */ 2948 /* We need to force the link down, then change the interface */ 2949 if (pl->old_link_state) { 2950 phylink_link_down(pl); 2951 pl->old_link_state = false; 2952 } 2953 if (!test_bit(PHYLINK_DISABLE_STOPPED, 2954 &pl->phylink_disable_state)) 2955 phylink_major_config(pl, false, &config); 2956 pl->link_config.interface = config.interface; 2957 linkmode_copy(pl->link_config.advertising, config.advertising); 2958 } else if (!linkmode_equal(pl->link_config.advertising, 2959 config.advertising)) { 2960 linkmode_copy(pl->link_config.advertising, config.advertising); 2961 phylink_change_inband_advert(pl); 2962 } 2963 mutex_unlock(&pl->state_mutex); 2964 2965 return 0; 2966 } 2967 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set); 2968 2969 /** 2970 * phylink_ethtool_nway_reset() - restart negotiation 2971 * @pl: a pointer to a &struct phylink returned from phylink_create() 2972 * 2973 * Restart negotiation for the phylink instance specified by @pl. This will 2974 * cause any attached phy to restart negotiation with the link partner, and 2975 * if the MAC is in a BaseX mode, the MAC will also be requested to restart 2976 * negotiation. 2977 * 2978 * Returns zero on success, or negative error code. 2979 */ 2980 int phylink_ethtool_nway_reset(struct phylink *pl) 2981 { 2982 int ret = 0; 2983 2984 ASSERT_RTNL(); 2985 2986 if (pl->phydev) 2987 ret = phy_restart_aneg(pl->phydev); 2988 phylink_pcs_an_restart(pl); 2989 2990 return ret; 2991 } 2992 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset); 2993 2994 /** 2995 * phylink_ethtool_get_pauseparam() - get the current pause parameters 2996 * @pl: a pointer to a &struct phylink returned from phylink_create() 2997 * @pause: a pointer to a &struct ethtool_pauseparam 2998 */ 2999 void phylink_ethtool_get_pauseparam(struct phylink *pl, 3000 struct ethtool_pauseparam *pause) 3001 { 3002 ASSERT_RTNL(); 3003 3004 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN); 3005 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX); 3006 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX); 3007 } 3008 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam); 3009 3010 /** 3011 * phylink_ethtool_set_pauseparam() - set the current pause parameters 3012 * @pl: a pointer to a &struct phylink returned from phylink_create() 3013 * @pause: a pointer to a &struct ethtool_pauseparam 3014 */ 3015 int phylink_ethtool_set_pauseparam(struct phylink *pl, 3016 struct ethtool_pauseparam *pause) 3017 { 3018 struct phylink_link_state *config = &pl->link_config; 3019 bool manual_changed; 3020 int pause_state; 3021 3022 ASSERT_RTNL(); 3023 3024 if (pl->req_link_an_mode == MLO_AN_FIXED) 3025 return -EOPNOTSUPP; 3026 3027 if (!phylink_test(pl->supported, Pause) && 3028 !phylink_test(pl->supported, Asym_Pause)) 3029 return -EOPNOTSUPP; 3030 3031 if (!phylink_test(pl->supported, Asym_Pause) && 3032 pause->rx_pause != pause->tx_pause) 3033 return -EINVAL; 3034 3035 pause_state = 0; 3036 if (pause->autoneg) 3037 pause_state |= MLO_PAUSE_AN; 3038 if (pause->rx_pause) 3039 pause_state |= MLO_PAUSE_RX; 3040 if (pause->tx_pause) 3041 pause_state |= MLO_PAUSE_TX; 3042 3043 mutex_lock(&pl->state_mutex); 3044 /* 3045 * See the comments for linkmode_set_pause(), wrt the deficiencies 3046 * with the current implementation. A solution to this issue would 3047 * be: 3048 * ethtool Local device 3049 * rx tx Pause AsymDir 3050 * 0 0 0 0 3051 * 1 0 1 1 3052 * 0 1 0 1 3053 * 1 1 1 1 3054 * and then use the ethtool rx/tx enablement status to mask the 3055 * rx/tx pause resolution. 3056 */ 3057 linkmode_set_pause(config->advertising, pause->tx_pause, 3058 pause->rx_pause); 3059 3060 manual_changed = (config->pause ^ pause_state) & MLO_PAUSE_AN || 3061 (!(pause_state & MLO_PAUSE_AN) && 3062 (config->pause ^ pause_state) & MLO_PAUSE_TXRX_MASK); 3063 3064 config->pause = pause_state; 3065 3066 /* Update our in-band advertisement, triggering a renegotiation if 3067 * the advertisement changed. 3068 */ 3069 if (!pl->phydev) 3070 phylink_change_inband_advert(pl); 3071 3072 mutex_unlock(&pl->state_mutex); 3073 3074 /* If we have a PHY, a change of the pause frame advertisement will 3075 * cause phylib to renegotiate (if AN is enabled) which will in turn 3076 * call our phylink_phy_change() and trigger a resolve. Note that 3077 * we can't hold our state mutex while calling phy_set_asym_pause(). 3078 */ 3079 if (pl->phydev) 3080 phy_set_asym_pause(pl->phydev, pause->rx_pause, 3081 pause->tx_pause); 3082 3083 /* If the manual pause settings changed, make sure we trigger a 3084 * resolve to update their state; we can not guarantee that the 3085 * link will cycle. 3086 */ 3087 if (manual_changed) { 3088 pl->link_failed = true; 3089 phylink_run_resolve(pl); 3090 } 3091 3092 return 0; 3093 } 3094 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam); 3095 3096 /** 3097 * phylink_get_eee_err() - read the energy efficient ethernet error 3098 * counter 3099 * @pl: a pointer to a &struct phylink returned from phylink_create(). 3100 * 3101 * Read the Energy Efficient Ethernet error counter from the PHY associated 3102 * with the phylink instance specified by @pl. 3103 * 3104 * Returns positive error counter value, or negative error code. 3105 */ 3106 int phylink_get_eee_err(struct phylink *pl) 3107 { 3108 int ret = 0; 3109 3110 ASSERT_RTNL(); 3111 3112 if (pl->phydev) 3113 ret = phy_get_eee_err(pl->phydev); 3114 3115 return ret; 3116 } 3117 EXPORT_SYMBOL_GPL(phylink_get_eee_err); 3118 3119 /** 3120 * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters 3121 * @pl: a pointer to a &struct phylink returned from phylink_create() 3122 * @eee: a pointer to a &struct ethtool_keee for the read parameters 3123 */ 3124 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_keee *eee) 3125 { 3126 int ret = -EOPNOTSUPP; 3127 3128 ASSERT_RTNL(); 3129 3130 if (pl->mac_supports_eee_ops && !pl->mac_supports_eee) 3131 return ret; 3132 3133 if (pl->phydev) { 3134 ret = phy_ethtool_get_eee(pl->phydev, eee); 3135 /* Restrict supported linkmode mask */ 3136 if (ret == 0 && pl->mac_supports_eee_ops) 3137 linkmode_and(eee->supported, eee->supported, 3138 pl->supported_lpi); 3139 } 3140 3141 return ret; 3142 } 3143 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee); 3144 3145 /** 3146 * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters 3147 * @pl: a pointer to a &struct phylink returned from phylink_create() 3148 * @eee: a pointer to a &struct ethtool_keee for the desired parameters 3149 */ 3150 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_keee *eee) 3151 { 3152 bool mac_eee = pl->mac_supports_eee; 3153 int ret = -EOPNOTSUPP; 3154 3155 ASSERT_RTNL(); 3156 3157 phylink_dbg(pl, "mac %s phylink EEE%s, adv %*pbl, LPI%s timer %uus\n", 3158 mac_eee ? "supports" : "does not support", 3159 eee->eee_enabled ? ", enabled" : "", 3160 __ETHTOOL_LINK_MODE_MASK_NBITS, eee->advertised, 3161 eee->tx_lpi_enabled ? " enabled" : "", eee->tx_lpi_timer); 3162 3163 if (pl->mac_supports_eee_ops && !mac_eee) 3164 return ret; 3165 3166 if (pl->phydev) { 3167 /* Restrict advertisement mask */ 3168 if (pl->mac_supports_eee_ops) 3169 linkmode_and(eee->advertised, eee->advertised, 3170 pl->supported_lpi); 3171 ret = phy_ethtool_set_eee(pl->phydev, eee); 3172 if (ret == 0) 3173 eee_to_eeecfg(&pl->eee_cfg, eee); 3174 } 3175 3176 return ret; 3177 } 3178 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee); 3179 3180 /* This emulates MII registers for a fixed-mode phy operating as per the 3181 * passed in state. "aneg" defines if we report negotiation is possible. 3182 * 3183 * FIXME: should deal with negotiation state too. 3184 */ 3185 static int phylink_mii_emul_read(unsigned int reg, 3186 struct phylink_link_state *state) 3187 { 3188 struct fixed_phy_status fs; 3189 unsigned long *lpa = state->lp_advertising; 3190 int val; 3191 3192 fs.link = state->link; 3193 fs.speed = state->speed; 3194 fs.duplex = state->duplex; 3195 fs.pause = test_bit(ETHTOOL_LINK_MODE_Pause_BIT, lpa); 3196 fs.asym_pause = test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, lpa); 3197 3198 val = swphy_read_reg(reg, &fs); 3199 if (reg == MII_BMSR) { 3200 if (!state->an_complete) 3201 val &= ~BMSR_ANEGCOMPLETE; 3202 } 3203 return val; 3204 } 3205 3206 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id, 3207 unsigned int reg) 3208 { 3209 struct phy_device *phydev = pl->phydev; 3210 int prtad, devad; 3211 3212 if (mdio_phy_id_is_c45(phy_id)) { 3213 prtad = mdio_phy_id_prtad(phy_id); 3214 devad = mdio_phy_id_devad(phy_id); 3215 return mdiobus_c45_read(pl->phydev->mdio.bus, prtad, devad, 3216 reg); 3217 } 3218 3219 if (phydev->is_c45) { 3220 switch (reg) { 3221 case MII_BMCR: 3222 case MII_BMSR: 3223 case MII_PHYSID1: 3224 case MII_PHYSID2: 3225 devad = __ffs(phydev->c45_ids.mmds_present); 3226 break; 3227 case MII_ADVERTISE: 3228 case MII_LPA: 3229 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN)) 3230 return -EINVAL; 3231 devad = MDIO_MMD_AN; 3232 if (reg == MII_ADVERTISE) 3233 reg = MDIO_AN_ADVERTISE; 3234 else 3235 reg = MDIO_AN_LPA; 3236 break; 3237 default: 3238 return -EINVAL; 3239 } 3240 prtad = phy_id; 3241 return mdiobus_c45_read(pl->phydev->mdio.bus, prtad, devad, 3242 reg); 3243 } 3244 3245 return mdiobus_read(pl->phydev->mdio.bus, phy_id, reg); 3246 } 3247 3248 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id, 3249 unsigned int reg, unsigned int val) 3250 { 3251 struct phy_device *phydev = pl->phydev; 3252 int prtad, devad; 3253 3254 if (mdio_phy_id_is_c45(phy_id)) { 3255 prtad = mdio_phy_id_prtad(phy_id); 3256 devad = mdio_phy_id_devad(phy_id); 3257 return mdiobus_c45_write(pl->phydev->mdio.bus, prtad, devad, 3258 reg, val); 3259 } 3260 3261 if (phydev->is_c45) { 3262 switch (reg) { 3263 case MII_BMCR: 3264 case MII_BMSR: 3265 case MII_PHYSID1: 3266 case MII_PHYSID2: 3267 devad = __ffs(phydev->c45_ids.mmds_present); 3268 break; 3269 case MII_ADVERTISE: 3270 case MII_LPA: 3271 if (!(phydev->c45_ids.mmds_present & MDIO_DEVS_AN)) 3272 return -EINVAL; 3273 devad = MDIO_MMD_AN; 3274 if (reg == MII_ADVERTISE) 3275 reg = MDIO_AN_ADVERTISE; 3276 else 3277 reg = MDIO_AN_LPA; 3278 break; 3279 default: 3280 return -EINVAL; 3281 } 3282 return mdiobus_c45_write(pl->phydev->mdio.bus, phy_id, devad, 3283 reg, val); 3284 } 3285 3286 return mdiobus_write(phydev->mdio.bus, phy_id, reg, val); 3287 } 3288 3289 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id, 3290 unsigned int reg) 3291 { 3292 struct phylink_link_state state; 3293 int val = 0xffff; 3294 3295 switch (pl->act_link_an_mode) { 3296 case MLO_AN_FIXED: 3297 if (phy_id == 0) { 3298 phylink_get_fixed_state(pl, &state); 3299 val = phylink_mii_emul_read(reg, &state); 3300 } 3301 break; 3302 3303 case MLO_AN_PHY: 3304 return -EOPNOTSUPP; 3305 3306 case MLO_AN_INBAND: 3307 if (phy_id == 0) { 3308 phylink_mac_pcs_get_state(pl, &state); 3309 val = phylink_mii_emul_read(reg, &state); 3310 } 3311 break; 3312 } 3313 3314 return val & 0xffff; 3315 } 3316 3317 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id, 3318 unsigned int reg, unsigned int val) 3319 { 3320 switch (pl->act_link_an_mode) { 3321 case MLO_AN_FIXED: 3322 break; 3323 3324 case MLO_AN_PHY: 3325 return -EOPNOTSUPP; 3326 3327 case MLO_AN_INBAND: 3328 break; 3329 } 3330 3331 return 0; 3332 } 3333 3334 /** 3335 * phylink_mii_ioctl() - generic mii ioctl interface 3336 * @pl: a pointer to a &struct phylink returned from phylink_create() 3337 * @ifr: a pointer to a &struct ifreq for socket ioctls 3338 * @cmd: ioctl cmd to execute 3339 * 3340 * Perform the specified MII ioctl on the PHY attached to the phylink instance 3341 * specified by @pl. If no PHY is attached, emulate the presence of the PHY. 3342 * 3343 * Returns: zero on success or negative error code. 3344 * 3345 * %SIOCGMIIPHY: 3346 * read register from the current PHY. 3347 * %SIOCGMIIREG: 3348 * read register from the specified PHY. 3349 * %SIOCSMIIREG: 3350 * set a register on the specified PHY. 3351 */ 3352 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd) 3353 { 3354 struct mii_ioctl_data *mii = if_mii(ifr); 3355 int ret; 3356 3357 ASSERT_RTNL(); 3358 3359 if (pl->phydev) { 3360 /* PHYs only exist for MLO_AN_PHY and SGMII */ 3361 switch (cmd) { 3362 case SIOCGMIIPHY: 3363 mii->phy_id = pl->phydev->mdio.addr; 3364 fallthrough; 3365 3366 case SIOCGMIIREG: 3367 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num); 3368 if (ret >= 0) { 3369 mii->val_out = ret; 3370 ret = 0; 3371 } 3372 break; 3373 3374 case SIOCSMIIREG: 3375 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num, 3376 mii->val_in); 3377 break; 3378 3379 default: 3380 ret = phy_mii_ioctl(pl->phydev, ifr, cmd); 3381 break; 3382 } 3383 } else { 3384 switch (cmd) { 3385 case SIOCGMIIPHY: 3386 mii->phy_id = 0; 3387 fallthrough; 3388 3389 case SIOCGMIIREG: 3390 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num); 3391 if (ret >= 0) { 3392 mii->val_out = ret; 3393 ret = 0; 3394 } 3395 break; 3396 3397 case SIOCSMIIREG: 3398 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num, 3399 mii->val_in); 3400 break; 3401 3402 default: 3403 ret = -EOPNOTSUPP; 3404 break; 3405 } 3406 } 3407 3408 return ret; 3409 } 3410 EXPORT_SYMBOL_GPL(phylink_mii_ioctl); 3411 3412 /** 3413 * phylink_speed_down() - set the non-SFP PHY to lowest speed supported by both 3414 * link partners 3415 * @pl: a pointer to a &struct phylink returned from phylink_create() 3416 * @sync: perform action synchronously 3417 * 3418 * If we have a PHY that is not part of a SFP module, then set the speed 3419 * as described in the phy_speed_down() function. Please see this function 3420 * for a description of the @sync parameter. 3421 * 3422 * Returns zero if there is no PHY, otherwise as per phy_speed_down(). 3423 */ 3424 int phylink_speed_down(struct phylink *pl, bool sync) 3425 { 3426 int ret = 0; 3427 3428 ASSERT_RTNL(); 3429 3430 if (!pl->sfp_bus && pl->phydev) 3431 ret = phy_speed_down(pl->phydev, sync); 3432 3433 return ret; 3434 } 3435 EXPORT_SYMBOL_GPL(phylink_speed_down); 3436 3437 /** 3438 * phylink_speed_up() - restore the advertised speeds prior to the call to 3439 * phylink_speed_down() 3440 * @pl: a pointer to a &struct phylink returned from phylink_create() 3441 * 3442 * If we have a PHY that is not part of a SFP module, then restore the 3443 * PHY speeds as per phy_speed_up(). 3444 * 3445 * Returns zero if there is no PHY, otherwise as per phy_speed_up(). 3446 */ 3447 int phylink_speed_up(struct phylink *pl) 3448 { 3449 int ret = 0; 3450 3451 ASSERT_RTNL(); 3452 3453 if (!pl->sfp_bus && pl->phydev) 3454 ret = phy_speed_up(pl->phydev); 3455 3456 return ret; 3457 } 3458 EXPORT_SYMBOL_GPL(phylink_speed_up); 3459 3460 static void phylink_sfp_attach(void *upstream, struct sfp_bus *bus) 3461 { 3462 struct phylink *pl = upstream; 3463 3464 pl->netdev->sfp_bus = bus; 3465 } 3466 3467 static void phylink_sfp_detach(void *upstream, struct sfp_bus *bus) 3468 { 3469 struct phylink *pl = upstream; 3470 3471 pl->netdev->sfp_bus = NULL; 3472 } 3473 3474 static phy_interface_t phylink_choose_sfp_interface(struct phylink *pl, 3475 const unsigned long *intf) 3476 { 3477 phy_interface_t interface; 3478 size_t i; 3479 3480 interface = PHY_INTERFACE_MODE_NA; 3481 for (i = 0; i < ARRAY_SIZE(phylink_sfp_interface_preference); i++) 3482 if (test_bit(phylink_sfp_interface_preference[i], intf)) { 3483 interface = phylink_sfp_interface_preference[i]; 3484 break; 3485 } 3486 3487 return interface; 3488 } 3489 3490 static void phylink_sfp_set_config(struct phylink *pl, unsigned long *supported, 3491 struct phylink_link_state *state, 3492 bool changed) 3493 { 3494 u8 mode = MLO_AN_INBAND; 3495 3496 phylink_dbg(pl, "requesting link mode %s/%s with support %*pb\n", 3497 phylink_an_mode_str(mode), phy_modes(state->interface), 3498 __ETHTOOL_LINK_MODE_MASK_NBITS, supported); 3499 3500 if (!linkmode_equal(pl->supported, supported)) { 3501 linkmode_copy(pl->supported, supported); 3502 changed = true; 3503 } 3504 3505 if (!linkmode_equal(pl->link_config.advertising, state->advertising)) { 3506 linkmode_copy(pl->link_config.advertising, state->advertising); 3507 changed = true; 3508 } 3509 3510 if (pl->req_link_an_mode != mode || 3511 pl->link_config.interface != state->interface) { 3512 pl->req_link_an_mode = mode; 3513 pl->link_config.interface = state->interface; 3514 3515 changed = true; 3516 3517 phylink_info(pl, "switched to %s/%s link mode\n", 3518 phylink_an_mode_str(mode), 3519 phy_modes(state->interface)); 3520 } 3521 3522 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED, 3523 &pl->phylink_disable_state)) 3524 phylink_mac_initial_config(pl, false); 3525 } 3526 3527 static int phylink_sfp_config_phy(struct phylink *pl, struct phy_device *phy) 3528 { 3529 __ETHTOOL_DECLARE_LINK_MODE_MASK(support); 3530 struct phylink_link_state config; 3531 int ret; 3532 3533 linkmode_copy(support, phy->supported); 3534 3535 memset(&config, 0, sizeof(config)); 3536 linkmode_copy(config.advertising, phy->advertising); 3537 config.interface = PHY_INTERFACE_MODE_NA; 3538 config.speed = SPEED_UNKNOWN; 3539 config.duplex = DUPLEX_UNKNOWN; 3540 config.pause = MLO_PAUSE_AN; 3541 3542 /* Ignore errors if we're expecting a PHY to attach later */ 3543 ret = phylink_validate(pl, support, &config); 3544 if (ret) { 3545 phylink_err(pl, "validation with support %*pb failed: %pe\n", 3546 __ETHTOOL_LINK_MODE_MASK_NBITS, support, 3547 ERR_PTR(ret)); 3548 return ret; 3549 } 3550 3551 config.interface = phylink_sfp_select_interface(pl, config.advertising); 3552 if (config.interface == PHY_INTERFACE_MODE_NA) 3553 return -EINVAL; 3554 3555 /* Attach the PHY so that the PHY is present when we do the major 3556 * configuration step. 3557 */ 3558 ret = phylink_attach_phy(pl, phy, config.interface); 3559 if (ret < 0) 3560 return ret; 3561 3562 /* This will validate the configuration for us. */ 3563 ret = phylink_bringup_phy(pl, phy, config.interface); 3564 if (ret < 0) { 3565 phy_detach(phy); 3566 return ret; 3567 } 3568 3569 pl->link_port = pl->sfp_port; 3570 3571 phylink_sfp_set_config(pl, support, &config, true); 3572 3573 return 0; 3574 } 3575 3576 static int phylink_sfp_config_optical(struct phylink *pl) 3577 { 3578 __ETHTOOL_DECLARE_LINK_MODE_MASK(support); 3579 DECLARE_PHY_INTERFACE_MASK(interfaces); 3580 struct phylink_link_state config; 3581 phy_interface_t interface; 3582 int ret; 3583 3584 phylink_dbg(pl, "optical SFP: interfaces=[mac=%*pbl, sfp=%*pbl]\n", 3585 (int)PHY_INTERFACE_MODE_MAX, 3586 pl->config->supported_interfaces, 3587 (int)PHY_INTERFACE_MODE_MAX, 3588 pl->sfp_interfaces); 3589 3590 /* Find the union of the supported interfaces by the PCS/MAC and 3591 * the SFP module. 3592 */ 3593 phy_interface_and(interfaces, pl->config->supported_interfaces, 3594 pl->sfp_interfaces); 3595 if (phy_interface_empty(interfaces)) { 3596 phylink_err(pl, "unsupported SFP module: no common interface modes\n"); 3597 return -EINVAL; 3598 } 3599 3600 memset(&config, 0, sizeof(config)); 3601 linkmode_copy(support, pl->sfp_support); 3602 linkmode_copy(config.advertising, pl->sfp_support); 3603 config.speed = SPEED_UNKNOWN; 3604 config.duplex = DUPLEX_UNKNOWN; 3605 config.pause = MLO_PAUSE_AN; 3606 3607 /* For all the interfaces that are supported, reduce the sfp_support 3608 * mask to only those link modes that can be supported. 3609 */ 3610 ret = phylink_validate_mask(pl, NULL, pl->sfp_support, &config, 3611 interfaces); 3612 if (ret) { 3613 phylink_err(pl, "unsupported SFP module: validation with support %*pb failed\n", 3614 __ETHTOOL_LINK_MODE_MASK_NBITS, support); 3615 return ret; 3616 } 3617 3618 interface = phylink_choose_sfp_interface(pl, interfaces); 3619 if (interface == PHY_INTERFACE_MODE_NA) { 3620 phylink_err(pl, "failed to select SFP interface\n"); 3621 return -EINVAL; 3622 } 3623 3624 phylink_dbg(pl, "optical SFP: chosen %s interface\n", 3625 phy_modes(interface)); 3626 3627 if (!phylink_validate_pcs_inband_autoneg(pl, interface, 3628 config.advertising)) { 3629 phylink_err(pl, "autoneg setting not compatible with PCS"); 3630 return -EINVAL; 3631 } 3632 3633 config.interface = interface; 3634 3635 /* Ignore errors if we're expecting a PHY to attach later */ 3636 ret = phylink_validate(pl, support, &config); 3637 if (ret) { 3638 phylink_err(pl, "validation with support %*pb failed: %pe\n", 3639 __ETHTOOL_LINK_MODE_MASK_NBITS, support, 3640 ERR_PTR(ret)); 3641 return ret; 3642 } 3643 3644 pl->link_port = pl->sfp_port; 3645 3646 phylink_sfp_set_config(pl, pl->sfp_support, &config, false); 3647 3648 return 0; 3649 } 3650 3651 static int phylink_sfp_module_insert(void *upstream, 3652 const struct sfp_eeprom_id *id) 3653 { 3654 struct phylink *pl = upstream; 3655 3656 ASSERT_RTNL(); 3657 3658 linkmode_zero(pl->sfp_support); 3659 phy_interface_zero(pl->sfp_interfaces); 3660 sfp_parse_support(pl->sfp_bus, id, pl->sfp_support, pl->sfp_interfaces); 3661 pl->sfp_port = sfp_parse_port(pl->sfp_bus, id, pl->sfp_support); 3662 3663 /* If this module may have a PHY connecting later, defer until later */ 3664 pl->sfp_may_have_phy = sfp_may_have_phy(pl->sfp_bus, id); 3665 if (pl->sfp_may_have_phy) 3666 return 0; 3667 3668 return phylink_sfp_config_optical(pl); 3669 } 3670 3671 static int phylink_sfp_module_start(void *upstream) 3672 { 3673 struct phylink *pl = upstream; 3674 3675 /* If this SFP module has a PHY, start the PHY now. */ 3676 if (pl->phydev) { 3677 phy_start(pl->phydev); 3678 return 0; 3679 } 3680 3681 /* If the module may have a PHY but we didn't detect one we 3682 * need to configure the MAC here. 3683 */ 3684 if (!pl->sfp_may_have_phy) 3685 return 0; 3686 3687 return phylink_sfp_config_optical(pl); 3688 } 3689 3690 static void phylink_sfp_module_stop(void *upstream) 3691 { 3692 struct phylink *pl = upstream; 3693 3694 /* If this SFP module has a PHY, stop it. */ 3695 if (pl->phydev) 3696 phy_stop(pl->phydev); 3697 } 3698 3699 static void phylink_sfp_link_down(void *upstream) 3700 { 3701 struct phylink *pl = upstream; 3702 3703 ASSERT_RTNL(); 3704 3705 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_LINK); 3706 } 3707 3708 static void phylink_sfp_link_up(void *upstream) 3709 { 3710 struct phylink *pl = upstream; 3711 3712 ASSERT_RTNL(); 3713 3714 phylink_enable_and_run_resolve(pl, PHYLINK_DISABLE_LINK); 3715 } 3716 3717 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy) 3718 { 3719 struct phylink *pl = upstream; 3720 3721 if (!phy->drv) { 3722 phylink_err(pl, "PHY %s (id 0x%.8lx) has no driver loaded\n", 3723 phydev_name(phy), (unsigned long)phy->phy_id); 3724 phylink_err(pl, "Drivers which handle known common cases: CONFIG_BCM84881_PHY, CONFIG_MARVELL_PHY\n"); 3725 return -EINVAL; 3726 } 3727 3728 /* 3729 * This is the new way of dealing with flow control for PHYs, 3730 * as described by Timur Tabi in commit 529ed1275263 ("net: phy: 3731 * phy drivers should not set SUPPORTED_[Asym_]Pause") except 3732 * using our validate call to the MAC, we rely upon the MAC 3733 * clearing the bits from both supported and advertising fields. 3734 */ 3735 phy_support_asym_pause(phy); 3736 3737 /* Set the PHY's host supported interfaces */ 3738 phy_interface_and(phy->host_interfaces, phylink_sfp_interfaces, 3739 pl->config->supported_interfaces); 3740 3741 /* Do the initial configuration */ 3742 return phylink_sfp_config_phy(pl, phy); 3743 } 3744 3745 static void phylink_sfp_disconnect_phy(void *upstream, 3746 struct phy_device *phydev) 3747 { 3748 phylink_disconnect_phy(upstream); 3749 } 3750 3751 static const struct sfp_upstream_ops sfp_phylink_ops = { 3752 .attach = phylink_sfp_attach, 3753 .detach = phylink_sfp_detach, 3754 .module_insert = phylink_sfp_module_insert, 3755 .module_start = phylink_sfp_module_start, 3756 .module_stop = phylink_sfp_module_stop, 3757 .link_up = phylink_sfp_link_up, 3758 .link_down = phylink_sfp_link_down, 3759 .connect_phy = phylink_sfp_connect_phy, 3760 .disconnect_phy = phylink_sfp_disconnect_phy, 3761 }; 3762 3763 /* Helpers for MAC drivers */ 3764 3765 static struct { 3766 int bit; 3767 int speed; 3768 } phylink_c73_priority_resolution[] = { 3769 { ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT, SPEED_100000 }, 3770 { ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT, SPEED_100000 }, 3771 /* 100GBASE-KP4 and 100GBASE-CR10 not supported */ 3772 { ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT, SPEED_40000 }, 3773 { ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT, SPEED_40000 }, 3774 { ETHTOOL_LINK_MODE_10000baseKR_Full_BIT, SPEED_10000 }, 3775 { ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT, SPEED_10000 }, 3776 /* 5GBASE-KR not supported */ 3777 { ETHTOOL_LINK_MODE_2500baseX_Full_BIT, SPEED_2500 }, 3778 { ETHTOOL_LINK_MODE_1000baseKX_Full_BIT, SPEED_1000 }, 3779 }; 3780 3781 void phylink_resolve_c73(struct phylink_link_state *state) 3782 { 3783 int i; 3784 3785 for (i = 0; i < ARRAY_SIZE(phylink_c73_priority_resolution); i++) { 3786 int bit = phylink_c73_priority_resolution[i].bit; 3787 if (linkmode_test_bit(bit, state->advertising) && 3788 linkmode_test_bit(bit, state->lp_advertising)) 3789 break; 3790 } 3791 3792 if (i < ARRAY_SIZE(phylink_c73_priority_resolution)) { 3793 state->speed = phylink_c73_priority_resolution[i].speed; 3794 state->duplex = DUPLEX_FULL; 3795 } else { 3796 /* negotiation failure */ 3797 state->link = false; 3798 } 3799 3800 phylink_resolve_an_pause(state); 3801 } 3802 EXPORT_SYMBOL_GPL(phylink_resolve_c73); 3803 3804 static void phylink_decode_c37_word(struct phylink_link_state *state, 3805 uint16_t config_reg, int speed) 3806 { 3807 int fd_bit; 3808 3809 if (speed == SPEED_2500) 3810 fd_bit = ETHTOOL_LINK_MODE_2500baseX_Full_BIT; 3811 else 3812 fd_bit = ETHTOOL_LINK_MODE_1000baseX_Full_BIT; 3813 3814 mii_lpa_mod_linkmode_x(state->lp_advertising, config_reg, fd_bit); 3815 3816 if (linkmode_test_bit(fd_bit, state->advertising) && 3817 linkmode_test_bit(fd_bit, state->lp_advertising)) { 3818 state->speed = speed; 3819 state->duplex = DUPLEX_FULL; 3820 } else { 3821 /* negotiation failure */ 3822 state->link = false; 3823 } 3824 3825 phylink_resolve_an_pause(state); 3826 } 3827 3828 static void phylink_decode_sgmii_word(struct phylink_link_state *state, 3829 uint16_t config_reg) 3830 { 3831 if (!(config_reg & LPA_SGMII_LINK)) { 3832 state->link = false; 3833 return; 3834 } 3835 3836 switch (config_reg & LPA_SGMII_SPD_MASK) { 3837 case LPA_SGMII_10: 3838 state->speed = SPEED_10; 3839 break; 3840 case LPA_SGMII_100: 3841 state->speed = SPEED_100; 3842 break; 3843 case LPA_SGMII_1000: 3844 state->speed = SPEED_1000; 3845 break; 3846 default: 3847 state->link = false; 3848 return; 3849 } 3850 if (config_reg & LPA_SGMII_FULL_DUPLEX) 3851 state->duplex = DUPLEX_FULL; 3852 else 3853 state->duplex = DUPLEX_HALF; 3854 } 3855 3856 /** 3857 * phylink_decode_usxgmii_word() - decode the USXGMII word from a MAC PCS 3858 * @state: a pointer to a struct phylink_link_state. 3859 * @lpa: a 16 bit value which stores the USXGMII auto-negotiation word 3860 * 3861 * Helper for MAC PCS supporting the USXGMII protocol and the auto-negotiation 3862 * code word. Decode the USXGMII code word and populate the corresponding fields 3863 * (speed, duplex) into the phylink_link_state structure. 3864 */ 3865 void phylink_decode_usxgmii_word(struct phylink_link_state *state, 3866 uint16_t lpa) 3867 { 3868 switch (lpa & MDIO_USXGMII_SPD_MASK) { 3869 case MDIO_USXGMII_10: 3870 state->speed = SPEED_10; 3871 break; 3872 case MDIO_USXGMII_100: 3873 state->speed = SPEED_100; 3874 break; 3875 case MDIO_USXGMII_1000: 3876 state->speed = SPEED_1000; 3877 break; 3878 case MDIO_USXGMII_2500: 3879 state->speed = SPEED_2500; 3880 break; 3881 case MDIO_USXGMII_5000: 3882 state->speed = SPEED_5000; 3883 break; 3884 case MDIO_USXGMII_10G: 3885 state->speed = SPEED_10000; 3886 break; 3887 default: 3888 state->link = false; 3889 return; 3890 } 3891 3892 if (lpa & MDIO_USXGMII_FULL_DUPLEX) 3893 state->duplex = DUPLEX_FULL; 3894 else 3895 state->duplex = DUPLEX_HALF; 3896 } 3897 EXPORT_SYMBOL_GPL(phylink_decode_usxgmii_word); 3898 3899 /** 3900 * phylink_decode_usgmii_word() - decode the USGMII word from a MAC PCS 3901 * @state: a pointer to a struct phylink_link_state. 3902 * @lpa: a 16 bit value which stores the USGMII auto-negotiation word 3903 * 3904 * Helper for MAC PCS supporting the USGMII protocol and the auto-negotiation 3905 * code word. Decode the USGMII code word and populate the corresponding fields 3906 * (speed, duplex) into the phylink_link_state structure. The structure for this 3907 * word is the same as the USXGMII word, except it only supports speeds up to 3908 * 1Gbps. 3909 */ 3910 static void phylink_decode_usgmii_word(struct phylink_link_state *state, 3911 uint16_t lpa) 3912 { 3913 switch (lpa & MDIO_USXGMII_SPD_MASK) { 3914 case MDIO_USXGMII_10: 3915 state->speed = SPEED_10; 3916 break; 3917 case MDIO_USXGMII_100: 3918 state->speed = SPEED_100; 3919 break; 3920 case MDIO_USXGMII_1000: 3921 state->speed = SPEED_1000; 3922 break; 3923 default: 3924 state->link = false; 3925 return; 3926 } 3927 3928 if (lpa & MDIO_USXGMII_FULL_DUPLEX) 3929 state->duplex = DUPLEX_FULL; 3930 else 3931 state->duplex = DUPLEX_HALF; 3932 } 3933 3934 /** 3935 * phylink_mii_c22_pcs_decode_state() - Decode MAC PCS state from MII registers 3936 * @state: a pointer to a &struct phylink_link_state. 3937 * @neg_mode: link negotiation mode (PHYLINK_PCS_NEG_xxx) 3938 * @bmsr: The value of the %MII_BMSR register 3939 * @lpa: The value of the %MII_LPA register 3940 * 3941 * Helper for MAC PCS supporting the 802.3 clause 22 register set for 3942 * clause 37 negotiation and/or SGMII control. 3943 * 3944 * Parse the Clause 37 or Cisco SGMII link partner negotiation word into 3945 * the phylink @state structure. This is suitable to be used for implementing 3946 * the pcs_get_state() member of the struct phylink_pcs_ops structure if 3947 * accessing @bmsr and @lpa cannot be done with MDIO directly. 3948 */ 3949 void phylink_mii_c22_pcs_decode_state(struct phylink_link_state *state, 3950 unsigned int neg_mode, u16 bmsr, u16 lpa) 3951 { 3952 state->link = !!(bmsr & BMSR_LSTATUS); 3953 state->an_complete = !!(bmsr & BMSR_ANEGCOMPLETE); 3954 3955 /* If the link is down, the advertisement data is undefined. */ 3956 if (!state->link) 3957 return; 3958 3959 switch (state->interface) { 3960 case PHY_INTERFACE_MODE_1000BASEX: 3961 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) { 3962 phylink_decode_c37_word(state, lpa, SPEED_1000); 3963 } else { 3964 state->speed = SPEED_1000; 3965 state->duplex = DUPLEX_FULL; 3966 state->pause |= MLO_PAUSE_TX | MLO_PAUSE_RX; 3967 } 3968 break; 3969 3970 case PHY_INTERFACE_MODE_2500BASEX: 3971 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) { 3972 phylink_decode_c37_word(state, lpa, SPEED_2500); 3973 } else { 3974 state->speed = SPEED_2500; 3975 state->duplex = DUPLEX_FULL; 3976 state->pause |= MLO_PAUSE_TX | MLO_PAUSE_RX; 3977 } 3978 break; 3979 3980 case PHY_INTERFACE_MODE_SGMII: 3981 case PHY_INTERFACE_MODE_QSGMII: 3982 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) 3983 phylink_decode_sgmii_word(state, lpa); 3984 break; 3985 3986 case PHY_INTERFACE_MODE_QUSGMII: 3987 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) 3988 phylink_decode_usgmii_word(state, lpa); 3989 break; 3990 3991 default: 3992 state->link = false; 3993 break; 3994 } 3995 } 3996 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_decode_state); 3997 3998 /** 3999 * phylink_mii_c22_pcs_get_state() - read the MAC PCS state 4000 * @pcs: a pointer to a &struct mdio_device. 4001 * @neg_mode: link negotiation mode (PHYLINK_PCS_NEG_xxx) 4002 * @state: a pointer to a &struct phylink_link_state. 4003 * 4004 * Helper for MAC PCS supporting the 802.3 clause 22 register set for 4005 * clause 37 negotiation and/or SGMII control. 4006 * 4007 * Read the MAC PCS state from the MII device configured in @config and 4008 * parse the Clause 37 or Cisco SGMII link partner negotiation word into 4009 * the phylink @state structure. This is suitable to be directly plugged 4010 * into the pcs_get_state() member of the struct phylink_pcs_ops 4011 * structure. 4012 */ 4013 void phylink_mii_c22_pcs_get_state(struct mdio_device *pcs, 4014 unsigned int neg_mode, 4015 struct phylink_link_state *state) 4016 { 4017 int bmsr, lpa; 4018 4019 bmsr = mdiodev_read(pcs, MII_BMSR); 4020 lpa = mdiodev_read(pcs, MII_LPA); 4021 if (bmsr < 0 || lpa < 0) { 4022 state->link = false; 4023 return; 4024 } 4025 4026 phylink_mii_c22_pcs_decode_state(state, neg_mode, bmsr, lpa); 4027 } 4028 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_get_state); 4029 4030 /** 4031 * phylink_mii_c22_pcs_encode_advertisement() - configure the clause 37 PCS 4032 * advertisement 4033 * @interface: the PHY interface mode being configured 4034 * @advertising: the ethtool advertisement mask 4035 * 4036 * Helper for MAC PCS supporting the 802.3 clause 22 register set for 4037 * clause 37 negotiation and/or SGMII control. 4038 * 4039 * Encode the clause 37 PCS advertisement as specified by @interface and 4040 * @advertising. 4041 * 4042 * Return: The new value for @adv, or ``-EINVAL`` if it should not be changed. 4043 */ 4044 int phylink_mii_c22_pcs_encode_advertisement(phy_interface_t interface, 4045 const unsigned long *advertising) 4046 { 4047 u16 adv; 4048 4049 switch (interface) { 4050 case PHY_INTERFACE_MODE_1000BASEX: 4051 case PHY_INTERFACE_MODE_2500BASEX: 4052 adv = ADVERTISE_1000XFULL; 4053 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, 4054 advertising)) 4055 adv |= ADVERTISE_1000XPAUSE; 4056 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 4057 advertising)) 4058 adv |= ADVERTISE_1000XPSE_ASYM; 4059 return adv; 4060 case PHY_INTERFACE_MODE_SGMII: 4061 case PHY_INTERFACE_MODE_QSGMII: 4062 return 0x0001; 4063 default: 4064 /* Nothing to do for other modes */ 4065 return -EINVAL; 4066 } 4067 } 4068 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_encode_advertisement); 4069 4070 /** 4071 * phylink_mii_c22_pcs_config() - configure clause 22 PCS 4072 * @pcs: a pointer to a &struct mdio_device. 4073 * @interface: the PHY interface mode being configured 4074 * @advertising: the ethtool advertisement mask 4075 * @neg_mode: PCS negotiation mode 4076 * 4077 * Configure a Clause 22 PCS PHY with the appropriate negotiation 4078 * parameters for the @mode, @interface and @advertising parameters. 4079 * Returns negative error number on failure, zero if the advertisement 4080 * has not changed, or positive if there is a change. 4081 */ 4082 int phylink_mii_c22_pcs_config(struct mdio_device *pcs, 4083 phy_interface_t interface, 4084 const unsigned long *advertising, 4085 unsigned int neg_mode) 4086 { 4087 bool changed = 0; 4088 u16 bmcr; 4089 int ret, adv; 4090 4091 adv = phylink_mii_c22_pcs_encode_advertisement(interface, advertising); 4092 if (adv >= 0) { 4093 ret = mdiobus_modify_changed(pcs->bus, pcs->addr, 4094 MII_ADVERTISE, 0xffff, adv); 4095 if (ret < 0) 4096 return ret; 4097 changed = ret; 4098 } 4099 4100 if (neg_mode == PHYLINK_PCS_NEG_INBAND_ENABLED) 4101 bmcr = BMCR_ANENABLE; 4102 else 4103 bmcr = 0; 4104 4105 /* Configure the inband state. Ensure ISOLATE bit is disabled */ 4106 ret = mdiodev_modify(pcs, MII_BMCR, BMCR_ANENABLE | BMCR_ISOLATE, bmcr); 4107 if (ret < 0) 4108 return ret; 4109 4110 return changed; 4111 } 4112 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_config); 4113 4114 /** 4115 * phylink_mii_c22_pcs_an_restart() - restart 802.3z autonegotiation 4116 * @pcs: a pointer to a &struct mdio_device. 4117 * 4118 * Helper for MAC PCS supporting the 802.3 clause 22 register set for 4119 * clause 37 negotiation. 4120 * 4121 * Restart the clause 37 negotiation with the link partner. This is 4122 * suitable to be directly plugged into the pcs_get_state() member 4123 * of the struct phylink_pcs_ops structure. 4124 */ 4125 void phylink_mii_c22_pcs_an_restart(struct mdio_device *pcs) 4126 { 4127 int val = mdiodev_read(pcs, MII_BMCR); 4128 4129 if (val >= 0) { 4130 val |= BMCR_ANRESTART; 4131 4132 mdiodev_write(pcs, MII_BMCR, val); 4133 } 4134 } 4135 EXPORT_SYMBOL_GPL(phylink_mii_c22_pcs_an_restart); 4136 4137 void phylink_mii_c45_pcs_get_state(struct mdio_device *pcs, 4138 struct phylink_link_state *state) 4139 { 4140 struct mii_bus *bus = pcs->bus; 4141 int addr = pcs->addr; 4142 int stat; 4143 4144 stat = mdiobus_c45_read(bus, addr, MDIO_MMD_PCS, MDIO_STAT1); 4145 if (stat < 0) { 4146 state->link = false; 4147 return; 4148 } 4149 4150 state->link = !!(stat & MDIO_STAT1_LSTATUS); 4151 if (!state->link) 4152 return; 4153 4154 switch (state->interface) { 4155 case PHY_INTERFACE_MODE_10GBASER: 4156 state->speed = SPEED_10000; 4157 state->duplex = DUPLEX_FULL; 4158 break; 4159 4160 default: 4161 break; 4162 } 4163 } 4164 EXPORT_SYMBOL_GPL(phylink_mii_c45_pcs_get_state); 4165 4166 static int __init phylink_init(void) 4167 { 4168 for (int i = 0; i < ARRAY_SIZE(phylink_sfp_interface_preference); ++i) 4169 __set_bit(phylink_sfp_interface_preference[i], 4170 phylink_sfp_interfaces); 4171 4172 return 0; 4173 } 4174 4175 module_init(phylink_init); 4176 4177 MODULE_LICENSE("GPL v2"); 4178 MODULE_DESCRIPTION("phylink models the MAC to optional PHY connection"); 4179