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/timer.h> 23 #include <linux/workqueue.h> 24 25 #include "sfp.h" 26 #include "swphy.h" 27 28 #define SUPPORTED_INTERFACES \ 29 (SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \ 30 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane) 31 #define ADVERTISED_INTERFACES \ 32 (ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \ 33 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane) 34 35 enum { 36 PHYLINK_DISABLE_STOPPED, 37 PHYLINK_DISABLE_LINK, 38 }; 39 40 /** 41 * struct phylink - internal data type for phylink 42 */ 43 struct phylink { 44 /* private: */ 45 struct net_device *netdev; 46 const struct phylink_mac_ops *ops; 47 48 unsigned long phylink_disable_state; /* bitmask of disables */ 49 struct phy_device *phydev; 50 phy_interface_t link_interface; /* PHY_INTERFACE_xxx */ 51 u8 link_an_mode; /* MLO_AN_xxx */ 52 u8 link_port; /* The current non-phy ethtool port */ 53 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 54 55 /* The link configuration settings */ 56 struct phylink_link_state link_config; 57 struct gpio_desc *link_gpio; 58 struct timer_list link_poll; 59 void (*get_fixed_state)(struct net_device *dev, 60 struct phylink_link_state *s); 61 62 struct mutex state_mutex; 63 struct phylink_link_state phy_state; 64 struct work_struct resolve; 65 66 bool mac_link_dropped; 67 68 struct sfp_bus *sfp_bus; 69 }; 70 71 /** 72 * phylink_set_port_modes() - set the port type modes in the ethtool mask 73 * @mask: ethtool link mode mask 74 * 75 * Sets all the port type modes in the ethtool mask. MAC drivers should 76 * use this in their 'validate' callback. 77 */ 78 void phylink_set_port_modes(unsigned long *mask) 79 { 80 phylink_set(mask, TP); 81 phylink_set(mask, AUI); 82 phylink_set(mask, MII); 83 phylink_set(mask, FIBRE); 84 phylink_set(mask, BNC); 85 phylink_set(mask, Backplane); 86 } 87 EXPORT_SYMBOL_GPL(phylink_set_port_modes); 88 89 static int phylink_is_empty_linkmode(const unsigned long *linkmode) 90 { 91 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, }; 92 93 phylink_set_port_modes(tmp); 94 phylink_set(tmp, Autoneg); 95 phylink_set(tmp, Pause); 96 phylink_set(tmp, Asym_Pause); 97 98 bitmap_andnot(tmp, linkmode, tmp, __ETHTOOL_LINK_MODE_MASK_NBITS); 99 100 return linkmode_empty(tmp); 101 } 102 103 static const char *phylink_an_mode_str(unsigned int mode) 104 { 105 static const char *modestr[] = { 106 [MLO_AN_PHY] = "phy", 107 [MLO_AN_FIXED] = "fixed", 108 [MLO_AN_INBAND] = "inband", 109 }; 110 111 return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown"; 112 } 113 114 static int phylink_validate(struct phylink *pl, unsigned long *supported, 115 struct phylink_link_state *state) 116 { 117 pl->ops->validate(pl->netdev, supported, state); 118 119 return phylink_is_empty_linkmode(supported) ? -EINVAL : 0; 120 } 121 122 static int phylink_parse_fixedlink(struct phylink *pl, 123 struct fwnode_handle *fwnode) 124 { 125 struct fwnode_handle *fixed_node; 126 const struct phy_setting *s; 127 struct gpio_desc *desc; 128 u32 speed; 129 int ret; 130 131 fixed_node = fwnode_get_named_child_node(fwnode, "fixed-link"); 132 if (fixed_node) { 133 ret = fwnode_property_read_u32(fixed_node, "speed", &speed); 134 135 pl->link_config.speed = speed; 136 pl->link_config.duplex = DUPLEX_HALF; 137 138 if (fwnode_property_read_bool(fixed_node, "full-duplex")) 139 pl->link_config.duplex = DUPLEX_FULL; 140 141 /* We treat the "pause" and "asym-pause" terminology as 142 * defining the link partner's ability. */ 143 if (fwnode_property_read_bool(fixed_node, "pause")) 144 pl->link_config.pause |= MLO_PAUSE_SYM; 145 if (fwnode_property_read_bool(fixed_node, "asym-pause")) 146 pl->link_config.pause |= MLO_PAUSE_ASYM; 147 148 if (ret == 0) { 149 desc = fwnode_get_named_gpiod(fixed_node, "link-gpios", 150 0, GPIOD_IN, "?"); 151 152 if (!IS_ERR(desc)) 153 pl->link_gpio = desc; 154 else if (desc == ERR_PTR(-EPROBE_DEFER)) 155 ret = -EPROBE_DEFER; 156 } 157 fwnode_handle_put(fixed_node); 158 159 if (ret) 160 return ret; 161 } else { 162 u32 prop[5]; 163 164 ret = fwnode_property_read_u32_array(fwnode, "fixed-link", 165 NULL, 0); 166 if (ret != ARRAY_SIZE(prop)) { 167 netdev_err(pl->netdev, "broken fixed-link?\n"); 168 return -EINVAL; 169 } 170 171 ret = fwnode_property_read_u32_array(fwnode, "fixed-link", 172 prop, ARRAY_SIZE(prop)); 173 if (!ret) { 174 pl->link_config.duplex = prop[1] ? 175 DUPLEX_FULL : DUPLEX_HALF; 176 pl->link_config.speed = prop[2]; 177 if (prop[3]) 178 pl->link_config.pause |= MLO_PAUSE_SYM; 179 if (prop[4]) 180 pl->link_config.pause |= MLO_PAUSE_ASYM; 181 } 182 } 183 184 if (pl->link_config.speed > SPEED_1000 && 185 pl->link_config.duplex != DUPLEX_FULL) 186 netdev_warn(pl->netdev, "fixed link specifies half duplex for %dMbps link?\n", 187 pl->link_config.speed); 188 189 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS); 190 linkmode_copy(pl->link_config.advertising, pl->supported); 191 phylink_validate(pl, pl->supported, &pl->link_config); 192 193 s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex, 194 pl->supported, true); 195 linkmode_zero(pl->supported); 196 phylink_set(pl->supported, MII); 197 if (s) { 198 __set_bit(s->bit, pl->supported); 199 } else { 200 netdev_warn(pl->netdev, "fixed link %s duplex %dMbps not recognised\n", 201 pl->link_config.duplex == DUPLEX_FULL ? "full" : "half", 202 pl->link_config.speed); 203 } 204 205 linkmode_and(pl->link_config.advertising, pl->link_config.advertising, 206 pl->supported); 207 208 pl->link_config.link = 1; 209 pl->link_config.an_complete = 1; 210 211 return 0; 212 } 213 214 static int phylink_parse_mode(struct phylink *pl, struct fwnode_handle *fwnode) 215 { 216 struct fwnode_handle *dn; 217 const char *managed; 218 219 dn = fwnode_get_named_child_node(fwnode, "fixed-link"); 220 if (dn || fwnode_property_present(fwnode, "fixed-link")) 221 pl->link_an_mode = MLO_AN_FIXED; 222 fwnode_handle_put(dn); 223 224 if (fwnode_property_read_string(fwnode, "managed", &managed) == 0 && 225 strcmp(managed, "in-band-status") == 0) { 226 if (pl->link_an_mode == MLO_AN_FIXED) { 227 netdev_err(pl->netdev, 228 "can't use both fixed-link and in-band-status\n"); 229 return -EINVAL; 230 } 231 232 linkmode_zero(pl->supported); 233 phylink_set(pl->supported, MII); 234 phylink_set(pl->supported, Autoneg); 235 phylink_set(pl->supported, Asym_Pause); 236 phylink_set(pl->supported, Pause); 237 pl->link_config.an_enabled = true; 238 pl->link_an_mode = MLO_AN_INBAND; 239 240 switch (pl->link_config.interface) { 241 case PHY_INTERFACE_MODE_SGMII: 242 phylink_set(pl->supported, 10baseT_Half); 243 phylink_set(pl->supported, 10baseT_Full); 244 phylink_set(pl->supported, 100baseT_Half); 245 phylink_set(pl->supported, 100baseT_Full); 246 phylink_set(pl->supported, 1000baseT_Half); 247 phylink_set(pl->supported, 1000baseT_Full); 248 break; 249 250 case PHY_INTERFACE_MODE_1000BASEX: 251 phylink_set(pl->supported, 1000baseX_Full); 252 break; 253 254 case PHY_INTERFACE_MODE_2500BASEX: 255 phylink_set(pl->supported, 2500baseX_Full); 256 break; 257 258 case PHY_INTERFACE_MODE_10GKR: 259 phylink_set(pl->supported, 10baseT_Half); 260 phylink_set(pl->supported, 10baseT_Full); 261 phylink_set(pl->supported, 100baseT_Half); 262 phylink_set(pl->supported, 100baseT_Full); 263 phylink_set(pl->supported, 1000baseT_Half); 264 phylink_set(pl->supported, 1000baseT_Full); 265 phylink_set(pl->supported, 1000baseX_Full); 266 phylink_set(pl->supported, 10000baseKR_Full); 267 phylink_set(pl->supported, 10000baseCR_Full); 268 phylink_set(pl->supported, 10000baseSR_Full); 269 phylink_set(pl->supported, 10000baseLR_Full); 270 phylink_set(pl->supported, 10000baseLRM_Full); 271 phylink_set(pl->supported, 10000baseER_Full); 272 break; 273 274 default: 275 netdev_err(pl->netdev, 276 "incorrect link mode %s for in-band status\n", 277 phy_modes(pl->link_config.interface)); 278 return -EINVAL; 279 } 280 281 linkmode_copy(pl->link_config.advertising, pl->supported); 282 283 if (phylink_validate(pl, pl->supported, &pl->link_config)) { 284 netdev_err(pl->netdev, 285 "failed to validate link configuration for in-band status\n"); 286 return -EINVAL; 287 } 288 } 289 290 return 0; 291 } 292 293 static void phylink_mac_config(struct phylink *pl, 294 const struct phylink_link_state *state) 295 { 296 netdev_dbg(pl->netdev, 297 "%s: mode=%s/%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n", 298 __func__, phylink_an_mode_str(pl->link_an_mode), 299 phy_modes(state->interface), 300 phy_speed_to_str(state->speed), 301 phy_duplex_to_str(state->duplex), 302 __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising, 303 state->pause, state->link, state->an_enabled); 304 305 pl->ops->mac_config(pl->netdev, pl->link_an_mode, state); 306 } 307 308 static void phylink_mac_an_restart(struct phylink *pl) 309 { 310 if (pl->link_config.an_enabled && 311 phy_interface_mode_is_8023z(pl->link_config.interface)) 312 pl->ops->mac_an_restart(pl->netdev); 313 } 314 315 static int phylink_get_mac_state(struct phylink *pl, struct phylink_link_state *state) 316 { 317 struct net_device *ndev = pl->netdev; 318 319 linkmode_copy(state->advertising, pl->link_config.advertising); 320 linkmode_zero(state->lp_advertising); 321 state->interface = pl->link_config.interface; 322 state->an_enabled = pl->link_config.an_enabled; 323 state->link = 1; 324 325 return pl->ops->mac_link_state(ndev, state); 326 } 327 328 /* The fixed state is... fixed except for the link state, 329 * which may be determined by a GPIO or a callback. 330 */ 331 static void phylink_get_fixed_state(struct phylink *pl, struct phylink_link_state *state) 332 { 333 *state = pl->link_config; 334 if (pl->get_fixed_state) 335 pl->get_fixed_state(pl->netdev, state); 336 else if (pl->link_gpio) 337 state->link = !!gpiod_get_value_cansleep(pl->link_gpio); 338 } 339 340 /* Flow control is resolved according to our and the link partners 341 * advertisements using the following drawn from the 802.3 specs: 342 * Local device Link partner 343 * Pause AsymDir Pause AsymDir Result 344 * 1 X 1 X TX+RX 345 * 0 1 1 1 RX 346 * 1 1 0 1 TX 347 */ 348 static void phylink_resolve_flow(struct phylink *pl, 349 struct phylink_link_state *state) 350 { 351 int new_pause = 0; 352 353 if (pl->link_config.pause & MLO_PAUSE_AN) { 354 int pause = 0; 355 356 if (phylink_test(pl->link_config.advertising, Pause)) 357 pause |= MLO_PAUSE_SYM; 358 if (phylink_test(pl->link_config.advertising, Asym_Pause)) 359 pause |= MLO_PAUSE_ASYM; 360 361 pause &= state->pause; 362 363 if (pause & MLO_PAUSE_SYM) 364 new_pause = MLO_PAUSE_TX | MLO_PAUSE_RX; 365 else if (pause & MLO_PAUSE_ASYM) 366 new_pause = state->pause & MLO_PAUSE_SYM ? 367 MLO_PAUSE_RX : MLO_PAUSE_TX; 368 } else { 369 new_pause = pl->link_config.pause & MLO_PAUSE_TXRX_MASK; 370 } 371 372 state->pause &= ~MLO_PAUSE_TXRX_MASK; 373 state->pause |= new_pause; 374 } 375 376 static const char *phylink_pause_to_str(int pause) 377 { 378 switch (pause & MLO_PAUSE_TXRX_MASK) { 379 case MLO_PAUSE_TX | MLO_PAUSE_RX: 380 return "rx/tx"; 381 case MLO_PAUSE_TX: 382 return "tx"; 383 case MLO_PAUSE_RX: 384 return "rx"; 385 default: 386 return "off"; 387 } 388 } 389 390 static void phylink_resolve(struct work_struct *w) 391 { 392 struct phylink *pl = container_of(w, struct phylink, resolve); 393 struct phylink_link_state link_state; 394 struct net_device *ndev = pl->netdev; 395 396 mutex_lock(&pl->state_mutex); 397 if (pl->phylink_disable_state) { 398 pl->mac_link_dropped = false; 399 link_state.link = false; 400 } else if (pl->mac_link_dropped) { 401 link_state.link = false; 402 } else { 403 switch (pl->link_an_mode) { 404 case MLO_AN_PHY: 405 link_state = pl->phy_state; 406 phylink_resolve_flow(pl, &link_state); 407 phylink_mac_config(pl, &link_state); 408 break; 409 410 case MLO_AN_FIXED: 411 phylink_get_fixed_state(pl, &link_state); 412 phylink_mac_config(pl, &link_state); 413 break; 414 415 case MLO_AN_INBAND: 416 phylink_get_mac_state(pl, &link_state); 417 if (pl->phydev) { 418 bool changed = false; 419 420 link_state.link = link_state.link && 421 pl->phy_state.link; 422 423 if (pl->phy_state.interface != 424 link_state.interface) { 425 link_state.interface = pl->phy_state.interface; 426 changed = true; 427 } 428 429 /* Propagate the flow control from the PHY 430 * to the MAC. Also propagate the interface 431 * if changed. 432 */ 433 if (pl->phy_state.link || changed) { 434 link_state.pause |= pl->phy_state.pause; 435 phylink_resolve_flow(pl, &link_state); 436 437 phylink_mac_config(pl, &link_state); 438 } 439 } 440 break; 441 } 442 } 443 444 if (link_state.link != netif_carrier_ok(ndev)) { 445 if (!link_state.link) { 446 netif_carrier_off(ndev); 447 pl->ops->mac_link_down(ndev, pl->link_an_mode, 448 pl->phy_state.interface); 449 netdev_info(ndev, "Link is Down\n"); 450 } else { 451 pl->ops->mac_link_up(ndev, pl->link_an_mode, 452 pl->phy_state.interface, 453 pl->phydev); 454 455 netif_carrier_on(ndev); 456 457 netdev_info(ndev, 458 "Link is Up - %s/%s - flow control %s\n", 459 phy_speed_to_str(link_state.speed), 460 phy_duplex_to_str(link_state.duplex), 461 phylink_pause_to_str(link_state.pause)); 462 } 463 } 464 if (!link_state.link && pl->mac_link_dropped) { 465 pl->mac_link_dropped = false; 466 queue_work(system_power_efficient_wq, &pl->resolve); 467 } 468 mutex_unlock(&pl->state_mutex); 469 } 470 471 static void phylink_run_resolve(struct phylink *pl) 472 { 473 if (!pl->phylink_disable_state) 474 queue_work(system_power_efficient_wq, &pl->resolve); 475 } 476 477 static void phylink_run_resolve_and_disable(struct phylink *pl, int bit) 478 { 479 unsigned long state = pl->phylink_disable_state; 480 481 set_bit(bit, &pl->phylink_disable_state); 482 if (state == 0) { 483 queue_work(system_power_efficient_wq, &pl->resolve); 484 flush_work(&pl->resolve); 485 } 486 } 487 488 static void phylink_fixed_poll(struct timer_list *t) 489 { 490 struct phylink *pl = container_of(t, struct phylink, link_poll); 491 492 mod_timer(t, jiffies + HZ); 493 494 phylink_run_resolve(pl); 495 } 496 497 static const struct sfp_upstream_ops sfp_phylink_ops; 498 499 static int phylink_register_sfp(struct phylink *pl, 500 struct fwnode_handle *fwnode) 501 { 502 struct fwnode_reference_args ref; 503 int ret; 504 505 if (!fwnode) 506 return 0; 507 508 ret = fwnode_property_get_reference_args(fwnode, "sfp", NULL, 509 0, 0, &ref); 510 if (ret < 0) { 511 if (ret == -ENOENT) 512 return 0; 513 514 netdev_err(pl->netdev, "unable to parse \"sfp\" node: %d\n", 515 ret); 516 return ret; 517 } 518 519 pl->sfp_bus = sfp_register_upstream(ref.fwnode, pl->netdev, pl, 520 &sfp_phylink_ops); 521 if (!pl->sfp_bus) 522 return -ENOMEM; 523 524 return 0; 525 } 526 527 /** 528 * phylink_create() - create a phylink instance 529 * @ndev: a pointer to the &struct net_device 530 * @fwnode: a pointer to a &struct fwnode_handle describing the network 531 * interface 532 * @iface: the desired link mode defined by &typedef phy_interface_t 533 * @ops: a pointer to a &struct phylink_mac_ops for the MAC. 534 * 535 * Create a new phylink instance, and parse the link parameters found in @np. 536 * This will parse in-band modes, fixed-link or SFP configuration. 537 * 538 * Returns a pointer to a &struct phylink, or an error-pointer value. Users 539 * must use IS_ERR() to check for errors from this function. 540 */ 541 struct phylink *phylink_create(struct net_device *ndev, 542 struct fwnode_handle *fwnode, 543 phy_interface_t iface, 544 const struct phylink_mac_ops *ops) 545 { 546 struct phylink *pl; 547 int ret; 548 549 pl = kzalloc(sizeof(*pl), GFP_KERNEL); 550 if (!pl) 551 return ERR_PTR(-ENOMEM); 552 553 mutex_init(&pl->state_mutex); 554 INIT_WORK(&pl->resolve, phylink_resolve); 555 pl->netdev = ndev; 556 pl->phy_state.interface = iface; 557 pl->link_interface = iface; 558 if (iface == PHY_INTERFACE_MODE_MOCA) 559 pl->link_port = PORT_BNC; 560 else 561 pl->link_port = PORT_MII; 562 pl->link_config.interface = iface; 563 pl->link_config.pause = MLO_PAUSE_AN; 564 pl->link_config.speed = SPEED_UNKNOWN; 565 pl->link_config.duplex = DUPLEX_UNKNOWN; 566 pl->link_config.an_enabled = true; 567 pl->ops = ops; 568 __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 569 timer_setup(&pl->link_poll, phylink_fixed_poll, 0); 570 571 bitmap_fill(pl->supported, __ETHTOOL_LINK_MODE_MASK_NBITS); 572 linkmode_copy(pl->link_config.advertising, pl->supported); 573 phylink_validate(pl, pl->supported, &pl->link_config); 574 575 ret = phylink_parse_mode(pl, fwnode); 576 if (ret < 0) { 577 kfree(pl); 578 return ERR_PTR(ret); 579 } 580 581 if (pl->link_an_mode == MLO_AN_FIXED) { 582 ret = phylink_parse_fixedlink(pl, fwnode); 583 if (ret < 0) { 584 kfree(pl); 585 return ERR_PTR(ret); 586 } 587 } 588 589 ret = phylink_register_sfp(pl, fwnode); 590 if (ret < 0) { 591 kfree(pl); 592 return ERR_PTR(ret); 593 } 594 595 return pl; 596 } 597 EXPORT_SYMBOL_GPL(phylink_create); 598 599 /** 600 * phylink_destroy() - cleanup and destroy the phylink instance 601 * @pl: a pointer to a &struct phylink returned from phylink_create() 602 * 603 * Destroy a phylink instance. Any PHY that has been attached must have been 604 * cleaned up via phylink_disconnect_phy() prior to calling this function. 605 */ 606 void phylink_destroy(struct phylink *pl) 607 { 608 if (pl->sfp_bus) 609 sfp_unregister_upstream(pl->sfp_bus); 610 if (!IS_ERR_OR_NULL(pl->link_gpio)) 611 gpiod_put(pl->link_gpio); 612 613 cancel_work_sync(&pl->resolve); 614 kfree(pl); 615 } 616 EXPORT_SYMBOL_GPL(phylink_destroy); 617 618 static void phylink_phy_change(struct phy_device *phydev, bool up, 619 bool do_carrier) 620 { 621 struct phylink *pl = phydev->phylink; 622 623 mutex_lock(&pl->state_mutex); 624 pl->phy_state.speed = phydev->speed; 625 pl->phy_state.duplex = phydev->duplex; 626 pl->phy_state.pause = MLO_PAUSE_NONE; 627 if (phydev->pause) 628 pl->phy_state.pause |= MLO_PAUSE_SYM; 629 if (phydev->asym_pause) 630 pl->phy_state.pause |= MLO_PAUSE_ASYM; 631 pl->phy_state.interface = phydev->interface; 632 pl->phy_state.link = up; 633 mutex_unlock(&pl->state_mutex); 634 635 phylink_run_resolve(pl); 636 637 netdev_dbg(pl->netdev, "phy link %s %s/%s/%s\n", up ? "up" : "down", 638 phy_modes(phydev->interface), 639 phy_speed_to_str(phydev->speed), 640 phy_duplex_to_str(phydev->duplex)); 641 } 642 643 static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy) 644 { 645 struct phylink_link_state config; 646 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported); 647 int ret; 648 649 memset(&config, 0, sizeof(config)); 650 linkmode_copy(supported, phy->supported); 651 linkmode_copy(config.advertising, phy->advertising); 652 config.interface = pl->link_config.interface; 653 654 /* 655 * This is the new way of dealing with flow control for PHYs, 656 * as described by Timur Tabi in commit 529ed1275263 ("net: phy: 657 * phy drivers should not set SUPPORTED_[Asym_]Pause") except 658 * using our validate call to the MAC, we rely upon the MAC 659 * clearing the bits from both supported and advertising fields. 660 */ 661 if (phylink_test(supported, Pause)) 662 phylink_set(config.advertising, Pause); 663 if (phylink_test(supported, Asym_Pause)) 664 phylink_set(config.advertising, Asym_Pause); 665 666 ret = phylink_validate(pl, supported, &config); 667 if (ret) 668 return ret; 669 670 phy->phylink = pl; 671 phy->phy_link_change = phylink_phy_change; 672 673 netdev_info(pl->netdev, 674 "PHY [%s] driver [%s]\n", dev_name(&phy->mdio.dev), 675 phy->drv->name); 676 677 mutex_lock(&phy->lock); 678 mutex_lock(&pl->state_mutex); 679 pl->phydev = phy; 680 linkmode_copy(pl->supported, supported); 681 linkmode_copy(pl->link_config.advertising, config.advertising); 682 683 /* Restrict the phy advertisement according to the MAC support. */ 684 linkmode_copy(phy->advertising, config.advertising); 685 mutex_unlock(&pl->state_mutex); 686 mutex_unlock(&phy->lock); 687 688 netdev_dbg(pl->netdev, 689 "phy: setting supported %*pb advertising %*pb\n", 690 __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported, 691 __ETHTOOL_LINK_MODE_MASK_NBITS, phy->advertising); 692 693 phy_start_machine(phy); 694 if (phy->irq > 0) 695 phy_start_interrupts(phy); 696 697 return 0; 698 } 699 700 static int __phylink_connect_phy(struct phylink *pl, struct phy_device *phy, 701 phy_interface_t interface) 702 { 703 int ret; 704 705 if (WARN_ON(pl->link_an_mode == MLO_AN_FIXED || 706 (pl->link_an_mode == MLO_AN_INBAND && 707 phy_interface_mode_is_8023z(interface)))) 708 return -EINVAL; 709 710 if (pl->phydev) 711 return -EBUSY; 712 713 ret = phy_attach_direct(pl->netdev, phy, 0, interface); 714 if (ret) 715 return ret; 716 717 ret = phylink_bringup_phy(pl, phy); 718 if (ret) 719 phy_detach(phy); 720 721 return ret; 722 } 723 724 /** 725 * phylink_connect_phy() - connect a PHY to the phylink instance 726 * @pl: a pointer to a &struct phylink returned from phylink_create() 727 * @phy: a pointer to a &struct phy_device. 728 * 729 * Connect @phy to the phylink instance specified by @pl by calling 730 * phy_attach_direct(). Configure the @phy according to the MAC driver's 731 * capabilities, start the PHYLIB state machine and enable any interrupts 732 * that the PHY supports. 733 * 734 * This updates the phylink's ethtool supported and advertising link mode 735 * masks. 736 * 737 * Returns 0 on success or a negative errno. 738 */ 739 int phylink_connect_phy(struct phylink *pl, struct phy_device *phy) 740 { 741 /* Use PHY device/driver interface */ 742 if (pl->link_interface == PHY_INTERFACE_MODE_NA) { 743 pl->link_interface = phy->interface; 744 pl->link_config.interface = pl->link_interface; 745 } 746 747 return __phylink_connect_phy(pl, phy, pl->link_interface); 748 } 749 EXPORT_SYMBOL_GPL(phylink_connect_phy); 750 751 /** 752 * phylink_of_phy_connect() - connect the PHY specified in the DT mode. 753 * @pl: a pointer to a &struct phylink returned from phylink_create() 754 * @dn: a pointer to a &struct device_node. 755 * @flags: PHY-specific flags to communicate to the PHY device driver 756 * 757 * Connect the phy specified in the device node @dn to the phylink instance 758 * specified by @pl. Actions specified in phylink_connect_phy() will be 759 * performed. 760 * 761 * Returns 0 on success or a negative errno. 762 */ 763 int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn, 764 u32 flags) 765 { 766 struct device_node *phy_node; 767 struct phy_device *phy_dev; 768 int ret; 769 770 /* Fixed links and 802.3z are handled without needing a PHY */ 771 if (pl->link_an_mode == MLO_AN_FIXED || 772 (pl->link_an_mode == MLO_AN_INBAND && 773 phy_interface_mode_is_8023z(pl->link_interface))) 774 return 0; 775 776 phy_node = of_parse_phandle(dn, "phy-handle", 0); 777 if (!phy_node) 778 phy_node = of_parse_phandle(dn, "phy", 0); 779 if (!phy_node) 780 phy_node = of_parse_phandle(dn, "phy-device", 0); 781 782 if (!phy_node) { 783 if (pl->link_an_mode == MLO_AN_PHY) 784 return -ENODEV; 785 return 0; 786 } 787 788 phy_dev = of_phy_attach(pl->netdev, phy_node, flags, 789 pl->link_interface); 790 /* We're done with the phy_node handle */ 791 of_node_put(phy_node); 792 793 if (!phy_dev) 794 return -ENODEV; 795 796 ret = phylink_bringup_phy(pl, phy_dev); 797 if (ret) 798 phy_detach(phy_dev); 799 800 return ret; 801 } 802 EXPORT_SYMBOL_GPL(phylink_of_phy_connect); 803 804 /** 805 * phylink_disconnect_phy() - disconnect any PHY attached to the phylink 806 * instance. 807 * @pl: a pointer to a &struct phylink returned from phylink_create() 808 * 809 * Disconnect any current PHY from the phylink instance described by @pl. 810 */ 811 void phylink_disconnect_phy(struct phylink *pl) 812 { 813 struct phy_device *phy; 814 815 ASSERT_RTNL(); 816 817 phy = pl->phydev; 818 if (phy) { 819 mutex_lock(&phy->lock); 820 mutex_lock(&pl->state_mutex); 821 pl->phydev = NULL; 822 mutex_unlock(&pl->state_mutex); 823 mutex_unlock(&phy->lock); 824 flush_work(&pl->resolve); 825 826 phy_disconnect(phy); 827 } 828 } 829 EXPORT_SYMBOL_GPL(phylink_disconnect_phy); 830 831 /** 832 * phylink_fixed_state_cb() - allow setting a fixed link callback 833 * @pl: a pointer to a &struct phylink returned from phylink_create() 834 * @cb: callback to execute to determine the fixed link state. 835 * 836 * The MAC driver should call this driver when the state of its link 837 * can be determined through e.g: an out of band MMIO register. 838 */ 839 int phylink_fixed_state_cb(struct phylink *pl, 840 void (*cb)(struct net_device *dev, 841 struct phylink_link_state *state)) 842 { 843 /* It does not make sense to let the link be overriden unless we use 844 * MLO_AN_FIXED 845 */ 846 if (pl->link_an_mode != MLO_AN_FIXED) 847 return -EINVAL; 848 849 mutex_lock(&pl->state_mutex); 850 pl->get_fixed_state = cb; 851 mutex_unlock(&pl->state_mutex); 852 853 return 0; 854 } 855 EXPORT_SYMBOL_GPL(phylink_fixed_state_cb); 856 857 /** 858 * phylink_mac_change() - notify phylink of a change in MAC state 859 * @pl: a pointer to a &struct phylink returned from phylink_create() 860 * @up: indicates whether the link is currently up. 861 * 862 * The MAC driver should call this driver when the state of its link 863 * changes (eg, link failure, new negotiation results, etc.) 864 */ 865 void phylink_mac_change(struct phylink *pl, bool up) 866 { 867 if (!up) 868 pl->mac_link_dropped = true; 869 phylink_run_resolve(pl); 870 netdev_dbg(pl->netdev, "mac link %s\n", up ? "up" : "down"); 871 } 872 EXPORT_SYMBOL_GPL(phylink_mac_change); 873 874 /** 875 * phylink_start() - start a phylink instance 876 * @pl: a pointer to a &struct phylink returned from phylink_create() 877 * 878 * Start the phylink instance specified by @pl, configuring the MAC for the 879 * desired link mode(s) and negotiation style. This should be called from the 880 * network device driver's &struct net_device_ops ndo_open() method. 881 */ 882 void phylink_start(struct phylink *pl) 883 { 884 ASSERT_RTNL(); 885 886 netdev_info(pl->netdev, "configuring for %s/%s link mode\n", 887 phylink_an_mode_str(pl->link_an_mode), 888 phy_modes(pl->link_config.interface)); 889 890 /* Always set the carrier off */ 891 netif_carrier_off(pl->netdev); 892 893 /* Apply the link configuration to the MAC when starting. This allows 894 * a fixed-link to start with the correct parameters, and also 895 * ensures that we set the appropriate advertisement for Serdes links. 896 */ 897 phylink_resolve_flow(pl, &pl->link_config); 898 phylink_mac_config(pl, &pl->link_config); 899 900 /* Restart autonegotiation if using 802.3z to ensure that the link 901 * parameters are properly negotiated. This is necessary for DSA 902 * switches using 802.3z negotiation to ensure they see our modes. 903 */ 904 phylink_mac_an_restart(pl); 905 906 clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state); 907 phylink_run_resolve(pl); 908 909 if (pl->link_an_mode == MLO_AN_FIXED && !IS_ERR(pl->link_gpio)) 910 mod_timer(&pl->link_poll, jiffies + HZ); 911 if (pl->sfp_bus) 912 sfp_upstream_start(pl->sfp_bus); 913 if (pl->phydev) 914 phy_start(pl->phydev); 915 } 916 EXPORT_SYMBOL_GPL(phylink_start); 917 918 /** 919 * phylink_stop() - stop a phylink instance 920 * @pl: a pointer to a &struct phylink returned from phylink_create() 921 * 922 * Stop the phylink instance specified by @pl. This should be called from the 923 * network device driver's &struct net_device_ops ndo_stop() method. The 924 * network device's carrier state should not be changed prior to calling this 925 * function. 926 */ 927 void phylink_stop(struct phylink *pl) 928 { 929 ASSERT_RTNL(); 930 931 if (pl->phydev) 932 phy_stop(pl->phydev); 933 if (pl->sfp_bus) 934 sfp_upstream_stop(pl->sfp_bus); 935 if (pl->link_an_mode == MLO_AN_FIXED && !IS_ERR(pl->link_gpio)) 936 del_timer_sync(&pl->link_poll); 937 938 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_STOPPED); 939 } 940 EXPORT_SYMBOL_GPL(phylink_stop); 941 942 /** 943 * phylink_ethtool_get_wol() - get the wake on lan parameters for the PHY 944 * @pl: a pointer to a &struct phylink returned from phylink_create() 945 * @wol: a pointer to &struct ethtool_wolinfo to hold the read parameters 946 * 947 * Read the wake on lan parameters from the PHY attached to the phylink 948 * instance specified by @pl. If no PHY is currently attached, report no 949 * support for wake on lan. 950 */ 951 void phylink_ethtool_get_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 952 { 953 ASSERT_RTNL(); 954 955 wol->supported = 0; 956 wol->wolopts = 0; 957 958 if (pl->phydev) 959 phy_ethtool_get_wol(pl->phydev, wol); 960 } 961 EXPORT_SYMBOL_GPL(phylink_ethtool_get_wol); 962 963 /** 964 * phylink_ethtool_set_wol() - set wake on lan parameters 965 * @pl: a pointer to a &struct phylink returned from phylink_create() 966 * @wol: a pointer to &struct ethtool_wolinfo for the desired parameters 967 * 968 * Set the wake on lan parameters for the PHY attached to the phylink 969 * instance specified by @pl. If no PHY is attached, returns %EOPNOTSUPP 970 * error. 971 * 972 * Returns zero on success or negative errno code. 973 */ 974 int phylink_ethtool_set_wol(struct phylink *pl, struct ethtool_wolinfo *wol) 975 { 976 int ret = -EOPNOTSUPP; 977 978 ASSERT_RTNL(); 979 980 if (pl->phydev) 981 ret = phy_ethtool_set_wol(pl->phydev, wol); 982 983 return ret; 984 } 985 EXPORT_SYMBOL_GPL(phylink_ethtool_set_wol); 986 987 static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b) 988 { 989 __ETHTOOL_DECLARE_LINK_MODE_MASK(mask); 990 991 linkmode_zero(mask); 992 phylink_set_port_modes(mask); 993 994 linkmode_and(dst, dst, mask); 995 linkmode_or(dst, dst, b); 996 } 997 998 static void phylink_get_ksettings(const struct phylink_link_state *state, 999 struct ethtool_link_ksettings *kset) 1000 { 1001 phylink_merge_link_mode(kset->link_modes.advertising, state->advertising); 1002 linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising); 1003 kset->base.speed = state->speed; 1004 kset->base.duplex = state->duplex; 1005 kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE : 1006 AUTONEG_DISABLE; 1007 } 1008 1009 /** 1010 * phylink_ethtool_ksettings_get() - get the current link settings 1011 * @pl: a pointer to a &struct phylink returned from phylink_create() 1012 * @kset: a pointer to a &struct ethtool_link_ksettings to hold link settings 1013 * 1014 * Read the current link settings for the phylink instance specified by @pl. 1015 * This will be the link settings read from the MAC, PHY or fixed link 1016 * settings depending on the current negotiation mode. 1017 */ 1018 int phylink_ethtool_ksettings_get(struct phylink *pl, 1019 struct ethtool_link_ksettings *kset) 1020 { 1021 struct phylink_link_state link_state; 1022 1023 ASSERT_RTNL(); 1024 1025 if (pl->phydev) { 1026 phy_ethtool_ksettings_get(pl->phydev, kset); 1027 } else { 1028 kset->base.port = pl->link_port; 1029 } 1030 1031 linkmode_copy(kset->link_modes.supported, pl->supported); 1032 1033 switch (pl->link_an_mode) { 1034 case MLO_AN_FIXED: 1035 /* We are using fixed settings. Report these as the 1036 * current link settings - and note that these also 1037 * represent the supported speeds/duplex/pause modes. 1038 */ 1039 phylink_get_fixed_state(pl, &link_state); 1040 phylink_get_ksettings(&link_state, kset); 1041 break; 1042 1043 case MLO_AN_INBAND: 1044 /* If there is a phy attached, then use the reported 1045 * settings from the phy with no modification. 1046 */ 1047 if (pl->phydev) 1048 break; 1049 1050 phylink_get_mac_state(pl, &link_state); 1051 1052 /* The MAC is reporting the link results from its own PCS 1053 * layer via in-band status. Report these as the current 1054 * link settings. 1055 */ 1056 phylink_get_ksettings(&link_state, kset); 1057 break; 1058 } 1059 1060 return 0; 1061 } 1062 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get); 1063 1064 /** 1065 * phylink_ethtool_ksettings_set() - set the link settings 1066 * @pl: a pointer to a &struct phylink returned from phylink_create() 1067 * @kset: a pointer to a &struct ethtool_link_ksettings for the desired modes 1068 */ 1069 int phylink_ethtool_ksettings_set(struct phylink *pl, 1070 const struct ethtool_link_ksettings *kset) 1071 { 1072 struct ethtool_link_ksettings our_kset; 1073 struct phylink_link_state config; 1074 int ret; 1075 1076 ASSERT_RTNL(); 1077 1078 if (kset->base.autoneg != AUTONEG_DISABLE && 1079 kset->base.autoneg != AUTONEG_ENABLE) 1080 return -EINVAL; 1081 1082 config = pl->link_config; 1083 1084 /* Mask out unsupported advertisements */ 1085 linkmode_and(config.advertising, kset->link_modes.advertising, 1086 pl->supported); 1087 1088 /* FIXME: should we reject autoneg if phy/mac does not support it? */ 1089 if (kset->base.autoneg == AUTONEG_DISABLE) { 1090 const struct phy_setting *s; 1091 1092 /* Autonegotiation disabled, select a suitable speed and 1093 * duplex. 1094 */ 1095 s = phy_lookup_setting(kset->base.speed, kset->base.duplex, 1096 pl->supported, false); 1097 if (!s) 1098 return -EINVAL; 1099 1100 /* If we have a fixed link (as specified by firmware), refuse 1101 * to change link parameters. 1102 */ 1103 if (pl->link_an_mode == MLO_AN_FIXED && 1104 (s->speed != pl->link_config.speed || 1105 s->duplex != pl->link_config.duplex)) 1106 return -EINVAL; 1107 1108 config.speed = s->speed; 1109 config.duplex = s->duplex; 1110 config.an_enabled = false; 1111 1112 __clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 1113 } else { 1114 /* If we have a fixed link, refuse to enable autonegotiation */ 1115 if (pl->link_an_mode == MLO_AN_FIXED) 1116 return -EINVAL; 1117 1118 config.speed = SPEED_UNKNOWN; 1119 config.duplex = DUPLEX_UNKNOWN; 1120 config.an_enabled = true; 1121 1122 __set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, config.advertising); 1123 } 1124 1125 if (phylink_validate(pl, pl->supported, &config)) 1126 return -EINVAL; 1127 1128 /* If autonegotiation is enabled, we must have an advertisement */ 1129 if (config.an_enabled && phylink_is_empty_linkmode(config.advertising)) 1130 return -EINVAL; 1131 1132 our_kset = *kset; 1133 linkmode_copy(our_kset.link_modes.advertising, config.advertising); 1134 our_kset.base.speed = config.speed; 1135 our_kset.base.duplex = config.duplex; 1136 1137 /* If we have a PHY, configure the phy */ 1138 if (pl->phydev) { 1139 ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset); 1140 if (ret) 1141 return ret; 1142 } 1143 1144 mutex_lock(&pl->state_mutex); 1145 /* Configure the MAC to match the new settings */ 1146 linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising); 1147 pl->link_config.interface = config.interface; 1148 pl->link_config.speed = our_kset.base.speed; 1149 pl->link_config.duplex = our_kset.base.duplex; 1150 pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE; 1151 1152 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 1153 phylink_mac_config(pl, &pl->link_config); 1154 phylink_mac_an_restart(pl); 1155 } 1156 mutex_unlock(&pl->state_mutex); 1157 1158 return 0; 1159 } 1160 EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set); 1161 1162 /** 1163 * phylink_ethtool_nway_reset() - restart negotiation 1164 * @pl: a pointer to a &struct phylink returned from phylink_create() 1165 * 1166 * Restart negotiation for the phylink instance specified by @pl. This will 1167 * cause any attached phy to restart negotiation with the link partner, and 1168 * if the MAC is in a BaseX mode, the MAC will also be requested to restart 1169 * negotiation. 1170 * 1171 * Returns zero on success, or negative error code. 1172 */ 1173 int phylink_ethtool_nway_reset(struct phylink *pl) 1174 { 1175 int ret = 0; 1176 1177 ASSERT_RTNL(); 1178 1179 if (pl->phydev) 1180 ret = phy_restart_aneg(pl->phydev); 1181 phylink_mac_an_restart(pl); 1182 1183 return ret; 1184 } 1185 EXPORT_SYMBOL_GPL(phylink_ethtool_nway_reset); 1186 1187 /** 1188 * phylink_ethtool_get_pauseparam() - get the current pause parameters 1189 * @pl: a pointer to a &struct phylink returned from phylink_create() 1190 * @pause: a pointer to a &struct ethtool_pauseparam 1191 */ 1192 void phylink_ethtool_get_pauseparam(struct phylink *pl, 1193 struct ethtool_pauseparam *pause) 1194 { 1195 ASSERT_RTNL(); 1196 1197 pause->autoneg = !!(pl->link_config.pause & MLO_PAUSE_AN); 1198 pause->rx_pause = !!(pl->link_config.pause & MLO_PAUSE_RX); 1199 pause->tx_pause = !!(pl->link_config.pause & MLO_PAUSE_TX); 1200 } 1201 EXPORT_SYMBOL_GPL(phylink_ethtool_get_pauseparam); 1202 1203 /** 1204 * phylink_ethtool_set_pauseparam() - set the current pause parameters 1205 * @pl: a pointer to a &struct phylink returned from phylink_create() 1206 * @pause: a pointer to a &struct ethtool_pauseparam 1207 */ 1208 int phylink_ethtool_set_pauseparam(struct phylink *pl, 1209 struct ethtool_pauseparam *pause) 1210 { 1211 struct phylink_link_state *config = &pl->link_config; 1212 1213 ASSERT_RTNL(); 1214 1215 if (!phylink_test(pl->supported, Pause) && 1216 !phylink_test(pl->supported, Asym_Pause)) 1217 return -EOPNOTSUPP; 1218 1219 if (!phylink_test(pl->supported, Asym_Pause) && 1220 !pause->autoneg && pause->rx_pause != pause->tx_pause) 1221 return -EINVAL; 1222 1223 config->pause &= ~(MLO_PAUSE_AN | MLO_PAUSE_TXRX_MASK); 1224 1225 if (pause->autoneg) 1226 config->pause |= MLO_PAUSE_AN; 1227 if (pause->rx_pause) 1228 config->pause |= MLO_PAUSE_RX; 1229 if (pause->tx_pause) 1230 config->pause |= MLO_PAUSE_TX; 1231 1232 if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) { 1233 switch (pl->link_an_mode) { 1234 case MLO_AN_PHY: 1235 /* Silently mark the carrier down, and then trigger a resolve */ 1236 netif_carrier_off(pl->netdev); 1237 phylink_run_resolve(pl); 1238 break; 1239 1240 case MLO_AN_FIXED: 1241 /* Should we allow fixed links to change against the config? */ 1242 phylink_resolve_flow(pl, config); 1243 phylink_mac_config(pl, config); 1244 break; 1245 1246 case MLO_AN_INBAND: 1247 phylink_mac_config(pl, config); 1248 phylink_mac_an_restart(pl); 1249 break; 1250 } 1251 } 1252 1253 return 0; 1254 } 1255 EXPORT_SYMBOL_GPL(phylink_ethtool_set_pauseparam); 1256 1257 /** 1258 * phylink_ethtool_get_eee_err() - read the energy efficient ethernet error 1259 * counter 1260 * @pl: a pointer to a &struct phylink returned from phylink_create(). 1261 * 1262 * Read the Energy Efficient Ethernet error counter from the PHY associated 1263 * with the phylink instance specified by @pl. 1264 * 1265 * Returns positive error counter value, or negative error code. 1266 */ 1267 int phylink_get_eee_err(struct phylink *pl) 1268 { 1269 int ret = 0; 1270 1271 ASSERT_RTNL(); 1272 1273 if (pl->phydev) 1274 ret = phy_get_eee_err(pl->phydev); 1275 1276 return ret; 1277 } 1278 EXPORT_SYMBOL_GPL(phylink_get_eee_err); 1279 1280 /** 1281 * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters 1282 * @pl: a pointer to a &struct phylink returned from phylink_create() 1283 * @eee: a pointer to a &struct ethtool_eee for the read parameters 1284 */ 1285 int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee) 1286 { 1287 int ret = -EOPNOTSUPP; 1288 1289 ASSERT_RTNL(); 1290 1291 if (pl->phydev) 1292 ret = phy_ethtool_get_eee(pl->phydev, eee); 1293 1294 return ret; 1295 } 1296 EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee); 1297 1298 /** 1299 * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters 1300 * @pl: a pointer to a &struct phylink returned from phylink_create() 1301 * @eee: a pointer to a &struct ethtool_eee for the desired parameters 1302 */ 1303 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee) 1304 { 1305 int ret = -EOPNOTSUPP; 1306 1307 ASSERT_RTNL(); 1308 1309 if (pl->phydev) 1310 ret = phy_ethtool_set_eee(pl->phydev, eee); 1311 1312 return ret; 1313 } 1314 EXPORT_SYMBOL_GPL(phylink_ethtool_set_eee); 1315 1316 /* This emulates MII registers for a fixed-mode phy operating as per the 1317 * passed in state. "aneg" defines if we report negotiation is possible. 1318 * 1319 * FIXME: should deal with negotiation state too. 1320 */ 1321 static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg, 1322 struct phylink_link_state *state, bool aneg) 1323 { 1324 struct fixed_phy_status fs; 1325 int val; 1326 1327 fs.link = state->link; 1328 fs.speed = state->speed; 1329 fs.duplex = state->duplex; 1330 fs.pause = state->pause & MLO_PAUSE_SYM; 1331 fs.asym_pause = state->pause & MLO_PAUSE_ASYM; 1332 1333 val = swphy_read_reg(reg, &fs); 1334 if (reg == MII_BMSR) { 1335 if (!state->an_complete) 1336 val &= ~BMSR_ANEGCOMPLETE; 1337 if (!aneg) 1338 val &= ~BMSR_ANEGCAPABLE; 1339 } 1340 return val; 1341 } 1342 1343 static int phylink_phy_read(struct phylink *pl, unsigned int phy_id, 1344 unsigned int reg) 1345 { 1346 struct phy_device *phydev = pl->phydev; 1347 int prtad, devad; 1348 1349 if (mdio_phy_id_is_c45(phy_id)) { 1350 prtad = mdio_phy_id_prtad(phy_id); 1351 devad = mdio_phy_id_devad(phy_id); 1352 devad = MII_ADDR_C45 | devad << 16 | reg; 1353 } else if (phydev->is_c45) { 1354 switch (reg) { 1355 case MII_BMCR: 1356 case MII_BMSR: 1357 case MII_PHYSID1: 1358 case MII_PHYSID2: 1359 devad = __ffs(phydev->c45_ids.devices_in_package); 1360 break; 1361 case MII_ADVERTISE: 1362 case MII_LPA: 1363 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1364 return -EINVAL; 1365 devad = MDIO_MMD_AN; 1366 if (reg == MII_ADVERTISE) 1367 reg = MDIO_AN_ADVERTISE; 1368 else 1369 reg = MDIO_AN_LPA; 1370 break; 1371 default: 1372 return -EINVAL; 1373 } 1374 prtad = phy_id; 1375 devad = MII_ADDR_C45 | devad << 16 | reg; 1376 } else { 1377 prtad = phy_id; 1378 devad = reg; 1379 } 1380 return mdiobus_read(pl->phydev->mdio.bus, prtad, devad); 1381 } 1382 1383 static int phylink_phy_write(struct phylink *pl, unsigned int phy_id, 1384 unsigned int reg, unsigned int val) 1385 { 1386 struct phy_device *phydev = pl->phydev; 1387 int prtad, devad; 1388 1389 if (mdio_phy_id_is_c45(phy_id)) { 1390 prtad = mdio_phy_id_prtad(phy_id); 1391 devad = mdio_phy_id_devad(phy_id); 1392 devad = MII_ADDR_C45 | devad << 16 | reg; 1393 } else if (phydev->is_c45) { 1394 switch (reg) { 1395 case MII_BMCR: 1396 case MII_BMSR: 1397 case MII_PHYSID1: 1398 case MII_PHYSID2: 1399 devad = __ffs(phydev->c45_ids.devices_in_package); 1400 break; 1401 case MII_ADVERTISE: 1402 case MII_LPA: 1403 if (!(phydev->c45_ids.devices_in_package & MDIO_DEVS_AN)) 1404 return -EINVAL; 1405 devad = MDIO_MMD_AN; 1406 if (reg == MII_ADVERTISE) 1407 reg = MDIO_AN_ADVERTISE; 1408 else 1409 reg = MDIO_AN_LPA; 1410 break; 1411 default: 1412 return -EINVAL; 1413 } 1414 prtad = phy_id; 1415 devad = MII_ADDR_C45 | devad << 16 | reg; 1416 } else { 1417 prtad = phy_id; 1418 devad = reg; 1419 } 1420 1421 return mdiobus_write(phydev->mdio.bus, prtad, devad, val); 1422 } 1423 1424 static int phylink_mii_read(struct phylink *pl, unsigned int phy_id, 1425 unsigned int reg) 1426 { 1427 struct phylink_link_state state; 1428 int val = 0xffff; 1429 1430 switch (pl->link_an_mode) { 1431 case MLO_AN_FIXED: 1432 if (phy_id == 0) { 1433 phylink_get_fixed_state(pl, &state); 1434 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1435 true); 1436 } 1437 break; 1438 1439 case MLO_AN_PHY: 1440 return -EOPNOTSUPP; 1441 1442 case MLO_AN_INBAND: 1443 if (phy_id == 0) { 1444 val = phylink_get_mac_state(pl, &state); 1445 if (val < 0) 1446 return val; 1447 1448 val = phylink_mii_emul_read(pl->netdev, reg, &state, 1449 true); 1450 } 1451 break; 1452 } 1453 1454 return val & 0xffff; 1455 } 1456 1457 static int phylink_mii_write(struct phylink *pl, unsigned int phy_id, 1458 unsigned int reg, unsigned int val) 1459 { 1460 switch (pl->link_an_mode) { 1461 case MLO_AN_FIXED: 1462 break; 1463 1464 case MLO_AN_PHY: 1465 return -EOPNOTSUPP; 1466 1467 case MLO_AN_INBAND: 1468 break; 1469 } 1470 1471 return 0; 1472 } 1473 1474 /** 1475 * phylink_mii_ioctl() - generic mii ioctl interface 1476 * @pl: a pointer to a &struct phylink returned from phylink_create() 1477 * @ifr: a pointer to a &struct ifreq for socket ioctls 1478 * @cmd: ioctl cmd to execute 1479 * 1480 * Perform the specified MII ioctl on the PHY attached to the phylink instance 1481 * specified by @pl. If no PHY is attached, emulate the presence of the PHY. 1482 * 1483 * Returns: zero on success or negative error code. 1484 * 1485 * %SIOCGMIIPHY: 1486 * read register from the current PHY. 1487 * %SIOCGMIIREG: 1488 * read register from the specified PHY. 1489 * %SIOCSMIIREG: 1490 * set a register on the specified PHY. 1491 */ 1492 int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd) 1493 { 1494 struct mii_ioctl_data *mii = if_mii(ifr); 1495 int ret; 1496 1497 ASSERT_RTNL(); 1498 1499 if (pl->phydev) { 1500 /* PHYs only exist for MLO_AN_PHY and SGMII */ 1501 switch (cmd) { 1502 case SIOCGMIIPHY: 1503 mii->phy_id = pl->phydev->mdio.addr; 1504 /* fall through */ 1505 1506 case SIOCGMIIREG: 1507 ret = phylink_phy_read(pl, mii->phy_id, mii->reg_num); 1508 if (ret >= 0) { 1509 mii->val_out = ret; 1510 ret = 0; 1511 } 1512 break; 1513 1514 case SIOCSMIIREG: 1515 ret = phylink_phy_write(pl, mii->phy_id, mii->reg_num, 1516 mii->val_in); 1517 break; 1518 1519 default: 1520 ret = phy_mii_ioctl(pl->phydev, ifr, cmd); 1521 break; 1522 } 1523 } else { 1524 switch (cmd) { 1525 case SIOCGMIIPHY: 1526 mii->phy_id = 0; 1527 /* fall through */ 1528 1529 case SIOCGMIIREG: 1530 ret = phylink_mii_read(pl, mii->phy_id, mii->reg_num); 1531 if (ret >= 0) { 1532 mii->val_out = ret; 1533 ret = 0; 1534 } 1535 break; 1536 1537 case SIOCSMIIREG: 1538 ret = phylink_mii_write(pl, mii->phy_id, mii->reg_num, 1539 mii->val_in); 1540 break; 1541 1542 default: 1543 ret = -EOPNOTSUPP; 1544 break; 1545 } 1546 } 1547 1548 return ret; 1549 } 1550 EXPORT_SYMBOL_GPL(phylink_mii_ioctl); 1551 1552 static int phylink_sfp_module_insert(void *upstream, 1553 const struct sfp_eeprom_id *id) 1554 { 1555 struct phylink *pl = upstream; 1556 __ETHTOOL_DECLARE_LINK_MODE_MASK(support) = { 0, }; 1557 struct phylink_link_state config; 1558 phy_interface_t iface; 1559 int ret = 0; 1560 bool changed; 1561 u8 port; 1562 1563 ASSERT_RTNL(); 1564 1565 sfp_parse_support(pl->sfp_bus, id, support); 1566 port = sfp_parse_port(pl->sfp_bus, id, support); 1567 1568 memset(&config, 0, sizeof(config)); 1569 linkmode_copy(config.advertising, support); 1570 config.interface = PHY_INTERFACE_MODE_NA; 1571 config.speed = SPEED_UNKNOWN; 1572 config.duplex = DUPLEX_UNKNOWN; 1573 config.pause = MLO_PAUSE_AN; 1574 config.an_enabled = pl->link_config.an_enabled; 1575 1576 /* Ignore errors if we're expecting a PHY to attach later */ 1577 ret = phylink_validate(pl, support, &config); 1578 if (ret) { 1579 netdev_err(pl->netdev, "validation with support %*pb failed: %d\n", 1580 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret); 1581 return ret; 1582 } 1583 1584 iface = sfp_select_interface(pl->sfp_bus, id, config.advertising); 1585 if (iface == PHY_INTERFACE_MODE_NA) { 1586 netdev_err(pl->netdev, 1587 "selection of interface failed, advertisement %*pb\n", 1588 __ETHTOOL_LINK_MODE_MASK_NBITS, config.advertising); 1589 return -EINVAL; 1590 } 1591 1592 config.interface = iface; 1593 ret = phylink_validate(pl, support, &config); 1594 if (ret) { 1595 netdev_err(pl->netdev, "validation of %s/%s with support %*pb failed: %d\n", 1596 phylink_an_mode_str(MLO_AN_INBAND), 1597 phy_modes(config.interface), 1598 __ETHTOOL_LINK_MODE_MASK_NBITS, support, ret); 1599 return ret; 1600 } 1601 1602 netdev_dbg(pl->netdev, "requesting link mode %s/%s with support %*pb\n", 1603 phylink_an_mode_str(MLO_AN_INBAND), 1604 phy_modes(config.interface), 1605 __ETHTOOL_LINK_MODE_MASK_NBITS, support); 1606 1607 if (phy_interface_mode_is_8023z(iface) && pl->phydev) 1608 return -EINVAL; 1609 1610 changed = !bitmap_equal(pl->supported, support, 1611 __ETHTOOL_LINK_MODE_MASK_NBITS); 1612 if (changed) { 1613 linkmode_copy(pl->supported, support); 1614 linkmode_copy(pl->link_config.advertising, config.advertising); 1615 } 1616 1617 if (pl->link_an_mode != MLO_AN_INBAND || 1618 pl->link_config.interface != config.interface) { 1619 pl->link_config.interface = config.interface; 1620 pl->link_an_mode = MLO_AN_INBAND; 1621 1622 changed = true; 1623 1624 netdev_info(pl->netdev, "switched to %s/%s link mode\n", 1625 phylink_an_mode_str(MLO_AN_INBAND), 1626 phy_modes(config.interface)); 1627 } 1628 1629 pl->link_port = port; 1630 1631 if (changed && !test_bit(PHYLINK_DISABLE_STOPPED, 1632 &pl->phylink_disable_state)) 1633 phylink_mac_config(pl, &pl->link_config); 1634 1635 return ret; 1636 } 1637 1638 static void phylink_sfp_link_down(void *upstream) 1639 { 1640 struct phylink *pl = upstream; 1641 1642 ASSERT_RTNL(); 1643 1644 phylink_run_resolve_and_disable(pl, PHYLINK_DISABLE_LINK); 1645 } 1646 1647 static void phylink_sfp_link_up(void *upstream) 1648 { 1649 struct phylink *pl = upstream; 1650 1651 ASSERT_RTNL(); 1652 1653 clear_bit(PHYLINK_DISABLE_LINK, &pl->phylink_disable_state); 1654 phylink_run_resolve(pl); 1655 } 1656 1657 static int phylink_sfp_connect_phy(void *upstream, struct phy_device *phy) 1658 { 1659 struct phylink *pl = upstream; 1660 1661 return __phylink_connect_phy(upstream, phy, pl->link_config.interface); 1662 } 1663 1664 static void phylink_sfp_disconnect_phy(void *upstream) 1665 { 1666 phylink_disconnect_phy(upstream); 1667 } 1668 1669 static const struct sfp_upstream_ops sfp_phylink_ops = { 1670 .module_insert = phylink_sfp_module_insert, 1671 .link_up = phylink_sfp_link_up, 1672 .link_down = phylink_sfp_link_down, 1673 .connect_phy = phylink_sfp_connect_phy, 1674 .disconnect_phy = phylink_sfp_disconnect_phy, 1675 }; 1676 1677 /* Helpers for MAC drivers */ 1678 1679 /** 1680 * phylink_helper_basex_speed() - 1000BaseX/2500BaseX helper 1681 * @state: a pointer to a &struct phylink_link_state 1682 * 1683 * Inspect the interface mode, advertising mask or forced speed and 1684 * decide whether to run at 2.5Gbit or 1Gbit appropriately, switching 1685 * the interface mode to suit. @state->interface is appropriately 1686 * updated, and the advertising mask has the "other" baseX_Full flag 1687 * cleared. 1688 */ 1689 void phylink_helper_basex_speed(struct phylink_link_state *state) 1690 { 1691 if (phy_interface_mode_is_8023z(state->interface)) { 1692 bool want_2500 = state->an_enabled ? 1693 phylink_test(state->advertising, 2500baseX_Full) : 1694 state->speed == SPEED_2500; 1695 1696 if (want_2500) { 1697 phylink_clear(state->advertising, 1000baseX_Full); 1698 state->interface = PHY_INTERFACE_MODE_2500BASEX; 1699 } else { 1700 phylink_clear(state->advertising, 2500baseX_Full); 1701 state->interface = PHY_INTERFACE_MODE_1000BASEX; 1702 } 1703 } 1704 } 1705 EXPORT_SYMBOL_GPL(phylink_helper_basex_speed); 1706 1707 MODULE_LICENSE("GPL"); 1708