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 flush_work(&pl->resolve); 777 } 778 EXPORT_SYMBOL_GPL(phylink_stop); 779 780 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 781 { 782 WARN_ON(!lockdep_rtnl_is_held()); 783 784 wol->supported = 0; 785 wol->wolopts = 0; 786 787 if (pl->phydev) 788 phy_ethtool_get_wol(pl->phydev, wol); 789 } 790 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol); 791 792 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 793 { 794 int ret = -EOPNOTSUPP; 795 796 WARN_ON(!lockdep_rtnl_is_held()); 797 798 if (pl->phydev) 799 ret = phy_ethtool_set_wol(pl->phydev, wol); 800 801 return ret; 802 } 803 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol); 804 805 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b) 806 { 807 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask); 808 809 linkmode_zero(mask); 810 phylink_set_port_modes(mask); 811 812 linkmode_and(dst, dst, mask); 813 linkmode_or(dst, dst, b); 814 } 815 816 static void phylink_get_ksettings(const struct phylink_link_state *state, 817 struct ethtool_link_ksettings *kset) 818 { 819 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising); 820 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising); 821 kset->base.speed = state->speed; 822 kset->base.duplex = state->duplex; 823 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE : 824 AUTONEG_DISABLE; 825 } 826 827 int phylink_ethtool_ksettings_get(struct phylink *pl, 828 struct ethtool_link_ksettings *kset) 829 { 830 struct phylink_link_state link_state; 831 832 WARN_ON(!lockdep_rtnl_is_held()); 833 834 if (pl->phydev) { 835 phy_ethtool_ksettings_get(pl->phydev, kset); 836 } else { 837 kset->base.port = pl->link_port; 838 } 839 840 linkmode_copy(kset->link_modes.supported, pl->supported); 841 842 switch (pl->link_an_mode) { 843 case MLO_AN_FIXED: 844 /* We are using fixed settings. Report these as the 845 * current link settings - and note that these also 846 * represent the supported speeds/duplex/pause modes. 847 */ 848 phylink_get_fixed_state(pl, &link_state); 849 phylink_get_ksettings(&link_state, kset); 850 break; 851 852 case MLO_AN_SGMII: 853 /* If there is a phy attached, then use the reported 854 * settings from the phy with no modification. 855 */ 856 if (pl->phydev) 857 break; 858 859 case MLO_AN_8023Z: 860 phylink_get_mac_state(pl, &link_state); 861 862 /* The MAC is reporting the link results from its own PCS 863 * layer via in-band status. Report these as the current 864 * link settings. 865 */ 866 phylink_get_ksettings(&link_state, kset); 867 break; 868 } 869 870 return 0; 871 } 872 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get); 873 874 int phylink_ethtool_ksettings_set(struct phylink *pl, 875 const struct ethtool_link_ksettings *kset) 876 { 877 struct ethtool_link_ksettings our_kset; 878 struct phylink_link_state config; 879 int ret; 880 881 WARN_ON(!lockdep_rtnl_is_held()); 882 883 if (kset->base.autoneg != AUTONEG_DISABLE && 884 kset->base.autoneg != AUTONEG_ENABLE) 885 return -EINVAL; 886 887 config = pl->link_config; 888 889 /* Mask out unsupported advertisments */ 890 linkmode_and(config.advertising, kset->link_modes.advertising, 891 pl->supported); 892 893 /* FIXME: should we reject autoneg if phy/mac does not support it? */ 894 if (kset->base.autoneg == AUTONEG_DISABLE) { 895 const struct phy_setting *s; 896 897 /* Autonegotiation disabled, select a suitable speed and 898 * duplex. 899 */ 900 s = phy_lookup_setting(kset->base.speed, kset->base.duplex, 901 pl->supported, 902 __ETHTOOL_LINK_MODE_MASK_NBITS, false); 903 if (!s) 904 return -EINVAL; 905 906 /* If we have a fixed link (as specified by firmware), refuse 907 * to change link parameters. 908 */ 909 if (pl->link_an_mode == MLO_AN_FIXED && 910 (s->speed != pl->link_config.speed || 911 s->duplex != pl->link_config.duplex)) 912 return -EINVAL; 913 914 config.speed = s->speed; 915 config.duplex = s->duplex; 916 config.an_enabled = false; 917 918 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 919 } else { 920 /* If we have a fixed link, refuse to enable autonegotiation */ 921 if (pl->link_an_mode == MLO_AN_FIXED) 922 return -EINVAL; 923 924 config.speed = SPEED_UNKNOWN; 925 config.duplex = DUPLEX_UNKNOWN; 926 config.an_enabled = true; 927 928 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 929 } 930 931 if (phylink_validate(pl, pl->supported, &config)) 932 return -EINVAL; 933 934 /* If autonegotiation is enabled, we must have an advertisment */ 935 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising)) 936 return -EINVAL; 937 938 our_kset = *kset; 939 linkmode_copy(our_kset.link_modes.advertising, config.advertising); 940 our_kset.base.speed = config.speed; 941 our_kset.base.duplex = config.duplex; 942 943 /* If we have a PHY, configure the phy */ 944 if (pl->phydev) { 945 ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset); 946 if (ret) 947 return ret; 948 } 949 950 mutex_lock(&pl->state_mutex); 951 /* Configure the MAC to match the new settings */ 952 linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising); 953 pl->link_config.speed = our_kset.base.speed; 954 pl->link_config.duplex = our_kset.base.duplex; 955 pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE; 956 957 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 958 phylink_mac_config(pl, &pl->link_config); 959 phylink_mac_an_restart(pl); 960 } 961 mutex_unlock(&pl->state_mutex); 962 963 return 0; 964 } 965 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set); 966 967 int phylink_ethtool_nway_reset(struct phylink *pl) 968 { 969 int ret = 0; 970 971 WARN_ON(!lockdep_rtnl_is_held()); 972 973 if (pl->phydev) 974 ret = phy_restart_aneg(pl->phydev); 975 phylink_mac_an_restart(pl); 976 977 return ret; 978 } 979 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset); 980 981 void phylink_ethtool_get_pauseparam(struct phylink *pl, 982 struct ethtool_pauseparam *pause) 983 { 984 WARN_ON(!lockdep_rtnl_is_held()); 985 986 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN); 987 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX); 988 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX); 989 } 990 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam); 991 992 int phylink_ethtool_set_pauseparam(struct phylink *pl, 993 struct ethtool_pauseparam *pause) 994 { 995 struct phylink_link_state *config = &pl->link_config; 996 997 WARN_ON(!lockdep_rtnl_is_held()); 998 999 if (!phylink_test(pl->supported, Pause) && 1000 !phylink_test(pl->supported, Asym_Pause)) 1001 return -EOPNOTSUPP; 1002 1003 if (!phylink_test(pl->supported, Asym_Pause) && 1004 !pause->autoneg && pause->rx_pause != pause->tx_pause) 1005 return -EINVAL; 1006 1007 config->pause &= ~(MLO_PAUSE_AN | MLO_PAUSE_TXRX_MASK); 1008 1009 if (pause->autoneg) 1010 config->pause |= MLO_PAUSE_AN; 1011 if (pause->rx_pause) 1012 config->pause |= MLO_PAUSE_RX; 1013 if (pause->tx_pause) 1014 config->pause |= MLO_PAUSE_TX; 1015 1016 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 1017 switch (pl->link_an_mode) { 1018 case MLO_AN_PHY: 1019 /* Silently mark the carrier down, and then trigger a resolve */ 1020 netif_carrier_off(pl->netdev); 1021 phylink_run_resolve(pl); 1022 break; 1023 1024 case MLO_AN_FIXED: 1025 /* Should we allow fixed links to change against the config? */ 1026 phylink_resolve_flow(pl, config); 1027 phylink_mac_config(pl, config); 1028 break; 1029 1030 case MLO_AN_SGMII: 1031 case MLO_AN_8023Z: 1032 phylink_mac_config(pl, config); 1033 phylink_mac_an_restart(pl); 1034 break; 1035 } 1036 } 1037 1038 return 0; 1039 } 1040 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam); 1041 1042 int phylink_ethtool_get_module_info(struct phylink *pl, 1043 struct ethtool_modinfo *modinfo) 1044 { 1045 int ret = -EOPNOTSUPP; 1046 1047 WARN_ON(!lockdep_rtnl_is_held()); 1048 1049 if (pl->sfp_bus) 1050 ret = sfp_get_module_info(pl->sfp_bus, modinfo); 1051 1052 return ret; 1053 } 1054 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_info); 1055 1056 int phylink_ethtool_get_module_eeprom(struct phylink *pl, 1057 struct ethtool_eeprom *ee, u8 *buf) 1058 { 1059 int ret = -EOPNOTSUPP; 1060 1061 WARN_ON(!lockdep_rtnl_is_held()); 1062 1063 if (pl->sfp_bus) 1064 ret = sfp_get_module_eeprom(pl->sfp_bus, ee, buf); 1065 1066 return ret; 1067 } 1068 EXPORT_SYMBOL_GPL(phylink_ethtool_get_module_eeprom); 1069 1070 int phylink_init_eee(struct phylink *pl, bool clk_stop_enable) 1071 { 1072 int ret = -EPROTONOSUPPORT; 1073 1074 WARN_ON(!lockdep_rtnl_is_held()); 1075 1076 if (pl->phydev) 1077 ret = phy_init_eee(pl->phydev, clk_stop_enable); 1078 1079 return ret; 1080 } 1081 EXPORT_SYMBOL_GPL(phylink_init_eee); 1082 1083 int phylink_get_eee_err(struct phylink *pl) 1084 { 1085 int ret = 0; 1086 1087 WARN_ON(!lockdep_rtnl_is_held()); 1088 1089 if (pl->phydev) 1090 ret = phy_get_eee_err(pl->phydev); 1091 1092 return ret; 1093 } 1094 EXPORT_SYMBOL_GPL(phylink_get_eee_err); 1095 1096 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee) 1097 { 1098 int ret = -EOPNOTSUPP; 1099 1100 WARN_ON(!lockdep_rtnl_is_held()); 1101 1102 if (pl->phydev) 1103 ret = phy_ethtool_get_eee(pl->phydev, eee); 1104 1105 return ret; 1106 } 1107 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee); 1108 1109 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee) 1110 { 1111 int ret = -EOPNOTSUPP; 1112 1113 WARN_ON(!lockdep_rtnl_is_held()); 1114 1115 if (pl->phydev) 1116 ret = phy_ethtool_set_eee(pl->phydev, eee); 1117 1118 return ret; 1119 } 1120 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee); 1121 1122 /* This emulates MII registers for a fixed-mode phy operating as per the 1123 * passed in state. "aneg" defines if we report negotiation is possible. 1124 * 1125 * FIXME: should deal with negotiation state too. 1126 */ 1127 static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg, 1128 struct phylink_link_state *state, bool aneg) 1129 { 1130 struct fixed_phy_status fs; 1131 int val; 1132 1133 fs.link = state->link; 1134 fs.speed = state->speed; 1135 fs.duplex = state->duplex; 1136 fs.pause = state->pause & MLO_PAUSE_SYM; 1137 fs.asym_pause = state->pause & MLO_PAUSE_ASYM; 1138 1139 val = swphy_read_reg(reg, &fs); 1140 if (reg == MII_BMSR) { 1141 if (!state->an_complete) 1142 val &= ~BMSR_ANEGCOMPLETE; 1143 if (!aneg) 1144 val &= ~BMSR_ANEGCAPABLE; 1145 } 1146 return val; 1147 } 1148 1149 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id, 1150 unsigned int reg) 1151 { 1152 struct phy_device *phydev = pl->phydev; 1153 int prtad, devad; 1154 1155 if (mdio_phy_id_is_c45(phy_id)) { 1156 prtad = mdio_phy_id_prtad(phy_id); 1157 devad = mdio_phy_id_devad(phy_id); 1158 devad = MII_ADDR_C45 | devad << 16 | reg; 1159 } else if (phydev->is_c45) { 1160 switch (reg) { 1161 case MII_BMCR: 1162 case MII_BMSR: 1163 case MII_PHYSID1: 1164 case MII_PHYSID2: 1165 devad = __ffs(phydev->c45_ids.devices_in_package); 1166 break; 1167 case MII_ADVERTISE: 1168 case MII_LPA: 1169 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1170 return -EINVAL; 1171 devad = MDIO_MMD_AN; 1172 if (reg == MII_ADVERTISE) 1173 reg = MDIO_AN_ADVERTISE; 1174 else 1175 reg = MDIO_AN_LPA; 1176 break; 1177 default: 1178 return -EINVAL; 1179 } 1180 prtad = phy_id; 1181 devad = MII_ADDR_C45 | devad << 16 | reg; 1182 } else { 1183 prtad = phy_id; 1184 devad = reg; 1185 } 1186 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad); 1187 } 1188 1189 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id, 1190 unsigned int reg, unsigned int val) 1191 { 1192 struct phy_device *phydev = pl->phydev; 1193 int prtad, devad; 1194 1195 if (mdio_phy_id_is_c45(phy_id)) { 1196 prtad = mdio_phy_id_prtad(phy_id); 1197 devad = mdio_phy_id_devad(phy_id); 1198 devad = MII_ADDR_C45 | devad << 16 | reg; 1199 } else if (phydev->is_c45) { 1200 switch (reg) { 1201 case MII_BMCR: 1202 case MII_BMSR: 1203 case MII_PHYSID1: 1204 case MII_PHYSID2: 1205 devad = __ffs(phydev->c45_ids.devices_in_package); 1206 break; 1207 case MII_ADVERTISE: 1208 case MII_LPA: 1209 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1210 return -EINVAL; 1211 devad = MDIO_MMD_AN; 1212 if (reg == MII_ADVERTISE) 1213 reg = MDIO_AN_ADVERTISE; 1214 else 1215 reg = MDIO_AN_LPA; 1216 break; 1217 default: 1218 return -EINVAL; 1219 } 1220 prtad = phy_id; 1221 devad = MII_ADDR_C45 | devad << 16 | reg; 1222 } else { 1223 prtad = phy_id; 1224 devad = reg; 1225 } 1226 1227 return mdiobus_write(phydev->mdio.bus, prtad, devad, val); 1228 } 1229 1230 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id, 1231 unsigned int reg) 1232 { 1233 struct phylink_link_state state; 1234 int val = 0xffff; 1235 1236 switch (pl->link_an_mode) { 1237 case MLO_AN_FIXED: 1238 if (phy_id == 0) { 1239 phylink_get_fixed_state(pl, &state); 1240 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1241 true); 1242 } 1243 break; 1244 1245 case MLO_AN_PHY: 1246 return -EOPNOTSUPP; 1247 1248 case MLO_AN_SGMII: 1249 /* No phy, fall through to 8023z method */ 1250 case MLO_AN_8023Z: 1251 if (phy_id == 0) { 1252 val = phylink_get_mac_state(pl, &state); 1253 if (val < 0) 1254 return val; 1255 1256 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1257 true); 1258 } 1259 break; 1260 } 1261 1262 return val & 0xffff; 1263 } 1264 1265 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id, 1266 unsigned int reg, unsigned int val) 1267 { 1268 switch (pl->link_an_mode) { 1269 case MLO_AN_FIXED: 1270 break; 1271 1272 case MLO_AN_PHY: 1273 return -EOPNOTSUPP; 1274 1275 case MLO_AN_SGMII: 1276 /* No phy, fall through to 8023z method */ 1277 case MLO_AN_8023Z: 1278 break; 1279 } 1280 1281 return 0; 1282 } 1283 1284 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd) 1285 { 1286 struct mii_ioctl_data *mii = if_mii(ifr); 1287 int ret; 1288 1289 WARN_ON(!lockdep_rtnl_is_held()); 1290 1291 if (pl->phydev) { 1292 /* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */ 1293 switch (cmd) { 1294 case SIOCGMIIPHY: 1295 mii->phy_id = pl->phydev->mdio.addr; 1296 1297 case SIOCGMIIREG: 1298 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num); 1299 if (ret >= 0) { 1300 mii->val_out = ret; 1301 ret = 0; 1302 } 1303 break; 1304 1305 case SIOCSMIIREG: 1306 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num, 1307 mii->val_in); 1308 break; 1309 1310 default: 1311 ret = phy_mii_ioctl(pl->phydev, ifr, cmd); 1312 break; 1313 } 1314 } else { 1315 switch (cmd) { 1316 case SIOCGMIIPHY: 1317 mii->phy_id = 0; 1318 1319 case SIOCGMIIREG: 1320 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num); 1321 if (ret >= 0) { 1322 mii->val_out = ret; 1323 ret = 0; 1324 } 1325 break; 1326 1327 case SIOCSMIIREG: 1328 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num, 1329 mii->val_in); 1330 break; 1331 1332 default: 1333 ret = -EOPNOTSUPP; 1334 break; 1335 } 1336 } 1337 1338 return ret; 1339 } 1340 EXPORT_SYMBOL_GPL(phylink_mii_ioctl); 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