1 /* 2 * Handling of a single switch port 3 * 4 * Copyright (c) 2017 Savoir-faire Linux Inc. 5 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 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 as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 13 #include <linux/if_bridge.h> 14 #include <linux/notifier.h> 15 #include <linux/of_mdio.h> 16 #include <linux/of_net.h> 17 18 #include "dsa_priv.h" 19 20 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v) 21 { 22 struct raw_notifier_head *nh = &dp->ds->dst->nh; 23 int err; 24 25 err = raw_notifier_call_chain(nh, e, v); 26 27 return notifier_to_errno(err); 28 } 29 30 int dsa_port_set_state(struct dsa_port *dp, u8 state, 31 struct switchdev_trans *trans) 32 { 33 struct dsa_switch *ds = dp->ds; 34 int port = dp->index; 35 36 if (switchdev_trans_ph_prepare(trans)) 37 return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP; 38 39 if (ds->ops->port_stp_state_set) 40 ds->ops->port_stp_state_set(ds, port, state); 41 42 if (ds->ops->port_fast_age) { 43 /* Fast age FDB entries or flush appropriate forwarding database 44 * for the given port, if we are moving it from Learning or 45 * Forwarding state, to Disabled or Blocking or Listening state. 46 */ 47 48 if ((dp->stp_state == BR_STATE_LEARNING || 49 dp->stp_state == BR_STATE_FORWARDING) && 50 (state == BR_STATE_DISABLED || 51 state == BR_STATE_BLOCKING || 52 state == BR_STATE_LISTENING)) 53 ds->ops->port_fast_age(ds, port); 54 } 55 56 dp->stp_state = state; 57 58 return 0; 59 } 60 61 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state) 62 { 63 int err; 64 65 err = dsa_port_set_state(dp, state, NULL); 66 if (err) 67 pr_err("DSA: failed to set STP state %u (%d)\n", state, err); 68 } 69 70 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy) 71 { 72 struct dsa_switch *ds = dp->ds; 73 int port = dp->index; 74 int err; 75 76 if (ds->ops->port_enable) { 77 err = ds->ops->port_enable(ds, port, phy); 78 if (err) 79 return err; 80 } 81 82 if (!dp->bridge_dev) 83 dsa_port_set_state_now(dp, BR_STATE_FORWARDING); 84 85 return 0; 86 } 87 88 void dsa_port_disable(struct dsa_port *dp) 89 { 90 struct dsa_switch *ds = dp->ds; 91 int port = dp->index; 92 93 if (!dp->bridge_dev) 94 dsa_port_set_state_now(dp, BR_STATE_DISABLED); 95 96 if (ds->ops->port_disable) 97 ds->ops->port_disable(ds, port); 98 } 99 100 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br) 101 { 102 struct dsa_notifier_bridge_info info = { 103 .sw_index = dp->ds->index, 104 .port = dp->index, 105 .br = br, 106 }; 107 int err; 108 109 /* Set the flooding mode before joining the port in the switch */ 110 err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD, NULL); 111 if (err) 112 return err; 113 114 /* Here the interface is already bridged. Reflect the current 115 * configuration so that drivers can program their chips accordingly. 116 */ 117 dp->bridge_dev = br; 118 119 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info); 120 121 /* The bridging is rolled back on error */ 122 if (err) { 123 dsa_port_bridge_flags(dp, 0, NULL); 124 dp->bridge_dev = NULL; 125 } 126 127 return err; 128 } 129 130 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br) 131 { 132 struct dsa_notifier_bridge_info info = { 133 .sw_index = dp->ds->index, 134 .port = dp->index, 135 .br = br, 136 }; 137 int err; 138 139 /* Here the port is already unbridged. Reflect the current configuration 140 * so that drivers can program their chips accordingly. 141 */ 142 dp->bridge_dev = NULL; 143 144 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info); 145 if (err) 146 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n"); 147 148 /* Port is leaving the bridge, disable flooding */ 149 dsa_port_bridge_flags(dp, 0, NULL); 150 151 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer, 152 * so allow it to be in BR_STATE_FORWARDING to be kept functional 153 */ 154 dsa_port_set_state_now(dp, BR_STATE_FORWARDING); 155 } 156 157 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp, 158 bool vlan_filtering) 159 { 160 struct dsa_switch *ds = dp->ds; 161 int i; 162 163 if (!ds->vlan_filtering_is_global) 164 return true; 165 166 /* For cases where enabling/disabling VLAN awareness is global to the 167 * switch, we need to handle the case where multiple bridges span 168 * different ports of the same switch device and one of them has a 169 * different setting than what is being requested. 170 */ 171 for (i = 0; i < ds->num_ports; i++) { 172 struct net_device *other_bridge; 173 174 other_bridge = dsa_to_port(ds, i)->bridge_dev; 175 if (!other_bridge) 176 continue; 177 /* If it's the same bridge, it also has same 178 * vlan_filtering setting => no need to check 179 */ 180 if (other_bridge == dp->bridge_dev) 181 continue; 182 if (br_vlan_enabled(other_bridge) != vlan_filtering) { 183 dev_err(ds->dev, "VLAN filtering is a global setting\n"); 184 return false; 185 } 186 } 187 return true; 188 } 189 190 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering, 191 struct switchdev_trans *trans) 192 { 193 struct dsa_switch *ds = dp->ds; 194 int err; 195 196 /* bridge skips -EOPNOTSUPP, so skip the prepare phase */ 197 if (switchdev_trans_ph_prepare(trans)) 198 return 0; 199 200 if (!ds->ops->port_vlan_filtering) 201 return 0; 202 203 if (!dsa_port_can_apply_vlan_filtering(dp, vlan_filtering)) 204 return -EINVAL; 205 206 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering) 207 return 0; 208 209 err = ds->ops->port_vlan_filtering(ds, dp->index, 210 vlan_filtering); 211 if (err) 212 return err; 213 214 if (ds->vlan_filtering_is_global) 215 ds->vlan_filtering = vlan_filtering; 216 else 217 dp->vlan_filtering = vlan_filtering; 218 return 0; 219 } 220 221 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock, 222 struct switchdev_trans *trans) 223 { 224 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock); 225 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies); 226 struct dsa_notifier_ageing_time_info info = { 227 .ageing_time = ageing_time, 228 .trans = trans, 229 }; 230 231 if (switchdev_trans_ph_prepare(trans)) 232 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 233 234 dp->ageing_time = ageing_time; 235 236 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 237 } 238 239 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags, 240 struct switchdev_trans *trans) 241 { 242 struct dsa_switch *ds = dp->ds; 243 244 if (!ds->ops->port_egress_floods || 245 (flags & ~(BR_FLOOD | BR_MCAST_FLOOD))) 246 return -EINVAL; 247 248 return 0; 249 } 250 251 int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags, 252 struct switchdev_trans *trans) 253 { 254 struct dsa_switch *ds = dp->ds; 255 int port = dp->index; 256 int err = 0; 257 258 if (switchdev_trans_ph_prepare(trans)) 259 return 0; 260 261 if (ds->ops->port_egress_floods) 262 err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD, 263 flags & BR_MCAST_FLOOD); 264 265 return err; 266 } 267 268 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr, 269 u16 vid) 270 { 271 struct dsa_notifier_fdb_info info = { 272 .sw_index = dp->ds->index, 273 .port = dp->index, 274 .addr = addr, 275 .vid = vid, 276 }; 277 278 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info); 279 } 280 281 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr, 282 u16 vid) 283 { 284 struct dsa_notifier_fdb_info info = { 285 .sw_index = dp->ds->index, 286 .port = dp->index, 287 .addr = addr, 288 .vid = vid, 289 290 }; 291 292 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info); 293 } 294 295 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data) 296 { 297 struct dsa_switch *ds = dp->ds; 298 int port = dp->index; 299 300 if (!ds->ops->port_fdb_dump) 301 return -EOPNOTSUPP; 302 303 return ds->ops->port_fdb_dump(ds, port, cb, data); 304 } 305 306 int dsa_port_mdb_add(const struct dsa_port *dp, 307 const struct switchdev_obj_port_mdb *mdb, 308 struct switchdev_trans *trans) 309 { 310 struct dsa_notifier_mdb_info info = { 311 .sw_index = dp->ds->index, 312 .port = dp->index, 313 .trans = trans, 314 .mdb = mdb, 315 }; 316 317 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info); 318 } 319 320 int dsa_port_mdb_del(const struct dsa_port *dp, 321 const struct switchdev_obj_port_mdb *mdb) 322 { 323 struct dsa_notifier_mdb_info info = { 324 .sw_index = dp->ds->index, 325 .port = dp->index, 326 .mdb = mdb, 327 }; 328 329 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info); 330 } 331 332 int dsa_port_vlan_add(struct dsa_port *dp, 333 const struct switchdev_obj_port_vlan *vlan, 334 struct switchdev_trans *trans) 335 { 336 struct dsa_notifier_vlan_info info = { 337 .sw_index = dp->ds->index, 338 .port = dp->index, 339 .trans = trans, 340 .vlan = vlan, 341 }; 342 343 /* Can be called from dsa_slave_port_obj_add() or 344 * dsa_slave_vlan_rx_add_vid() 345 */ 346 if (!dp->bridge_dev || br_vlan_enabled(dp->bridge_dev)) 347 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); 348 349 return 0; 350 } 351 352 int dsa_port_vlan_del(struct dsa_port *dp, 353 const struct switchdev_obj_port_vlan *vlan) 354 { 355 struct dsa_notifier_vlan_info info = { 356 .sw_index = dp->ds->index, 357 .port = dp->index, 358 .vlan = vlan, 359 }; 360 361 if (vlan->obj.orig_dev && netif_is_bridge_master(vlan->obj.orig_dev)) 362 return -EOPNOTSUPP; 363 364 /* Can be called from dsa_slave_port_obj_del() or 365 * dsa_slave_vlan_rx_kill_vid() 366 */ 367 if (!dp->bridge_dev || br_vlan_enabled(dp->bridge_dev)) 368 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 369 370 return 0; 371 } 372 373 int dsa_port_vid_add(struct dsa_port *dp, u16 vid, u16 flags) 374 { 375 struct switchdev_obj_port_vlan vlan = { 376 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 377 .flags = flags, 378 .vid_begin = vid, 379 .vid_end = vid, 380 }; 381 struct switchdev_trans trans; 382 int err; 383 384 trans.ph_prepare = true; 385 err = dsa_port_vlan_add(dp, &vlan, &trans); 386 if (err == -EOPNOTSUPP) 387 return 0; 388 389 trans.ph_prepare = false; 390 return dsa_port_vlan_add(dp, &vlan, &trans); 391 } 392 EXPORT_SYMBOL(dsa_port_vid_add); 393 394 int dsa_port_vid_del(struct dsa_port *dp, u16 vid) 395 { 396 struct switchdev_obj_port_vlan vlan = { 397 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 398 .vid_begin = vid, 399 .vid_end = vid, 400 }; 401 402 return dsa_port_vlan_del(dp, &vlan); 403 } 404 EXPORT_SYMBOL(dsa_port_vid_del); 405 406 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) 407 { 408 struct device_node *phy_dn; 409 struct phy_device *phydev; 410 411 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); 412 if (!phy_dn) 413 return NULL; 414 415 phydev = of_phy_find_device(phy_dn); 416 if (!phydev) { 417 of_node_put(phy_dn); 418 return ERR_PTR(-EPROBE_DEFER); 419 } 420 421 of_node_put(phy_dn); 422 return phydev; 423 } 424 425 void dsa_port_phylink_validate(struct phylink_config *config, 426 unsigned long *supported, 427 struct phylink_link_state *state) 428 { 429 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 430 struct dsa_switch *ds = dp->ds; 431 432 if (!ds->ops->phylink_validate) 433 return; 434 435 ds->ops->phylink_validate(ds, dp->index, supported, state); 436 } 437 EXPORT_SYMBOL_GPL(dsa_port_phylink_validate); 438 439 int dsa_port_phylink_mac_link_state(struct phylink_config *config, 440 struct phylink_link_state *state) 441 { 442 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 443 struct dsa_switch *ds = dp->ds; 444 445 /* Only called for SGMII and 802.3z */ 446 if (!ds->ops->phylink_mac_link_state) 447 return -EOPNOTSUPP; 448 449 return ds->ops->phylink_mac_link_state(ds, dp->index, state); 450 } 451 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_state); 452 453 void dsa_port_phylink_mac_config(struct phylink_config *config, 454 unsigned int mode, 455 const struct phylink_link_state *state) 456 { 457 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 458 struct dsa_switch *ds = dp->ds; 459 460 if (!ds->ops->phylink_mac_config) 461 return; 462 463 ds->ops->phylink_mac_config(ds, dp->index, mode, state); 464 } 465 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_config); 466 467 void dsa_port_phylink_mac_an_restart(struct phylink_config *config) 468 { 469 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 470 struct dsa_switch *ds = dp->ds; 471 472 if (!ds->ops->phylink_mac_an_restart) 473 return; 474 475 ds->ops->phylink_mac_an_restart(ds, dp->index); 476 } 477 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_an_restart); 478 479 void dsa_port_phylink_mac_link_down(struct phylink_config *config, 480 unsigned int mode, 481 phy_interface_t interface) 482 { 483 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 484 struct phy_device *phydev = NULL; 485 struct dsa_switch *ds = dp->ds; 486 487 if (dsa_is_user_port(ds, dp->index)) 488 phydev = dp->slave->phydev; 489 490 if (!ds->ops->phylink_mac_link_down) { 491 if (ds->ops->adjust_link && phydev) 492 ds->ops->adjust_link(ds, dp->index, phydev); 493 return; 494 } 495 496 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface); 497 } 498 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_down); 499 500 void dsa_port_phylink_mac_link_up(struct phylink_config *config, 501 unsigned int mode, 502 phy_interface_t interface, 503 struct phy_device *phydev) 504 { 505 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 506 struct dsa_switch *ds = dp->ds; 507 508 if (!ds->ops->phylink_mac_link_up) { 509 if (ds->ops->adjust_link && phydev) 510 ds->ops->adjust_link(ds, dp->index, phydev); 511 return; 512 } 513 514 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev); 515 } 516 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_up); 517 518 const struct phylink_mac_ops dsa_port_phylink_mac_ops = { 519 .validate = dsa_port_phylink_validate, 520 .mac_link_state = dsa_port_phylink_mac_link_state, 521 .mac_config = dsa_port_phylink_mac_config, 522 .mac_an_restart = dsa_port_phylink_mac_an_restart, 523 .mac_link_down = dsa_port_phylink_mac_link_down, 524 .mac_link_up = dsa_port_phylink_mac_link_up, 525 }; 526 527 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 528 { 529 struct dsa_switch *ds = dp->ds; 530 struct phy_device *phydev; 531 int port = dp->index; 532 int err = 0; 533 534 phydev = dsa_port_get_phy_device(dp); 535 if (!phydev) 536 return 0; 537 538 if (IS_ERR(phydev)) 539 return PTR_ERR(phydev); 540 541 if (enable) { 542 err = genphy_config_init(phydev); 543 if (err < 0) 544 goto err_put_dev; 545 546 err = genphy_resume(phydev); 547 if (err < 0) 548 goto err_put_dev; 549 550 err = genphy_read_status(phydev); 551 if (err < 0) 552 goto err_put_dev; 553 } else { 554 err = genphy_suspend(phydev); 555 if (err < 0) 556 goto err_put_dev; 557 } 558 559 if (ds->ops->adjust_link) 560 ds->ops->adjust_link(ds, port, phydev); 561 562 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 563 564 err_put_dev: 565 put_device(&phydev->mdio.dev); 566 return err; 567 } 568 569 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 570 { 571 struct device_node *dn = dp->dn; 572 struct dsa_switch *ds = dp->ds; 573 struct phy_device *phydev; 574 int port = dp->index; 575 int mode; 576 int err; 577 578 err = of_phy_register_fixed_link(dn); 579 if (err) { 580 dev_err(ds->dev, 581 "failed to register the fixed PHY of port %d\n", 582 port); 583 return err; 584 } 585 586 phydev = of_phy_find_device(dn); 587 588 mode = of_get_phy_mode(dn); 589 if (mode < 0) 590 mode = PHY_INTERFACE_MODE_NA; 591 phydev->interface = mode; 592 593 genphy_config_init(phydev); 594 genphy_read_status(phydev); 595 596 if (ds->ops->adjust_link) 597 ds->ops->adjust_link(ds, port, phydev); 598 599 put_device(&phydev->mdio.dev); 600 601 return 0; 602 } 603 604 static int dsa_port_phylink_register(struct dsa_port *dp) 605 { 606 struct dsa_switch *ds = dp->ds; 607 struct device_node *port_dn = dp->dn; 608 int mode, err; 609 610 mode = of_get_phy_mode(port_dn); 611 if (mode < 0) 612 mode = PHY_INTERFACE_MODE_NA; 613 614 dp->pl_config.dev = ds->dev; 615 dp->pl_config.type = PHYLINK_DEV; 616 617 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), 618 mode, &dsa_port_phylink_mac_ops); 619 if (IS_ERR(dp->pl)) { 620 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl)); 621 return PTR_ERR(dp->pl); 622 } 623 624 err = phylink_of_phy_connect(dp->pl, port_dn, 0); 625 if (err) { 626 pr_err("could not attach to PHY: %d\n", err); 627 goto err_phy_connect; 628 } 629 630 rtnl_lock(); 631 phylink_start(dp->pl); 632 rtnl_unlock(); 633 634 return 0; 635 636 err_phy_connect: 637 phylink_destroy(dp->pl); 638 return err; 639 } 640 641 int dsa_port_link_register_of(struct dsa_port *dp) 642 { 643 struct dsa_switch *ds = dp->ds; 644 645 if (!ds->ops->adjust_link) 646 return dsa_port_phylink_register(dp); 647 648 dev_warn(ds->dev, 649 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n"); 650 651 if (of_phy_is_fixed_link(dp->dn)) 652 return dsa_port_fixed_link_register_of(dp); 653 else 654 return dsa_port_setup_phy_of(dp, true); 655 } 656 657 void dsa_port_link_unregister_of(struct dsa_port *dp) 658 { 659 struct dsa_switch *ds = dp->ds; 660 661 if (!ds->ops->adjust_link) { 662 rtnl_lock(); 663 phylink_disconnect_phy(dp->pl); 664 rtnl_unlock(); 665 phylink_destroy(dp->pl); 666 return; 667 } 668 669 if (of_phy_is_fixed_link(dp->dn)) 670 of_phy_deregister_fixed_link(dp->dn); 671 else 672 dsa_port_setup_phy_of(dp, false); 673 } 674 675 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) 676 { 677 struct phy_device *phydev; 678 int ret = -EOPNOTSUPP; 679 680 if (of_phy_is_fixed_link(dp->dn)) 681 return ret; 682 683 phydev = dsa_port_get_phy_device(dp); 684 if (IS_ERR_OR_NULL(phydev)) 685 return ret; 686 687 ret = phy_ethtool_get_strings(phydev, data); 688 put_device(&phydev->mdio.dev); 689 690 return ret; 691 } 692 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); 693 694 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) 695 { 696 struct phy_device *phydev; 697 int ret = -EOPNOTSUPP; 698 699 if (of_phy_is_fixed_link(dp->dn)) 700 return ret; 701 702 phydev = dsa_port_get_phy_device(dp); 703 if (IS_ERR_OR_NULL(phydev)) 704 return ret; 705 706 ret = phy_ethtool_get_stats(phydev, NULL, data); 707 put_device(&phydev->mdio.dev); 708 709 return ret; 710 } 711 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); 712 713 int dsa_port_get_phy_sset_count(struct dsa_port *dp) 714 { 715 struct phy_device *phydev; 716 int ret = -EOPNOTSUPP; 717 718 if (of_phy_is_fixed_link(dp->dn)) 719 return ret; 720 721 phydev = dsa_port_get_phy_device(dp); 722 if (IS_ERR_OR_NULL(phydev)) 723 return ret; 724 725 ret = phy_ethtool_get_sset_count(phydev); 726 put_device(&phydev->mdio.dev); 727 728 return ret; 729 } 730 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count); 731