1 /* 2 * phylink models the MAC to optional PHY connection, supporting 3 * technologies such as SFP cages where the PHY is hot-pluggable. 4 * 5 * Copyright (C) 2015 Russell King 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/ethtool.h> 12 #include <linux/export.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/netdevice.h> 15 #include <linux/of.h> 16 #include <linux/of_mdio.h> 17 #include <linux/phy.h> 18 #include <linux/phy_fixed.h> 19 #include <linux/phylink.h> 20 #include <linux/rtnetlink.h> 21 #include <linux/spinlock.h> 22 #include <linux/workqueue.h> 23 24 #include "sfp.h" 25 #include "swphy.h" 26 27 #define SUPPORTED_INTERFACES \ 28 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \ 29 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane) 30 #define ADVERTISED_INTERFACES \ 31 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \ 32 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane) 33 34 enum { 35 PHYLINK_DISABLE_STOPPED, 36 PHYLINK_DISABLE_LINK, 37 }; 38 39 struct phylink { 40 struct net_device *netdev; 41 const struct phylink_mac_ops *ops; 42 43 unsigned long phylink_disable_state; /* bitmask of disables */ 44 struct phy_device *phydev; 45 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */ 46 u8 link_an_mode; /* MLO_AN_xxx */ 47 u8 link_port; /* The current non-phy ethtool port */ 48 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 49 50 /* The link configuration settings */ 51 struct phylink_link_state link_config; 52 struct gpio_desc *link_gpio; 53 54 struct mutex state_mutex; 55 struct phylink_link_state phy_state; 56 struct work_struct resolve; 57 58 bool mac_link_dropped; 59 60 struct sfp_bus *sfp_bus; 61 }; 62 63 static inline void linkmode_zero(unsigned long *dst) 64 { 65 bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS); 66 } 67 68 static inline void linkmode_copy(unsigned long *dst, const unsigned long *src) 69 { 70 bitmap_copy(dst, src, __ETHTOOL_LINK_MODE_MASK_NBITS); 71 } 72 73 static inline void linkmode_and(unsigned long *dst, const unsigned long *a, 74 const unsigned long *b) 75 { 76 bitmap_and(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS); 77 } 78 79 static inline void linkmode_or(unsigned long *dst, const unsigned long *a, 80 const unsigned long *b) 81 { 82 bitmap_or(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS); 83 } 84 85 static inline bool linkmode_empty(const unsigned long *src) 86 { 87 return bitmap_empty(src, __ETHTOOL_LINK_MODE_MASK_NBITS); 88 } 89 90 void phylink_set_port_modes(unsigned long *mask) 91 { 92 phylink_set(mask, TP); 93 phylink_set(mask, AUI); 94 phylink_set(mask, MII); 95 phylink_set(mask, FIBRE); 96 phylink_set(mask, BNC); 97 phylink_set(mask, Backplane); 98 } 99 EXPORT_SYMBOL_GPL(phylink_set_port_modes); 100 101 static int phylink_is_empty_linkmode(const unsigned long *linkmode) 102 { 103 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, }; 104 105 phylink_set_port_modes(tmp); 106 phylink_set(tmp, Autoneg); 107 phylink_set(tmp, Pause); 108 phylink_set(tmp, Asym_Pause); 109 110 bitmap_andnot(tmp, linkmode, tmp, __ETHTOOL_LINK_MODE_MASK_NBITS); 111 112 return linkmode_empty(tmp); 113 } 114 115 static const char *phylink_an_mode_str(unsigned int mode) 116 { 117 static const char *modestr[] = { 118 [MLO_AN_PHY] = "phy", 119 [MLO_AN_FIXED] = "fixed", 120 [MLO_AN_SGMII] = "SGMII", 121 [MLO_AN_8023Z] = "802.3z", 122 }; 123 124 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown"; 125 } 126 127 static int phylink_validate(struct phylink *pl, unsigned long *supported, 128 struct phylink_link_state *state) 129 { 130 pl->ops->validate(pl->netdev, supported, state); 131 132 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0; 133 } 134 135 static int phylink_parse_fixedlink(struct phylink *pl, struct device_node *np) 136 { 137 struct device_node *fixed_node; 138 const struct phy_setting *s; 139 struct gpio_desc *desc; 140 const __be32 *fixed_prop; 141 u32 speed; 142 int ret, len; 143 144 fixed_node = of_get_child_by_name(np, "fixed-link"); 145 if (fixed_node) { 146 ret = of_property_read_u32(fixed_node, "speed", &speed); 147 148 pl->link_config.speed = speed; 149 pl->link_config.duplex = DUPLEX_HALF; 150 151 if (of_property_read_bool(fixed_node, "full-duplex")) 152 pl->link_config.duplex = DUPLEX_FULL; 153 154 /* We treat the "pause" and "asym-pause" terminology as 155 * defining the link partner's ability. */ 156 if (of_property_read_bool(fixed_node, "pause")) 157 pl->link_config.pause |= MLO_PAUSE_SYM; 158 if (of_property_read_bool(fixed_node, "asym-pause")) 159 pl->link_config.pause |= MLO_PAUSE_ASYM; 160 161 if (ret == 0) { 162 desc = fwnode_get_named_gpiod(&fixed_node->fwnode, 163 "link-gpios", 0, 164 GPIOD_IN, "?"); 165 166 if (!IS_ERR(desc)) 167 pl->link_gpio = desc; 168 else if (desc == ERR_PTR(-EPROBE_DEFER)) 169 ret = -EPROBE_DEFER; 170 } 171 of_node_put(fixed_node); 172 173 if (ret) 174 return ret; 175 } else { 176 fixed_prop = of_get_property(np, "fixed-link", &len); 177 if (!fixed_prop) { 178 netdev_err(pl->netdev, "broken fixed-link?\n"); 179 return -EINVAL; 180 } 181 if (len == 5 * sizeof(*fixed_prop)) { 182 pl->link_config.duplex = be32_to_cpu(fixed_prop[1]) ? 183 DUPLEX_FULL : DUPLEX_HALF; 184 pl->link_config.speed = be32_to_cpu(fixed_prop[2]); 185 if (be32_to_cpu(fixed_prop[3])) 186 pl->link_config.pause |= MLO_PAUSE_SYM; 187 if (be32_to_cpu(fixed_prop[4])) 188 pl->link_config.pause |= MLO_PAUSE_ASYM; 189 } 190 } 191 192 if (pl->link_config.speed > SPEED_1000 && 193 pl->link_config.duplex != DUPLEX_FULL) 194 netdev_warn(pl->netdev, "fixed link specifies half duplex for %dMbps link?\n", 195 pl->link_config.speed); 196 197 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS); 198 linkmode_copy(pl->link_config.advertising, pl->supported); 199 phylink_validate(pl, pl->supported, &pl->link_config); 200 201 s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex, 202 pl->supported, 203 __ETHTOOL_LINK_MODE_MASK_NBITS, true); 204 linkmode_zero(pl->supported); 205 phylink_set(pl->supported, MII); 206 if (s) { 207 __set_bit(s->bit, pl->supported); 208 } else { 209 netdev_warn(pl->netdev, "fixed link %s duplex %dMbps not recognised\n", 210 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half", 211 pl->link_config.speed); 212 } 213 214 linkmode_and(pl->link_config.advertising, pl->link_config.advertising, 215 pl->supported); 216 217 pl->link_config.link = 1; 218 pl->link_config.an_complete = 1; 219 220 return 0; 221 } 222 223 static int phylink_parse_mode(struct phylink *pl, struct device_node *np) 224 { 225 struct device_node *dn; 226 const char *managed; 227 228 dn = of_get_child_by_name(np, "fixed-link"); 229 if (dn || of_find_property(np, "fixed-link", NULL)) 230 pl->link_an_mode = MLO_AN_FIXED; 231 of_node_put(dn); 232 233 if (of_property_read_string(np, "managed", &managed) == 0 && 234 strcmp(managed, "in-band-status") == 0) { 235 if (pl->link_an_mode == MLO_AN_FIXED) { 236 netdev_err(pl->netdev, 237 "can't use both fixed-link and in-band-status\n"); 238 return -EINVAL; 239 } 240 241 linkmode_zero(pl->supported); 242 phylink_set(pl->supported, MII); 243 phylink_set(pl->supported, Autoneg); 244 phylink_set(pl->supported, Asym_Pause); 245 phylink_set(pl->supported, Pause); 246 pl->link_config.an_enabled = true; 247 248 switch (pl->link_config.interface) { 249 case PHY_INTERFACE_MODE_SGMII: 250 phylink_set(pl->supported, 10baseT_Half); 251 phylink_set(pl->supported, 10baseT_Full); 252 phylink_set(pl->supported, 100baseT_Half); 253 phylink_set(pl->supported, 100baseT_Full); 254 phylink_set(pl->supported, 1000baseT_Half); 255 phylink_set(pl->supported, 1000baseT_Full); 256 pl->link_an_mode = MLO_AN_SGMII; 257 break; 258 259 case PHY_INTERFACE_MODE_1000BASEX: 260 phylink_set(pl->supported, 1000baseX_Full); 261 pl->link_an_mode = MLO_AN_8023Z; 262 break; 263 264 case PHY_INTERFACE_MODE_2500BASEX: 265 phylink_set(pl->supported, 2500baseX_Full); 266 pl->link_an_mode = MLO_AN_8023Z; 267 break; 268 269 case PHY_INTERFACE_MODE_10GKR: 270 phylink_set(pl->supported, 10baseT_Half); 271 phylink_set(pl->supported, 10baseT_Full); 272 phylink_set(pl->supported, 100baseT_Half); 273 phylink_set(pl->supported, 100baseT_Full); 274 phylink_set(pl->supported, 1000baseT_Half); 275 phylink_set(pl->supported, 1000baseT_Full); 276 phylink_set(pl->supported, 1000baseX_Full); 277 phylink_set(pl->supported, 10000baseKR_Full); 278 phylink_set(pl->supported, 10000baseCR_Full); 279 phylink_set(pl->supported, 10000baseSR_Full); 280 phylink_set(pl->supported, 10000baseLR_Full); 281 phylink_set(pl->supported, 10000baseLRM_Full); 282 phylink_set(pl->supported, 10000baseER_Full); 283 pl->link_an_mode = MLO_AN_SGMII; 284 break; 285 286 default: 287 netdev_err(pl->netdev, 288 "incorrect link mode %s for in-band status\n", 289 phy_modes(pl->link_config.interface)); 290 return -EINVAL; 291 } 292 293 linkmode_copy(pl->link_config.advertising, pl->supported); 294 295 if (phylink_validate(pl, pl->supported, &pl->link_config)) { 296 netdev_err(pl->netdev, 297 "failed to validate link configuration for in-band status\n"); 298 return -EINVAL; 299 } 300 } 301 302 return 0; 303 } 304 305 static void phylink_mac_config(struct phylink *pl, 306 const struct phylink_link_state *state) 307 { 308 netdev_dbg(pl->netdev, 309 "%s: mode=%s/%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n", 310 __func__, phylink_an_mode_str(pl->link_an_mode), 311 phy_modes(state->interface), 312 phy_speed_to_str(state->speed), 313 phy_duplex_to_str(state->duplex), 314 __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising, 315 state->pause, state->link, state->an_enabled); 316 317 pl->ops->mac_config(pl->netdev, pl->link_an_mode, state); 318 } 319 320 static void phylink_mac_an_restart(struct phylink *pl) 321 { 322 if (pl->link_config.an_enabled && 323 (pl->link_config.interface == PHY_INTERFACE_MODE_1000BASEX || 324 pl->link_config.interface == PHY_INTERFACE_MODE_2500BASEX)) 325 pl->ops->mac_an_restart(pl->netdev); 326 } 327 328 static int phylink_get_mac_state(struct phylink *pl, struct phylink_link_state *state) 329 { 330 struct net_device *ndev = pl->netdev; 331 332 linkmode_copy(state->advertising, pl->link_config.advertising); 333 linkmode_zero(state->lp_advertising); 334 state->interface = pl->link_config.interface; 335 state->an_enabled = pl->link_config.an_enabled; 336 state->link = 1; 337 338 return pl->ops->mac_link_state(ndev, state); 339 } 340 341 /* The fixed state is... fixed except for the link state, 342 * which may be determined by a GPIO. 343 */ 344 static void phylink_get_fixed_state(struct phylink *pl, struct phylink_link_state *state) 345 { 346 *state = pl->link_config; 347 if (pl->link_gpio) 348 state->link = !!gpiod_get_value(pl->link_gpio); 349 } 350 351 /* Flow control is resolved according to our and the link partners 352 * advertisments using the following drawn from the 802.3 specs: 353 * Local device Link partner 354 * Pause AsymDir Pause AsymDir Result 355 * 1 X 1 X TX+RX 356 * 0 1 1 1 RX 357 * 1 1 0 1 TX 358 */ 359 static void phylink_resolve_flow(struct phylink *pl, 360 struct phylink_link_state *state) 361 { 362 int new_pause = 0; 363 364 if (pl->link_config.pause & MLO_PAUSE_AN) { 365 int pause = 0; 366 367 if (phylink_test(pl->link_config.advertising, Pause)) 368 pause |= MLO_PAUSE_SYM; 369 if (phylink_test(pl->link_config.advertising, Asym_Pause)) 370 pause |= MLO_PAUSE_ASYM; 371 372 pause &= state->pause; 373 374 if (pause & MLO_PAUSE_SYM) 375 new_pause = MLO_PAUSE_TX | MLO_PAUSE_RX; 376 else if (pause & MLO_PAUSE_ASYM) 377 new_pause = state->pause & MLO_PAUSE_SYM ? 378 MLO_PAUSE_RX : MLO_PAUSE_TX; 379 } else { 380 new_pause = pl->link_config.pause & MLO_PAUSE_TXRX_MASK; 381 } 382 383 state->pause &= ~MLO_PAUSE_TXRX_MASK; 384 state->pause |= new_pause; 385 } 386 387 static const char *phylink_pause_to_str(int pause) 388 { 389 switch (pause & MLO_PAUSE_TXRX_MASK) { 390 case MLO_PAUSE_TX | MLO_PAUSE_RX: 391 return "rx/tx"; 392 case MLO_PAUSE_TX: 393 return "tx"; 394 case MLO_PAUSE_RX: 395 return "rx"; 396 default: 397 return "off"; 398 } 399 } 400 401 static void phylink_resolve(struct work_struct *w) 402 { 403 struct phylink *pl = container_of(w, struct phylink, resolve); 404 struct phylink_link_state link_state; 405 struct net_device *ndev = pl->netdev; 406 407 mutex_lock(&pl->state_mutex); 408 if (pl->phylink_disable_state) { 409 pl->mac_link_dropped = false; 410 link_state.link = false; 411 } else if (pl->mac_link_dropped) { 412 link_state.link = false; 413 } else { 414 switch (pl->link_an_mode) { 415 case MLO_AN_PHY: 416 link_state = pl->phy_state; 417 phylink_resolve_flow(pl, &link_state); 418 phylink_mac_config(pl, &link_state); 419 break; 420 421 case MLO_AN_FIXED: 422 phylink_get_fixed_state(pl, &link_state); 423 phylink_mac_config(pl, &link_state); 424 break; 425 426 case MLO_AN_SGMII: 427 phylink_get_mac_state(pl, &link_state); 428 if (pl->phydev) { 429 bool changed = false; 430 431 link_state.link = link_state.link && 432 pl->phy_state.link; 433 434 if (pl->phy_state.interface != 435 link_state.interface) { 436 link_state.interface = pl->phy_state.interface; 437 changed = true; 438 } 439 440 /* Propagate the flow control from the PHY 441 * to the MAC. Also propagate the interface 442 * if changed. 443 */ 444 if (pl->phy_state.link || changed) { 445 link_state.pause |= pl->phy_state.pause; 446 phylink_resolve_flow(pl, &link_state); 447 448 phylink_mac_config(pl, &link_state); 449 } 450 } 451 break; 452 453 case MLO_AN_8023Z: 454 phylink_get_mac_state(pl, &link_state); 455 break; 456 } 457 } 458 459 if (link_state.link != netif_carrier_ok(ndev)) { 460 if (!link_state.link) { 461 netif_carrier_off(ndev); 462 pl->ops->mac_link_down(ndev, pl->link_an_mode); 463 netdev_info(ndev, "Link is Down\n"); 464 } else { 465 pl->ops->mac_link_up(ndev, pl->link_an_mode, 466 pl->phydev); 467 468 netif_carrier_on(ndev); 469 470 netdev_info(ndev, 471 "Link is Up - %s/%s - flow control %s\n", 472 phy_speed_to_str(link_state.speed), 473 phy_duplex_to_str(link_state.duplex), 474 phylink_pause_to_str(link_state.pause)); 475 } 476 } 477 if (!link_state.link && pl->mac_link_dropped) { 478 pl->mac_link_dropped = false; 479 queue_work(system_power_efficient_wq, &pl->resolve); 480 } 481 mutex_unlock(&pl->state_mutex); 482 } 483 484 static void phylink_run_resolve(struct phylink *pl) 485 { 486 if (!pl->phylink_disable_state) 487 queue_work(system_power_efficient_wq, &pl->resolve); 488 } 489 490 static const struct sfp_upstream_ops sfp_phylink_ops; 491 492 static int phylink_register_sfp(struct phylink *pl, struct device_node *np) 493 { 494 struct device_node *sfp_np; 495 496 sfp_np = of_parse_phandle(np, "sfp", 0); 497 if (!sfp_np) 498 return 0; 499 500 pl->sfp_bus = sfp_register_upstream(sfp_np, pl->netdev, pl, 501 &sfp_phylink_ops); 502 if (!pl->sfp_bus) 503 return -ENOMEM; 504 505 return 0; 506 } 507 508 struct phylink *phylink_create(struct net_device *ndev, struct device_node *np, 509 phy_interface_t iface, const struct phylink_mac_ops *ops) 510 { 511 struct phylink *pl; 512 int ret; 513 514 pl = kzalloc(sizeof(*pl), GFP_KERNEL); 515 if (!pl) 516 return ERR_PTR(-ENOMEM); 517 518 mutex_init(&pl->state_mutex); 519 INIT_WORK(&pl->resolve, phylink_resolve); 520 pl->netdev = ndev; 521 pl->phy_state.interface = iface; 522 pl->link_interface = iface; 523 pl->link_port = PORT_MII; 524 pl->link_config.interface = iface; 525 pl->link_config.pause = MLO_PAUSE_AN; 526 pl->link_config.speed = SPEED_UNKNOWN; 527 pl->link_config.duplex = DUPLEX_UNKNOWN; 528 pl->ops = ops; 529 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 530 531 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS); 532 linkmode_copy(pl->link_config.advertising, pl->supported); 533 phylink_validate(pl, pl->supported, &pl->link_config); 534 535 ret = phylink_parse_mode(pl, np); 536 if (ret < 0) { 537 kfree(pl); 538 return ERR_PTR(ret); 539 } 540 541 if (pl->link_an_mode == MLO_AN_FIXED) { 542 ret = phylink_parse_fixedlink(pl, np); 543 if (ret < 0) { 544 kfree(pl); 545 return ERR_PTR(ret); 546 } 547 } 548 549 ret = phylink_register_sfp(pl, np); 550 if (ret < 0) { 551 kfree(pl); 552 return ERR_PTR(ret); 553 } 554 555 return pl; 556 } 557 EXPORT_SYMBOL_GPL(phylink_create); 558 559 void phylink_destroy(struct phylink *pl) 560 { 561 if (pl->sfp_bus) 562 sfp_unregister_upstream(pl->sfp_bus); 563 564 cancel_work_sync(&pl->resolve); 565 kfree(pl); 566 } 567 EXPORT_SYMBOL_GPL(phylink_destroy); 568 569 void phylink_phy_change(struct phy_device *phydev, bool up, bool do_carrier) 570 { 571 struct phylink *pl = phydev->phylink; 572 573 mutex_lock(&pl->state_mutex); 574 pl->phy_state.speed = phydev->speed; 575 pl->phy_state.duplex = phydev->duplex; 576 pl->phy_state.pause = MLO_PAUSE_NONE; 577 if (phydev->pause) 578 pl->phy_state.pause |= MLO_PAUSE_SYM; 579 if (phydev->asym_pause) 580 pl->phy_state.pause |= MLO_PAUSE_ASYM; 581 pl->phy_state.interface = phydev->interface; 582 pl->phy_state.link = up; 583 mutex_unlock(&pl->state_mutex); 584 585 phylink_run_resolve(pl); 586 587 netdev_dbg(pl->netdev, "phy link %s %s/%s/%s\n", up ? "up" : "down", 588 phy_modes(phydev->interface), 589 phy_speed_to_str(phydev->speed), 590 phy_duplex_to_str(phydev->duplex)); 591 } 592 593 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy) 594 { 595 struct phylink_link_state config; 596 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 597 u32 advertising; 598 int ret; 599 600 memset(&config, 0, sizeof(config)); 601 ethtool_convert_legacy_u32_to_link_mode(supported, phy->supported); 602 ethtool_convert_legacy_u32_to_link_mode(config.advertising, 603 phy->advertising); 604 config.interface = pl->link_config.interface; 605 606 /* 607 * This is the new way of dealing with flow control for PHYs, 608 * as described by Timur Tabi in commit 529ed1275263 ("net: phy: 609 * phy drivers should not set SUPPORTED_[Asym_]Pause") except 610 * using our validate call to the MAC, we rely upon the MAC 611 * clearing the bits from both supported and advertising fields. 612 */ 613 if (phylink_test(supported, Pause)) 614 phylink_set(config.advertising, Pause); 615 if (phylink_test(supported, Asym_Pause)) 616 phylink_set(config.advertising, Asym_Pause); 617 618 ret = phylink_validate(pl, supported, &config); 619 if (ret) 620 return ret; 621 622 phy->phylink = pl; 623 phy->phy_link_change = phylink_phy_change; 624 625 netdev_info(pl->netdev, 626 "PHY [%s] driver [%s]\n", dev_name(&phy->mdio.dev), 627 phy->drv->name); 628 629 mutex_lock(&phy->lock); 630 mutex_lock(&pl->state_mutex); 631 pl->netdev->phydev = phy; 632 pl->phydev = phy; 633 linkmode_copy(pl->supported, supported); 634 linkmode_copy(pl->link_config.advertising, config.advertising); 635 636 /* Restrict the phy advertisment according to the MAC support. */ 637 ethtool_convert_link_mode_to_legacy_u32(&advertising, config.advertising); 638 phy->advertising = advertising; 639 mutex_unlock(&pl->state_mutex); 640 mutex_unlock(&phy->lock); 641 642 netdev_dbg(pl->netdev, 643 "phy: setting supported %*pb advertising 0x%08x\n", 644 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported, 645 phy->advertising); 646 647 phy_start_machine(phy); 648 if (phy->irq > 0) 649 phy_start_interrupts(phy); 650 651 return 0; 652 } 653 654 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy) 655 { 656 int ret; 657 658 ret = phy_attach_direct(pl->netdev, phy, 0, pl->link_interface); 659 if (ret) 660 return ret; 661 662 ret = phylink_bringup_phy(pl, phy); 663 if (ret) 664 phy_detach(phy); 665 666 return ret; 667 } 668 EXPORT_SYMBOL_GPL(phylink_connect_phy); 669 670 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn) 671 { 672 struct device_node *phy_node; 673 struct phy_device *phy_dev; 674 int ret; 675 676 /* Fixed links are handled without needing a PHY */ 677 if (pl->link_an_mode == MLO_AN_FIXED) 678 return 0; 679 680 phy_node = of_parse_phandle(dn, "phy-handle", 0); 681 if (!phy_node) 682 phy_node = of_parse_phandle(dn, "phy", 0); 683 if (!phy_node) 684 phy_node = of_parse_phandle(dn, "phy-device", 0); 685 686 if (!phy_node) { 687 if (pl->link_an_mode == MLO_AN_PHY) { 688 netdev_err(pl->netdev, "unable to find PHY node\n"); 689 return -ENODEV; 690 } 691 return 0; 692 } 693 694 phy_dev = of_phy_attach(pl->netdev, phy_node, 0, pl->link_interface); 695 /* We're done with the phy_node handle */ 696 of_node_put(phy_node); 697 698 if (!phy_dev) 699 return -ENODEV; 700 701 ret = phylink_bringup_phy(pl, phy_dev); 702 if (ret) 703 phy_detach(phy_dev); 704 705 return ret; 706 } 707 EXPORT_SYMBOL_GPL(phylink_of_phy_connect); 708 709 void phylink_disconnect_phy(struct phylink *pl) 710 { 711 struct phy_device *phy; 712 713 WARN_ON(!lockdep_rtnl_is_held()); 714 715 phy = pl->phydev; 716 if (phy) { 717 mutex_lock(&phy->lock); 718 mutex_lock(&pl->state_mutex); 719 pl->netdev->phydev = NULL; 720 pl->phydev = NULL; 721 mutex_unlock(&pl->state_mutex); 722 mutex_unlock(&phy->lock); 723 flush_work(&pl->resolve); 724 725 phy_disconnect(phy); 726 } 727 } 728 EXPORT_SYMBOL_GPL(phylink_disconnect_phy); 729 730 void phylink_mac_change(struct phylink *pl, bool up) 731 { 732 if (!up) 733 pl->mac_link_dropped = true; 734 phylink_run_resolve(pl); 735 netdev_dbg(pl->netdev, "mac link %s\n", up ? "up" : "down"); 736 } 737 EXPORT_SYMBOL_GPL(phylink_mac_change); 738 739 void phylink_start(struct phylink *pl) 740 { 741 WARN_ON(!lockdep_rtnl_is_held()); 742 743 netdev_info(pl->netdev, "configuring for %s/%s link mode\n", 744 phylink_an_mode_str(pl->link_an_mode), 745 phy_modes(pl->link_config.interface)); 746 747 /* Apply the link configuration to the MAC when starting. This allows 748 * a fixed-link to start with the correct parameters, and also 749 * ensures that we set the appropriate advertisment for Serdes links. 750 */ 751 phylink_resolve_flow(pl, &pl->link_config); 752 phylink_mac_config(pl, &pl->link_config); 753 754 clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 755 phylink_run_resolve(pl); 756 757 if (pl->sfp_bus) 758 sfp_upstream_start(pl->sfp_bus); 759 if (pl->phydev) 760 phy_start(pl->phydev); 761 } 762 EXPORT_SYMBOL_GPL(phylink_start); 763 764 void phylink_stop(struct phylink *pl) 765 { 766 WARN_ON(!lockdep_rtnl_is_held()); 767 768 if (pl->phydev) 769 phy_stop(pl->phydev); 770 if (pl->sfp_bus) 771 sfp_upstream_stop(pl->sfp_bus); 772 773 set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 774 flush_work(&pl->resolve); 775 } 776 EXPORT_SYMBOL_GPL(phylink_stop); 777 778 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 779 { 780 WARN_ON(!lockdep_rtnl_is_held()); 781 782 wol->supported = 0; 783 wol->wolopts = 0; 784 785 if (pl->phydev) 786 phy_ethtool_get_wol(pl->phydev, wol); 787 } 788 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol); 789 790 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 791 { 792 int ret = -EOPNOTSUPP; 793 794 WARN_ON(!lockdep_rtnl_is_held()); 795 796 if (pl->phydev) 797 ret = phy_ethtool_set_wol(pl->phydev, wol); 798 799 return ret; 800 } 801 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol); 802 803 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b) 804 { 805 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask); 806 807 linkmode_zero(mask); 808 phylink_set_port_modes(mask); 809 810 linkmode_and(dst, dst, mask); 811 linkmode_or(dst, dst, b); 812 } 813 814 static void phylink_get_ksettings(const struct phylink_link_state *state, 815 struct ethtool_link_ksettings *kset) 816 { 817 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising); 818 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising); 819 kset->base.speed = state->speed; 820 kset->base.duplex = state->duplex; 821 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE : 822 AUTONEG_DISABLE; 823 } 824 825 int phylink_ethtool_ksettings_get(struct phylink *pl, 826 struct ethtool_link_ksettings *kset) 827 { 828 struct phylink_link_state link_state; 829 830 WARN_ON(!lockdep_rtnl_is_held()); 831 832 if (pl->phydev) { 833 phy_ethtool_ksettings_get(pl->phydev, kset); 834 } else { 835 kset->base.port = pl->link_port; 836 } 837 838 linkmode_copy(kset->link_modes.supported, pl->supported); 839 840 switch (pl->link_an_mode) { 841 case MLO_AN_FIXED: 842 /* We are using fixed settings. Report these as the 843 * current link settings - and note that these also 844 * represent the supported speeds/duplex/pause modes. 845 */ 846 phylink_get_fixed_state(pl, &link_state); 847 phylink_get_ksettings(&link_state, kset); 848 break; 849 850 case MLO_AN_SGMII: 851 /* If there is a phy attached, then use the reported 852 * settings from the phy with no modification. 853 */ 854 if (pl->phydev) 855 break; 856 857 case MLO_AN_8023Z: 858 phylink_get_mac_state(pl, &link_state); 859 860 /* The MAC is reporting the link results from its own PCS 861 * layer via in-band status. Report these as the current 862 * link settings. 863 */ 864 phylink_get_ksettings(&link_state, kset); 865 break; 866 } 867 868 return 0; 869 } 870 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get); 871 872 int phylink_ethtool_ksettings_set(struct phylink *pl, 873 const struct ethtool_link_ksettings *kset) 874 { 875 struct ethtool_link_ksettings our_kset; 876 struct phylink_link_state config; 877 int ret; 878 879 WARN_ON(!lockdep_rtnl_is_held()); 880 881 if (kset->base.autoneg != AUTONEG_DISABLE && 882 kset->base.autoneg != AUTONEG_ENABLE) 883 return -EINVAL; 884 885 config = pl->link_config; 886 887 /* Mask out unsupported advertisments */ 888 linkmode_and(config.advertising, kset->link_modes.advertising, 889 pl->supported); 890 891 /* FIXME: should we reject autoneg if phy/mac does not support it? */ 892 if (kset->base.autoneg == AUTONEG_DISABLE) { 893 const struct phy_setting *s; 894 895 /* Autonegotiation disabled, select a suitable speed and 896 * duplex. 897 */ 898 s = phy_lookup_setting(kset->base.speed, kset->base.duplex, 899 pl->supported, 900 __ETHTOOL_LINK_MODE_MASK_NBITS, false); 901 if (!s) 902 return -EINVAL; 903 904 /* If we have a fixed link (as specified by firmware), refuse 905 * to change link parameters. 906 */ 907 if (pl->link_an_mode == MLO_AN_FIXED && 908 (s->speed != pl->link_config.speed || 909 s->duplex != pl->link_config.duplex)) 910 return -EINVAL; 911 912 config.speed = s->speed; 913 config.duplex = s->duplex; 914 config.an_enabled = false; 915 916 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 917 } else { 918 /* If we have a fixed link, refuse to enable autonegotiation */ 919 if (pl->link_an_mode == MLO_AN_FIXED) 920 return -EINVAL; 921 922 config.speed = SPEED_UNKNOWN; 923 config.duplex = DUPLEX_UNKNOWN; 924 config.an_enabled = true; 925 926 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 927 } 928 929 if (phylink_validate(pl, pl->supported, &config)) 930 return -EINVAL; 931 932 /* If autonegotiation is enabled, we must have an advertisment */ 933 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising)) 934 return -EINVAL; 935 936 our_kset = *kset; 937 linkmode_copy(our_kset.link_modes.advertising, config.advertising); 938 our_kset.base.speed = config.speed; 939 our_kset.base.duplex = config.duplex; 940 941 /* If we have a PHY, configure the phy */ 942 if (pl->phydev) { 943 ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset); 944 if (ret) 945 return ret; 946 } 947 948 mutex_lock(&pl->state_mutex); 949 /* Configure the MAC to match the new settings */ 950 linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising); 951 pl->link_config.speed = our_kset.base.speed; 952 pl->link_config.duplex = our_kset.base.duplex; 953 pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE; 954 955 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 956 phylink_mac_config(pl, &pl->link_config); 957 phylink_mac_an_restart(pl); 958 } 959 mutex_unlock(&pl->state_mutex); 960 961 return 0; 962 } 963 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set); 964 965 int phylink_ethtool_nway_reset(struct phylink *pl) 966 { 967 int ret = 0; 968 969 WARN_ON(!lockdep_rtnl_is_held()); 970 971 if (pl->phydev) 972 ret = phy_restart_aneg(pl->phydev); 973 phylink_mac_an_restart(pl); 974 975 return ret; 976 } 977 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset); 978 979 void phylink_ethtool_get_pauseparam(struct phylink *pl, 980 struct ethtool_pauseparam *pause) 981 { 982 WARN_ON(!lockdep_rtnl_is_held()); 983 984 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN); 985 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX); 986 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX); 987 } 988 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam); 989 990 int phylink_ethtool_set_pauseparam(struct phylink *pl, 991 struct ethtool_pauseparam *pause) 992 { 993 struct phylink_link_state *config = &pl->link_config; 994 995 WARN_ON(!lockdep_rtnl_is_held()); 996 997 if (!phylink_test(pl->supported, Pause) && 998 !phylink_test(pl->supported, Asym_Pause)) 999 return -EOPNOTSUPP; 1000 1001 if (!phylink_test(pl->supported, Asym_Pause) && 1002 !pause->autoneg && pause->rx_pause != pause->tx_pause) 1003 return -EINVAL; 1004 1005 config->pause &= ~(MLO_PAUSE_AN | MLO_PAUSE_TXRX_MASK); 1006 1007 if (pause->autoneg) 1008 config->pause |= MLO_PAUSE_AN; 1009 if (pause->rx_pause) 1010 config->pause |= MLO_PAUSE_RX; 1011 if (pause->tx_pause) 1012 config->pause |= MLO_PAUSE_TX; 1013 1014 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 1015 switch (pl->link_an_mode) { 1016 case MLO_AN_PHY: 1017 /* Silently mark the carrier down, and then trigger a resolve */ 1018 netif_carrier_off(pl->netdev); 1019 phylink_run_resolve(pl); 1020 break; 1021 1022 case MLO_AN_FIXED: 1023 /* Should we allow fixed links to change against the config? */ 1024 phylink_resolve_flow(pl, config); 1025 phylink_mac_config(pl, config); 1026 break; 1027 1028 case MLO_AN_SGMII: 1029 case MLO_AN_8023Z: 1030 phylink_mac_config(pl, config); 1031 phylink_mac_an_restart(pl); 1032 break; 1033 } 1034 } 1035 1036 return 0; 1037 } 1038 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam); 1039 1040 int phylink_ethtool_get_module_info(struct phylink *pl, 1041 struct ethtool_modinfo *modinfo) 1042 { 1043 int ret = -EOPNOTSUPP; 1044 1045 WARN_ON(!lockdep_rtnl_is_held()); 1046 1047 if (pl->sfp_bus) 1048 ret = sfp_get_module_info(pl->sfp_bus, modinfo); 1049 1050 return ret; 1051 } 1052 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_info); 1053 1054 int phylink_ethtool_get_module_eeprom(struct phylink *pl, 1055 struct ethtool_eeprom *ee, u8 *buf) 1056 { 1057 int ret = -EOPNOTSUPP; 1058 1059 WARN_ON(!lockdep_rtnl_is_held()); 1060 1061 if (pl->sfp_bus) 1062 ret = sfp_get_module_eeprom(pl->sfp_bus, ee, buf); 1063 1064 return ret; 1065 } 1066 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_eeprom); 1067 1068 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable) 1069 { 1070 int ret = -EPROTONOSUPPORT; 1071 1072 WARN_ON(!lockdep_rtnl_is_held()); 1073 1074 if (pl->phydev) 1075 ret = phy_init_eee(pl->phydev, clk_stop_enable); 1076 1077 return ret; 1078 } 1079 EXPORT_SYMBOL_GPL(phylink_init_eee); 1080 1081 int phylink_get_eee_err(struct phylink *pl) 1082 { 1083 int ret = 0; 1084 1085 WARN_ON(!lockdep_rtnl_is_held()); 1086 1087 if (pl->phydev) 1088 ret = phy_get_eee_err(pl->phydev); 1089 1090 return ret; 1091 } 1092 EXPORT_SYMBOL_GPL(phylink_get_eee_err); 1093 1094 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee) 1095 { 1096 int ret = -EOPNOTSUPP; 1097 1098 WARN_ON(!lockdep_rtnl_is_held()); 1099 1100 if (pl->phydev) 1101 ret = phy_ethtool_get_eee(pl->phydev, eee); 1102 1103 return ret; 1104 } 1105 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee); 1106 1107 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee) 1108 { 1109 int ret = -EOPNOTSUPP; 1110 1111 WARN_ON(!lockdep_rtnl_is_held()); 1112 1113 if (pl->phydev) 1114 ret = phy_ethtool_set_eee(pl->phydev, eee); 1115 1116 return ret; 1117 } 1118 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee); 1119 1120 /* This emulates MII registers for a fixed-mode phy operating as per the 1121 * passed in state. "aneg" defines if we report negotiation is possible. 1122 * 1123 * FIXME: should deal with negotiation state too. 1124 */ 1125 static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg, 1126 struct phylink_link_state *state, bool aneg) 1127 { 1128 struct fixed_phy_status fs; 1129 int val; 1130 1131 fs.link = state->link; 1132 fs.speed = state->speed; 1133 fs.duplex = state->duplex; 1134 fs.pause = state->pause & MLO_PAUSE_SYM; 1135 fs.asym_pause = state->pause & MLO_PAUSE_ASYM; 1136 1137 val = swphy_read_reg(reg, &fs); 1138 if (reg == MII_BMSR) { 1139 if (!state->an_complete) 1140 val &= ~BMSR_ANEGCOMPLETE; 1141 if (!aneg) 1142 val &= ~BMSR_ANEGCAPABLE; 1143 } 1144 return val; 1145 } 1146 1147 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id, 1148 unsigned int reg) 1149 { 1150 struct phy_device *phydev = pl->phydev; 1151 int prtad, devad; 1152 1153 if (mdio_phy_id_is_c45(phy_id)) { 1154 prtad = mdio_phy_id_prtad(phy_id); 1155 devad = mdio_phy_id_devad(phy_id); 1156 devad = MII_ADDR_C45 | devad << 16 | reg; 1157 } else if (phydev->is_c45) { 1158 switch (reg) { 1159 case MII_BMCR: 1160 case MII_BMSR: 1161 case MII_PHYSID1: 1162 case MII_PHYSID2: 1163 devad = __ffs(phydev->c45_ids.devices_in_package); 1164 break; 1165 case MII_ADVERTISE: 1166 case MII_LPA: 1167 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1168 return -EINVAL; 1169 devad = MDIO_MMD_AN; 1170 if (reg == MII_ADVERTISE) 1171 reg = MDIO_AN_ADVERTISE; 1172 else 1173 reg = MDIO_AN_LPA; 1174 break; 1175 default: 1176 return -EINVAL; 1177 } 1178 prtad = phy_id; 1179 devad = MII_ADDR_C45 | devad << 16 | reg; 1180 } else { 1181 prtad = phy_id; 1182 devad = reg; 1183 } 1184 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad); 1185 } 1186 1187 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id, 1188 unsigned int reg, unsigned int val) 1189 { 1190 struct phy_device *phydev = pl->phydev; 1191 int prtad, devad; 1192 1193 if (mdio_phy_id_is_c45(phy_id)) { 1194 prtad = mdio_phy_id_prtad(phy_id); 1195 devad = mdio_phy_id_devad(phy_id); 1196 devad = MII_ADDR_C45 | devad << 16 | reg; 1197 } else if (phydev->is_c45) { 1198 switch (reg) { 1199 case MII_BMCR: 1200 case MII_BMSR: 1201 case MII_PHYSID1: 1202 case MII_PHYSID2: 1203 devad = __ffs(phydev->c45_ids.devices_in_package); 1204 break; 1205 case MII_ADVERTISE: 1206 case MII_LPA: 1207 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1208 return -EINVAL; 1209 devad = MDIO_MMD_AN; 1210 if (reg == MII_ADVERTISE) 1211 reg = MDIO_AN_ADVERTISE; 1212 else 1213 reg = MDIO_AN_LPA; 1214 break; 1215 default: 1216 return -EINVAL; 1217 } 1218 prtad = phy_id; 1219 devad = MII_ADDR_C45 | devad << 16 | reg; 1220 } else { 1221 prtad = phy_id; 1222 devad = reg; 1223 } 1224 1225 return mdiobus_write(phydev->mdio.bus, prtad, devad, val); 1226 } 1227 1228 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id, 1229 unsigned int reg) 1230 { 1231 struct phylink_link_state state; 1232 int val = 0xffff; 1233 1234 switch (pl->link_an_mode) { 1235 case MLO_AN_FIXED: 1236 if (phy_id == 0) { 1237 phylink_get_fixed_state(pl, &state); 1238 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1239 true); 1240 } 1241 break; 1242 1243 case MLO_AN_PHY: 1244 return -EOPNOTSUPP; 1245 1246 case MLO_AN_SGMII: 1247 /* No phy, fall through to 8023z method */ 1248 case MLO_AN_8023Z: 1249 if (phy_id == 0) { 1250 val = phylink_get_mac_state(pl, &state); 1251 if (val < 0) 1252 return val; 1253 1254 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1255 true); 1256 } 1257 break; 1258 } 1259 1260 return val & 0xffff; 1261 } 1262 1263 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id, 1264 unsigned int reg, unsigned int val) 1265 { 1266 switch (pl->link_an_mode) { 1267 case MLO_AN_FIXED: 1268 break; 1269 1270 case MLO_AN_PHY: 1271 return -EOPNOTSUPP; 1272 1273 case MLO_AN_SGMII: 1274 /* No phy, fall through to 8023z method */ 1275 case MLO_AN_8023Z: 1276 break; 1277 } 1278 1279 return 0; 1280 } 1281 1282 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd) 1283 { 1284 struct mii_ioctl_data *mii = if_mii(ifr); 1285 int ret; 1286 1287 WARN_ON(!lockdep_rtnl_is_held()); 1288 1289 if (pl->phydev) { 1290 /* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */ 1291 switch (cmd) { 1292 case SIOCGMIIPHY: 1293 mii->phy_id = pl->phydev->mdio.addr; 1294 1295 case SIOCGMIIREG: 1296 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num); 1297 if (ret >= 0) { 1298 mii->val_out = ret; 1299 ret = 0; 1300 } 1301 break; 1302 1303 case SIOCSMIIREG: 1304 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num, 1305 mii->val_in); 1306 break; 1307 1308 default: 1309 ret = phy_mii_ioctl(pl->phydev, ifr, cmd); 1310 break; 1311 } 1312 } else { 1313 switch (cmd) { 1314 case SIOCGMIIPHY: 1315 mii->phy_id = 0; 1316 1317 case SIOCGMIIREG: 1318 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num); 1319 if (ret >= 0) { 1320 mii->val_out = ret; 1321 ret = 0; 1322 } 1323 break; 1324 1325 case SIOCSMIIREG: 1326 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num, 1327 mii->val_in); 1328 break; 1329 1330 default: 1331 ret = -EOPNOTSUPP; 1332 break; 1333 } 1334 } 1335 1336 return ret; 1337 } 1338 EXPORT_SYMBOL_GPL(phylink_mii_ioctl); 1339 1340 1341 1342 static int phylink_sfp_module_insert(void *upstream, 1343 const struct sfp_eeprom_id *id) 1344 { 1345 struct phylink *pl = upstream; 1346 __ETHTOOL_DECLARE_LINK_MODE_MASK(support) = { 0, }; 1347 struct phylink_link_state config; 1348 phy_interface_t iface; 1349 int mode, ret = 0; 1350 bool changed; 1351 u8 port; 1352 1353 sfp_parse_support(pl->sfp_bus, id, support); 1354 port = sfp_parse_port(pl->sfp_bus, id, support); 1355 iface = sfp_parse_interface(pl->sfp_bus, id); 1356 1357 WARN_ON(!lockdep_rtnl_is_held()); 1358 1359 switch (iface) { 1360 case PHY_INTERFACE_MODE_SGMII: 1361 mode = MLO_AN_SGMII; 1362 break; 1363 case PHY_INTERFACE_MODE_1000BASEX: 1364 mode = MLO_AN_8023Z; 1365 break; 1366 default: 1367 return -EINVAL; 1368 } 1369 1370 memset(&config, 0, sizeof(config)); 1371 linkmode_copy(config.advertising, support); 1372 config.interface = iface; 1373 config.speed = SPEED_UNKNOWN; 1374 config.duplex = DUPLEX_UNKNOWN; 1375 config.pause = MLO_PAUSE_AN; 1376 config.an_enabled = pl->link_config.an_enabled; 1377 1378 /* Ignore errors if we're expecting a PHY to attach later */ 1379 ret = phylink_validate(pl, support, &config); 1380 if (ret) { 1381 netdev_err(pl->netdev, "validation of %s/%s with support %*pb failed: %d\n", 1382 phylink_an_mode_str(mode), phy_modes(config.interface), 1383 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret); 1384 return ret; 1385 } 1386 1387 netdev_dbg(pl->netdev, "requesting link mode %s/%s with support %*pb\n", 1388 phylink_an_mode_str(mode), phy_modes(config.interface), 1389 __ETHTOOL_LINK_MODE_MASK_NBITS, support); 1390 1391 if (mode == MLO_AN_8023Z && pl->phydev) 1392 return -EINVAL; 1393 1394 changed = !bitmap_equal(pl->supported, support, 1395 __ETHTOOL_LINK_MODE_MASK_NBITS); 1396 if (changed) { 1397 linkmode_copy(pl->supported, support); 1398 linkmode_copy(pl->link_config.advertising, config.advertising); 1399 } 1400 1401 if (pl->link_an_mode != mode || 1402 pl->link_config.interface != config.interface) { 1403 pl->link_config.interface = config.interface; 1404 pl->link_an_mode = mode; 1405 1406 changed = true; 1407 1408 netdev_info(pl->netdev, "switched to %s/%s link mode\n", 1409 phylink_an_mode_str(mode), 1410 phy_modes(config.interface)); 1411 } 1412 1413 pl->link_port = port; 1414 1415 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED, 1416 &pl->phylink_disable_state)) 1417 phylink_mac_config(pl, &pl->link_config); 1418 1419 return ret; 1420 } 1421 1422 static void phylink_sfp_link_down(void *upstream) 1423 { 1424 struct phylink *pl = upstream; 1425 1426 WARN_ON(!lockdep_rtnl_is_held()); 1427 1428 set_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state); 1429 flush_work(&pl->resolve); 1430 1431 netif_carrier_off(pl->netdev); 1432 } 1433 1434 static void phylink_sfp_link_up(void *upstream) 1435 { 1436 struct phylink *pl = upstream; 1437 1438 WARN_ON(!lockdep_rtnl_is_held()); 1439 1440 clear_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state); 1441 phylink_run_resolve(pl); 1442 } 1443 1444 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy) 1445 { 1446 return phylink_connect_phy(upstream, phy); 1447 } 1448 1449 static void phylink_sfp_disconnect_phy(void *upstream) 1450 { 1451 phylink_disconnect_phy(upstream); 1452 } 1453 1454 static const struct sfp_upstream_ops sfp_phylink_ops = { 1455 .module_insert = phylink_sfp_module_insert, 1456 .link_up = phylink_sfp_link_up, 1457 .link_down = phylink_sfp_link_down, 1458 .connect_phy = phylink_sfp_connect_phy, 1459 .disconnect_phy = phylink_sfp_disconnect_phy, 1460 }; 1461 1462 MODULE_LICENSE("GPL"); 1463