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