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