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, 510 const struct phylink_mac_ops *ops) 511 { 512 struct phylink *pl; 513 int ret; 514 515 pl = kzalloc(sizeof(*pl), GFP_KERNEL); 516 if (!pl) 517 return ERR_PTR(-ENOMEM); 518 519 mutex_init(&pl->state_mutex); 520 INIT_WORK(&pl->resolve, phylink_resolve); 521 pl->netdev = ndev; 522 pl->phy_state.interface = iface; 523 pl->link_interface = iface; 524 pl->link_port = PORT_MII; 525 pl->link_config.interface = iface; 526 pl->link_config.pause = MLO_PAUSE_AN; 527 pl->link_config.speed = SPEED_UNKNOWN; 528 pl->link_config.duplex = DUPLEX_UNKNOWN; 529 pl->ops = ops; 530 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 531 532 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS); 533 linkmode_copy(pl->link_config.advertising, pl->supported); 534 phylink_validate(pl, pl->supported, &pl->link_config); 535 536 ret = phylink_parse_mode(pl, np); 537 if (ret < 0) { 538 kfree(pl); 539 return ERR_PTR(ret); 540 } 541 542 if (pl->link_an_mode == MLO_AN_FIXED) { 543 ret = phylink_parse_fixedlink(pl, np); 544 if (ret < 0) { 545 kfree(pl); 546 return ERR_PTR(ret); 547 } 548 } 549 550 ret = phylink_register_sfp(pl, np); 551 if (ret < 0) { 552 kfree(pl); 553 return ERR_PTR(ret); 554 } 555 556 return pl; 557 } 558 EXPORT_SYMBOL_GPL(phylink_create); 559 560 void phylink_destroy(struct phylink *pl) 561 { 562 if (pl->sfp_bus) 563 sfp_unregister_upstream(pl->sfp_bus); 564 565 cancel_work_sync(&pl->resolve); 566 kfree(pl); 567 } 568 EXPORT_SYMBOL_GPL(phylink_destroy); 569 570 static void phylink_phy_change(struct phy_device *phydev, bool up, 571 bool do_carrier) 572 { 573 struct phylink *pl = phydev->phylink; 574 575 mutex_lock(&pl->state_mutex); 576 pl->phy_state.speed = phydev->speed; 577 pl->phy_state.duplex = phydev->duplex; 578 pl->phy_state.pause = MLO_PAUSE_NONE; 579 if (phydev->pause) 580 pl->phy_state.pause |= MLO_PAUSE_SYM; 581 if (phydev->asym_pause) 582 pl->phy_state.pause |= MLO_PAUSE_ASYM; 583 pl->phy_state.interface = phydev->interface; 584 pl->phy_state.link = up; 585 mutex_unlock(&pl->state_mutex); 586 587 phylink_run_resolve(pl); 588 589 netdev_dbg(pl->netdev, "phy link %s %s/%s/%s\n", up ? "up" : "down", 590 phy_modes(phydev->interface), 591 phy_speed_to_str(phydev->speed), 592 phy_duplex_to_str(phydev->duplex)); 593 } 594 595 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy) 596 { 597 struct phylink_link_state config; 598 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 599 u32 advertising; 600 int ret; 601 602 memset(&config, 0, sizeof(config)); 603 ethtool_convert_legacy_u32_to_link_mode(supported, phy->supported); 604 ethtool_convert_legacy_u32_to_link_mode(config.advertising, 605 phy->advertising); 606 config.interface = pl->link_config.interface; 607 608 /* 609 * This is the new way of dealing with flow control for PHYs, 610 * as described by Timur Tabi in commit 529ed1275263 ("net: phy: 611 * phy drivers should not set SUPPORTED_[Asym_]Pause") except 612 * using our validate call to the MAC, we rely upon the MAC 613 * clearing the bits from both supported and advertising fields. 614 */ 615 if (phylink_test(supported, Pause)) 616 phylink_set(config.advertising, Pause); 617 if (phylink_test(supported, Asym_Pause)) 618 phylink_set(config.advertising, Asym_Pause); 619 620 ret = phylink_validate(pl, supported, &config); 621 if (ret) 622 return ret; 623 624 phy->phylink = pl; 625 phy->phy_link_change = phylink_phy_change; 626 627 netdev_info(pl->netdev, 628 "PHY [%s] driver [%s]\n", dev_name(&phy->mdio.dev), 629 phy->drv->name); 630 631 mutex_lock(&phy->lock); 632 mutex_lock(&pl->state_mutex); 633 pl->netdev->phydev = phy; 634 pl->phydev = phy; 635 linkmode_copy(pl->supported, supported); 636 linkmode_copy(pl->link_config.advertising, config.advertising); 637 638 /* Restrict the phy advertisment according to the MAC support. */ 639 ethtool_convert_link_mode_to_legacy_u32(&advertising, config.advertising); 640 phy->advertising = advertising; 641 mutex_unlock(&pl->state_mutex); 642 mutex_unlock(&phy->lock); 643 644 netdev_dbg(pl->netdev, 645 "phy: setting supported %*pb advertising 0x%08x\n", 646 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported, 647 phy->advertising); 648 649 phy_start_machine(phy); 650 if (phy->irq > 0) 651 phy_start_interrupts(phy); 652 653 return 0; 654 } 655 656 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy) 657 { 658 int ret; 659 660 ret = phy_attach_direct(pl->netdev, phy, 0, pl->link_interface); 661 if (ret) 662 return ret; 663 664 ret = phylink_bringup_phy(pl, phy); 665 if (ret) 666 phy_detach(phy); 667 668 return ret; 669 } 670 EXPORT_SYMBOL_GPL(phylink_connect_phy); 671 672 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn) 673 { 674 struct device_node *phy_node; 675 struct phy_device *phy_dev; 676 int ret; 677 678 /* Fixed links are handled without needing a PHY */ 679 if (pl->link_an_mode == MLO_AN_FIXED) 680 return 0; 681 682 phy_node = of_parse_phandle(dn, "phy-handle", 0); 683 if (!phy_node) 684 phy_node = of_parse_phandle(dn, "phy", 0); 685 if (!phy_node) 686 phy_node = of_parse_phandle(dn, "phy-device", 0); 687 688 if (!phy_node) { 689 if (pl->link_an_mode == MLO_AN_PHY) { 690 netdev_err(pl->netdev, "unable to find PHY node\n"); 691 return -ENODEV; 692 } 693 return 0; 694 } 695 696 phy_dev = of_phy_attach(pl->netdev, phy_node, 0, pl->link_interface); 697 /* We're done with the phy_node handle */ 698 of_node_put(phy_node); 699 700 if (!phy_dev) 701 return -ENODEV; 702 703 ret = phylink_bringup_phy(pl, phy_dev); 704 if (ret) 705 phy_detach(phy_dev); 706 707 return ret; 708 } 709 EXPORT_SYMBOL_GPL(phylink_of_phy_connect); 710 711 void phylink_disconnect_phy(struct phylink *pl) 712 { 713 struct phy_device *phy; 714 715 WARN_ON(!lockdep_rtnl_is_held()); 716 717 phy = pl->phydev; 718 if (phy) { 719 mutex_lock(&phy->lock); 720 mutex_lock(&pl->state_mutex); 721 pl->netdev->phydev = NULL; 722 pl->phydev = NULL; 723 mutex_unlock(&pl->state_mutex); 724 mutex_unlock(&phy->lock); 725 flush_work(&pl->resolve); 726 727 phy_disconnect(phy); 728 } 729 } 730 EXPORT_SYMBOL_GPL(phylink_disconnect_phy); 731 732 void phylink_mac_change(struct phylink *pl, bool up) 733 { 734 if (!up) 735 pl->mac_link_dropped = true; 736 phylink_run_resolve(pl); 737 netdev_dbg(pl->netdev, "mac link %s\n", up ? "up" : "down"); 738 } 739 EXPORT_SYMBOL_GPL(phylink_mac_change); 740 741 void phylink_start(struct phylink *pl) 742 { 743 WARN_ON(!lockdep_rtnl_is_held()); 744 745 netdev_info(pl->netdev, "configuring for %s/%s link mode\n", 746 phylink_an_mode_str(pl->link_an_mode), 747 phy_modes(pl->link_config.interface)); 748 749 /* Apply the link configuration to the MAC when starting. This allows 750 * a fixed-link to start with the correct parameters, and also 751 * ensures that we set the appropriate advertisment for Serdes links. 752 */ 753 phylink_resolve_flow(pl, &pl->link_config); 754 phylink_mac_config(pl, &pl->link_config); 755 756 clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 757 phylink_run_resolve(pl); 758 759 if (pl->sfp_bus) 760 sfp_upstream_start(pl->sfp_bus); 761 if (pl->phydev) 762 phy_start(pl->phydev); 763 } 764 EXPORT_SYMBOL_GPL(phylink_start); 765 766 void phylink_stop(struct phylink *pl) 767 { 768 WARN_ON(!lockdep_rtnl_is_held()); 769 770 if (pl->phydev) 771 phy_stop(pl->phydev); 772 if (pl->sfp_bus) 773 sfp_upstream_stop(pl->sfp_bus); 774 775 set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 776 queue_work(system_power_efficient_wq, &pl->resolve); 777 flush_work(&pl->resolve); 778 } 779 EXPORT_SYMBOL_GPL(phylink_stop); 780 781 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 782 { 783 WARN_ON(!lockdep_rtnl_is_held()); 784 785 wol->supported = 0; 786 wol->wolopts = 0; 787 788 if (pl->phydev) 789 phy_ethtool_get_wol(pl->phydev, wol); 790 } 791 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol); 792 793 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 794 { 795 int ret = -EOPNOTSUPP; 796 797 WARN_ON(!lockdep_rtnl_is_held()); 798 799 if (pl->phydev) 800 ret = phy_ethtool_set_wol(pl->phydev, wol); 801 802 return ret; 803 } 804 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol); 805 806 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b) 807 { 808 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask); 809 810 linkmode_zero(mask); 811 phylink_set_port_modes(mask); 812 813 linkmode_and(dst, dst, mask); 814 linkmode_or(dst, dst, b); 815 } 816 817 static void phylink_get_ksettings(const struct phylink_link_state *state, 818 struct ethtool_link_ksettings *kset) 819 { 820 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising); 821 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising); 822 kset->base.speed = state->speed; 823 kset->base.duplex = state->duplex; 824 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE : 825 AUTONEG_DISABLE; 826 } 827 828 int phylink_ethtool_ksettings_get(struct phylink *pl, 829 struct ethtool_link_ksettings *kset) 830 { 831 struct phylink_link_state link_state; 832 833 WARN_ON(!lockdep_rtnl_is_held()); 834 835 if (pl->phydev) { 836 phy_ethtool_ksettings_get(pl->phydev, kset); 837 } else { 838 kset->base.port = pl->link_port; 839 } 840 841 linkmode_copy(kset->link_modes.supported, pl->supported); 842 843 switch (pl->link_an_mode) { 844 case MLO_AN_FIXED: 845 /* We are using fixed settings. Report these as the 846 * current link settings - and note that these also 847 * represent the supported speeds/duplex/pause modes. 848 */ 849 phylink_get_fixed_state(pl, &link_state); 850 phylink_get_ksettings(&link_state, kset); 851 break; 852 853 case MLO_AN_SGMII: 854 /* If there is a phy attached, then use the reported 855 * settings from the phy with no modification. 856 */ 857 if (pl->phydev) 858 break; 859 860 case MLO_AN_8023Z: 861 phylink_get_mac_state(pl, &link_state); 862 863 /* The MAC is reporting the link results from its own PCS 864 * layer via in-band status. Report these as the current 865 * link settings. 866 */ 867 phylink_get_ksettings(&link_state, kset); 868 break; 869 } 870 871 return 0; 872 } 873 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get); 874 875 int phylink_ethtool_ksettings_set(struct phylink *pl, 876 const struct ethtool_link_ksettings *kset) 877 { 878 struct ethtool_link_ksettings our_kset; 879 struct phylink_link_state config; 880 int ret; 881 882 WARN_ON(!lockdep_rtnl_is_held()); 883 884 if (kset->base.autoneg != AUTONEG_DISABLE && 885 kset->base.autoneg != AUTONEG_ENABLE) 886 return -EINVAL; 887 888 config = pl->link_config; 889 890 /* Mask out unsupported advertisments */ 891 linkmode_and(config.advertising, kset->link_modes.advertising, 892 pl->supported); 893 894 /* FIXME: should we reject autoneg if phy/mac does not support it? */ 895 if (kset->base.autoneg == AUTONEG_DISABLE) { 896 const struct phy_setting *s; 897 898 /* Autonegotiation disabled, select a suitable speed and 899 * duplex. 900 */ 901 s = phy_lookup_setting(kset->base.speed, kset->base.duplex, 902 pl->supported, 903 __ETHTOOL_LINK_MODE_MASK_NBITS, false); 904 if (!s) 905 return -EINVAL; 906 907 /* If we have a fixed link (as specified by firmware), refuse 908 * to change link parameters. 909 */ 910 if (pl->link_an_mode == MLO_AN_FIXED && 911 (s->speed != pl->link_config.speed || 912 s->duplex != pl->link_config.duplex)) 913 return -EINVAL; 914 915 config.speed = s->speed; 916 config.duplex = s->duplex; 917 config.an_enabled = false; 918 919 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 920 } else { 921 /* If we have a fixed link, refuse to enable autonegotiation */ 922 if (pl->link_an_mode == MLO_AN_FIXED) 923 return -EINVAL; 924 925 config.speed = SPEED_UNKNOWN; 926 config.duplex = DUPLEX_UNKNOWN; 927 config.an_enabled = true; 928 929 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 930 } 931 932 if (phylink_validate(pl, pl->supported, &config)) 933 return -EINVAL; 934 935 /* If autonegotiation is enabled, we must have an advertisment */ 936 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising)) 937 return -EINVAL; 938 939 our_kset = *kset; 940 linkmode_copy(our_kset.link_modes.advertising, config.advertising); 941 our_kset.base.speed = config.speed; 942 our_kset.base.duplex = config.duplex; 943 944 /* If we have a PHY, configure the phy */ 945 if (pl->phydev) { 946 ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset); 947 if (ret) 948 return ret; 949 } 950 951 mutex_lock(&pl->state_mutex); 952 /* Configure the MAC to match the new settings */ 953 linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising); 954 pl->link_config.speed = our_kset.base.speed; 955 pl->link_config.duplex = our_kset.base.duplex; 956 pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE; 957 958 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 959 phylink_mac_config(pl, &pl->link_config); 960 phylink_mac_an_restart(pl); 961 } 962 mutex_unlock(&pl->state_mutex); 963 964 return 0; 965 } 966 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set); 967 968 int phylink_ethtool_nway_reset(struct phylink *pl) 969 { 970 int ret = 0; 971 972 WARN_ON(!lockdep_rtnl_is_held()); 973 974 if (pl->phydev) 975 ret = phy_restart_aneg(pl->phydev); 976 phylink_mac_an_restart(pl); 977 978 return ret; 979 } 980 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset); 981 982 void phylink_ethtool_get_pauseparam(struct phylink *pl, 983 struct ethtool_pauseparam *pause) 984 { 985 WARN_ON(!lockdep_rtnl_is_held()); 986 987 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN); 988 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX); 989 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX); 990 } 991 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam); 992 993 int phylink_ethtool_set_pauseparam(struct phylink *pl, 994 struct ethtool_pauseparam *pause) 995 { 996 struct phylink_link_state *config = &pl->link_config; 997 998 WARN_ON(!lockdep_rtnl_is_held()); 999 1000 if (!phylink_test(pl->supported, Pause) && 1001 !phylink_test(pl->supported, Asym_Pause)) 1002 return -EOPNOTSUPP; 1003 1004 if (!phylink_test(pl->supported, Asym_Pause) && 1005 !pause->autoneg && pause->rx_pause != pause->tx_pause) 1006 return -EINVAL; 1007 1008 config->pause &= ~(MLO_PAUSE_AN | MLO_PAUSE_TXRX_MASK); 1009 1010 if (pause->autoneg) 1011 config->pause |= MLO_PAUSE_AN; 1012 if (pause->rx_pause) 1013 config->pause |= MLO_PAUSE_RX; 1014 if (pause->tx_pause) 1015 config->pause |= MLO_PAUSE_TX; 1016 1017 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 1018 switch (pl->link_an_mode) { 1019 case MLO_AN_PHY: 1020 /* Silently mark the carrier down, and then trigger a resolve */ 1021 netif_carrier_off(pl->netdev); 1022 phylink_run_resolve(pl); 1023 break; 1024 1025 case MLO_AN_FIXED: 1026 /* Should we allow fixed links to change against the config? */ 1027 phylink_resolve_flow(pl, config); 1028 phylink_mac_config(pl, config); 1029 break; 1030 1031 case MLO_AN_SGMII: 1032 case MLO_AN_8023Z: 1033 phylink_mac_config(pl, config); 1034 phylink_mac_an_restart(pl); 1035 break; 1036 } 1037 } 1038 1039 return 0; 1040 } 1041 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam); 1042 1043 int phylink_ethtool_get_module_info(struct phylink *pl, 1044 struct ethtool_modinfo *modinfo) 1045 { 1046 int ret = -EOPNOTSUPP; 1047 1048 WARN_ON(!lockdep_rtnl_is_held()); 1049 1050 if (pl->sfp_bus) 1051 ret = sfp_get_module_info(pl->sfp_bus, modinfo); 1052 1053 return ret; 1054 } 1055 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_info); 1056 1057 int phylink_ethtool_get_module_eeprom(struct phylink *pl, 1058 struct ethtool_eeprom *ee, u8 *buf) 1059 { 1060 int ret = -EOPNOTSUPP; 1061 1062 WARN_ON(!lockdep_rtnl_is_held()); 1063 1064 if (pl->sfp_bus) 1065 ret = sfp_get_module_eeprom(pl->sfp_bus, ee, buf); 1066 1067 return ret; 1068 } 1069 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_eeprom); 1070 1071 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable) 1072 { 1073 int ret = -EPROTONOSUPPORT; 1074 1075 WARN_ON(!lockdep_rtnl_is_held()); 1076 1077 if (pl->phydev) 1078 ret = phy_init_eee(pl->phydev, clk_stop_enable); 1079 1080 return ret; 1081 } 1082 EXPORT_SYMBOL_GPL(phylink_init_eee); 1083 1084 int phylink_get_eee_err(struct phylink *pl) 1085 { 1086 int ret = 0; 1087 1088 WARN_ON(!lockdep_rtnl_is_held()); 1089 1090 if (pl->phydev) 1091 ret = phy_get_eee_err(pl->phydev); 1092 1093 return ret; 1094 } 1095 EXPORT_SYMBOL_GPL(phylink_get_eee_err); 1096 1097 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee) 1098 { 1099 int ret = -EOPNOTSUPP; 1100 1101 WARN_ON(!lockdep_rtnl_is_held()); 1102 1103 if (pl->phydev) 1104 ret = phy_ethtool_get_eee(pl->phydev, eee); 1105 1106 return ret; 1107 } 1108 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee); 1109 1110 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee) 1111 { 1112 int ret = -EOPNOTSUPP; 1113 1114 WARN_ON(!lockdep_rtnl_is_held()); 1115 1116 if (pl->phydev) 1117 ret = phy_ethtool_set_eee(pl->phydev, eee); 1118 1119 return ret; 1120 } 1121 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee); 1122 1123 /* This emulates MII registers for a fixed-mode phy operating as per the 1124 * passed in state. "aneg" defines if we report negotiation is possible. 1125 * 1126 * FIXME: should deal with negotiation state too. 1127 */ 1128 static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg, 1129 struct phylink_link_state *state, bool aneg) 1130 { 1131 struct fixed_phy_status fs; 1132 int val; 1133 1134 fs.link = state->link; 1135 fs.speed = state->speed; 1136 fs.duplex = state->duplex; 1137 fs.pause = state->pause & MLO_PAUSE_SYM; 1138 fs.asym_pause = state->pause & MLO_PAUSE_ASYM; 1139 1140 val = swphy_read_reg(reg, &fs); 1141 if (reg == MII_BMSR) { 1142 if (!state->an_complete) 1143 val &= ~BMSR_ANEGCOMPLETE; 1144 if (!aneg) 1145 val &= ~BMSR_ANEGCAPABLE; 1146 } 1147 return val; 1148 } 1149 1150 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id, 1151 unsigned int reg) 1152 { 1153 struct phy_device *phydev = pl->phydev; 1154 int prtad, devad; 1155 1156 if (mdio_phy_id_is_c45(phy_id)) { 1157 prtad = mdio_phy_id_prtad(phy_id); 1158 devad = mdio_phy_id_devad(phy_id); 1159 devad = MII_ADDR_C45 | devad << 16 | reg; 1160 } else if (phydev->is_c45) { 1161 switch (reg) { 1162 case MII_BMCR: 1163 case MII_BMSR: 1164 case MII_PHYSID1: 1165 case MII_PHYSID2: 1166 devad = __ffs(phydev->c45_ids.devices_in_package); 1167 break; 1168 case MII_ADVERTISE: 1169 case MII_LPA: 1170 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1171 return -EINVAL; 1172 devad = MDIO_MMD_AN; 1173 if (reg == MII_ADVERTISE) 1174 reg = MDIO_AN_ADVERTISE; 1175 else 1176 reg = MDIO_AN_LPA; 1177 break; 1178 default: 1179 return -EINVAL; 1180 } 1181 prtad = phy_id; 1182 devad = MII_ADDR_C45 | devad << 16 | reg; 1183 } else { 1184 prtad = phy_id; 1185 devad = reg; 1186 } 1187 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad); 1188 } 1189 1190 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id, 1191 unsigned int reg, unsigned int val) 1192 { 1193 struct phy_device *phydev = pl->phydev; 1194 int prtad, devad; 1195 1196 if (mdio_phy_id_is_c45(phy_id)) { 1197 prtad = mdio_phy_id_prtad(phy_id); 1198 devad = mdio_phy_id_devad(phy_id); 1199 devad = MII_ADDR_C45 | devad << 16 | reg; 1200 } else if (phydev->is_c45) { 1201 switch (reg) { 1202 case MII_BMCR: 1203 case MII_BMSR: 1204 case MII_PHYSID1: 1205 case MII_PHYSID2: 1206 devad = __ffs(phydev->c45_ids.devices_in_package); 1207 break; 1208 case MII_ADVERTISE: 1209 case MII_LPA: 1210 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1211 return -EINVAL; 1212 devad = MDIO_MMD_AN; 1213 if (reg == MII_ADVERTISE) 1214 reg = MDIO_AN_ADVERTISE; 1215 else 1216 reg = MDIO_AN_LPA; 1217 break; 1218 default: 1219 return -EINVAL; 1220 } 1221 prtad = phy_id; 1222 devad = MII_ADDR_C45 | devad << 16 | reg; 1223 } else { 1224 prtad = phy_id; 1225 devad = reg; 1226 } 1227 1228 return mdiobus_write(phydev->mdio.bus, prtad, devad, val); 1229 } 1230 1231 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id, 1232 unsigned int reg) 1233 { 1234 struct phylink_link_state state; 1235 int val = 0xffff; 1236 1237 switch (pl->link_an_mode) { 1238 case MLO_AN_FIXED: 1239 if (phy_id == 0) { 1240 phylink_get_fixed_state(pl, &state); 1241 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1242 true); 1243 } 1244 break; 1245 1246 case MLO_AN_PHY: 1247 return -EOPNOTSUPP; 1248 1249 case MLO_AN_SGMII: 1250 /* No phy, fall through to 8023z method */ 1251 case MLO_AN_8023Z: 1252 if (phy_id == 0) { 1253 val = phylink_get_mac_state(pl, &state); 1254 if (val < 0) 1255 return val; 1256 1257 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1258 true); 1259 } 1260 break; 1261 } 1262 1263 return val & 0xffff; 1264 } 1265 1266 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id, 1267 unsigned int reg, unsigned int val) 1268 { 1269 switch (pl->link_an_mode) { 1270 case MLO_AN_FIXED: 1271 break; 1272 1273 case MLO_AN_PHY: 1274 return -EOPNOTSUPP; 1275 1276 case MLO_AN_SGMII: 1277 /* No phy, fall through to 8023z method */ 1278 case MLO_AN_8023Z: 1279 break; 1280 } 1281 1282 return 0; 1283 } 1284 1285 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd) 1286 { 1287 struct mii_ioctl_data *mii = if_mii(ifr); 1288 int ret; 1289 1290 WARN_ON(!lockdep_rtnl_is_held()); 1291 1292 if (pl->phydev) { 1293 /* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */ 1294 switch (cmd) { 1295 case SIOCGMIIPHY: 1296 mii->phy_id = pl->phydev->mdio.addr; 1297 1298 case SIOCGMIIREG: 1299 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num); 1300 if (ret >= 0) { 1301 mii->val_out = ret; 1302 ret = 0; 1303 } 1304 break; 1305 1306 case SIOCSMIIREG: 1307 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num, 1308 mii->val_in); 1309 break; 1310 1311 default: 1312 ret = phy_mii_ioctl(pl->phydev, ifr, cmd); 1313 break; 1314 } 1315 } else { 1316 switch (cmd) { 1317 case SIOCGMIIPHY: 1318 mii->phy_id = 0; 1319 1320 case SIOCGMIIREG: 1321 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num); 1322 if (ret >= 0) { 1323 mii->val_out = ret; 1324 ret = 0; 1325 } 1326 break; 1327 1328 case SIOCSMIIREG: 1329 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num, 1330 mii->val_in); 1331 break; 1332 1333 default: 1334 ret = -EOPNOTSUPP; 1335 break; 1336 } 1337 } 1338 1339 return ret; 1340 } 1341 EXPORT_SYMBOL_GPL(phylink_mii_ioctl); 1342 1343 static int phylink_sfp_module_insert(void *upstream, 1344 const struct sfp_eeprom_id *id) 1345 { 1346 struct phylink *pl = upstream; 1347 __ETHTOOL_DECLARE_LINK_MODE_MASK(support) = { 0, }; 1348 struct phylink_link_state config; 1349 phy_interface_t iface; 1350 int mode, ret = 0; 1351 bool changed; 1352 u8 port; 1353 1354 sfp_parse_support(pl->sfp_bus, id, support); 1355 port = sfp_parse_port(pl->sfp_bus, id, support); 1356 iface = sfp_parse_interface(pl->sfp_bus, id); 1357 1358 WARN_ON(!lockdep_rtnl_is_held()); 1359 1360 switch (iface) { 1361 case PHY_INTERFACE_MODE_SGMII: 1362 mode = MLO_AN_SGMII; 1363 break; 1364 case PHY_INTERFACE_MODE_1000BASEX: 1365 mode = MLO_AN_8023Z; 1366 break; 1367 default: 1368 return -EINVAL; 1369 } 1370 1371 memset(&config, 0, sizeof(config)); 1372 linkmode_copy(config.advertising, support); 1373 config.interface = iface; 1374 config.speed = SPEED_UNKNOWN; 1375 config.duplex = DUPLEX_UNKNOWN; 1376 config.pause = MLO_PAUSE_AN; 1377 config.an_enabled = pl->link_config.an_enabled; 1378 1379 /* Ignore errors if we're expecting a PHY to attach later */ 1380 ret = phylink_validate(pl, support, &config); 1381 if (ret) { 1382 netdev_err(pl->netdev, "validation of %s/%s with support %*pb failed: %d\n", 1383 phylink_an_mode_str(mode), phy_modes(config.interface), 1384 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret); 1385 return ret; 1386 } 1387 1388 netdev_dbg(pl->netdev, "requesting link mode %s/%s with support %*pb\n", 1389 phylink_an_mode_str(mode), phy_modes(config.interface), 1390 __ETHTOOL_LINK_MODE_MASK_NBITS, support); 1391 1392 if (mode == MLO_AN_8023Z && pl->phydev) 1393 return -EINVAL; 1394 1395 changed = !bitmap_equal(pl->supported, support, 1396 __ETHTOOL_LINK_MODE_MASK_NBITS); 1397 if (changed) { 1398 linkmode_copy(pl->supported, support); 1399 linkmode_copy(pl->link_config.advertising, config.advertising); 1400 } 1401 1402 if (pl->link_an_mode != mode || 1403 pl->link_config.interface != config.interface) { 1404 pl->link_config.interface = config.interface; 1405 pl->link_an_mode = mode; 1406 1407 changed = true; 1408 1409 netdev_info(pl->netdev, "switched to %s/%s link mode\n", 1410 phylink_an_mode_str(mode), 1411 phy_modes(config.interface)); 1412 } 1413 1414 pl->link_port = port; 1415 1416 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED, 1417 &pl->phylink_disable_state)) 1418 phylink_mac_config(pl, &pl->link_config); 1419 1420 return ret; 1421 } 1422 1423 static void phylink_sfp_link_down(void *upstream) 1424 { 1425 struct phylink *pl = upstream; 1426 1427 WARN_ON(!lockdep_rtnl_is_held()); 1428 1429 set_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state); 1430 flush_work(&pl->resolve); 1431 1432 netif_carrier_off(pl->netdev); 1433 } 1434 1435 static void phylink_sfp_link_up(void *upstream) 1436 { 1437 struct phylink *pl = upstream; 1438 1439 WARN_ON(!lockdep_rtnl_is_held()); 1440 1441 clear_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state); 1442 phylink_run_resolve(pl); 1443 } 1444 1445 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy) 1446 { 1447 return phylink_connect_phy(upstream, phy); 1448 } 1449 1450 static void phylink_sfp_disconnect_phy(void *upstream) 1451 { 1452 phylink_disconnect_phy(upstream); 1453 } 1454 1455 static const struct sfp_upstream_ops sfp_phylink_ops = { 1456 .module_insert = phylink_sfp_module_insert, 1457 .link_up = phylink_sfp_link_up, 1458 .link_down = phylink_sfp_link_down, 1459 .connect_phy = phylink_sfp_connect_phy, 1460 .disconnect_phy = phylink_sfp_disconnect_phy, 1461 }; 1462 1463 MODULE_LICENSE("GPL"); 1464