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