1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2/* Copyright (c) 2019-2020 Marvell International Ltd. All rights reserved */ 3 4#include <linux/if_bridge.h> 5#include <linux/if_vlan.h> 6#include <linux/kernel.h> 7#include <linux/module.h> 8#include <linux/notifier.h> 9#include <net/netevent.h> 10#include <net/switchdev.h> 11 12#include "prestera.h" 13#include "prestera_hw.h" 14#include "prestera_switchdev.h" 15 16#define PRESTERA_VID_ALL (0xffff) 17 18#define PRESTERA_DEFAULT_AGEING_TIME_MS 300000 19#define PRESTERA_MAX_AGEING_TIME_MS 1000000000 20#define PRESTERA_MIN_AGEING_TIME_MS 32000 21 22struct prestera_fdb_event_work { 23 struct work_struct work; 24 struct switchdev_notifier_fdb_info fdb_info; 25 struct net_device *dev; 26 unsigned long event; 27}; 28 29struct prestera_switchdev { 30 struct prestera_switch *sw; 31 struct list_head bridge_list; 32 bool bridge_8021q_exists; 33 struct notifier_block swdev_nb_blk; 34 struct notifier_block swdev_nb; 35}; 36 37struct prestera_bridge { 38 struct list_head head; 39 struct net_device *dev; 40 struct prestera_switchdev *swdev; 41 struct list_head port_list; 42 struct list_head br_mdb_entry_list; 43 bool mrouter_exist; 44 bool vlan_enabled; 45 bool multicast_enabled; 46 u16 bridge_id; 47}; 48 49struct prestera_bridge_port { 50 struct list_head head; 51 struct net_device *dev; 52 struct prestera_bridge *bridge; 53 struct list_head vlan_list; 54 struct list_head br_mdb_port_list; 55 refcount_t ref_count; 56 unsigned long flags; 57 bool mrouter; 58 u8 stp_state; 59}; 60 61struct prestera_bridge_vlan { 62 struct list_head head; 63 struct list_head port_vlan_list; 64 u16 vid; 65}; 66 67struct prestera_port_vlan { 68 struct list_head br_vlan_head; 69 struct list_head port_head; 70 struct prestera_port *port; 71 struct prestera_bridge_port *br_port; 72 u16 vid; 73}; 74 75struct prestera_br_mdb_port { 76 struct prestera_bridge_port *br_port; 77 struct list_head br_mdb_port_node; 78}; 79 80/* Software representation of MDB table. */ 81struct prestera_br_mdb_entry { 82 struct prestera_bridge *bridge; 83 struct prestera_mdb_entry *mdb; 84 struct list_head br_mdb_port_list; 85 struct list_head br_mdb_entry_node; 86 bool enabled; 87}; 88 89static struct workqueue_struct *swdev_wq; 90 91static void prestera_bridge_port_put(struct prestera_bridge_port *br_port); 92 93static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid, 94 u8 state); 95 96static struct prestera_bridge * 97prestera_bridge_find(const struct prestera_switch *sw, 98 const struct net_device *br_dev) 99{ 100 struct prestera_bridge *bridge; 101 102 list_for_each_entry(bridge, &sw->swdev->bridge_list, head) 103 if (bridge->dev == br_dev) 104 return bridge; 105 106 return NULL; 107} 108 109static struct prestera_bridge_port * 110__prestera_bridge_port_find(const struct prestera_bridge *bridge, 111 const struct net_device *brport_dev) 112{ 113 struct prestera_bridge_port *br_port; 114 115 list_for_each_entry(br_port, &bridge->port_list, head) 116 if (br_port->dev == brport_dev) 117 return br_port; 118 119 return NULL; 120} 121 122static struct prestera_bridge_port * 123prestera_bridge_port_find(struct prestera_switch *sw, 124 struct net_device *brport_dev) 125{ 126 struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev); 127 struct prestera_bridge *bridge; 128 129 if (!br_dev) 130 return NULL; 131 132 bridge = prestera_bridge_find(sw, br_dev); 133 if (!bridge) 134 return NULL; 135 136 return __prestera_bridge_port_find(bridge, brport_dev); 137} 138 139static void 140prestera_br_port_flags_reset(struct prestera_bridge_port *br_port, 141 struct prestera_port *port) 142{ 143 prestera_port_uc_flood_set(port, false); 144 prestera_port_mc_flood_set(port, false); 145 prestera_port_learning_set(port, false); 146 prestera_port_br_locked_set(port, false); 147} 148 149static int prestera_br_port_flags_set(struct prestera_bridge_port *br_port, 150 struct prestera_port *port) 151{ 152 int err; 153 154 err = prestera_port_uc_flood_set(port, br_port->flags & BR_FLOOD); 155 if (err) 156 goto err_out; 157 158 err = prestera_port_mc_flood_set(port, br_port->flags & BR_MCAST_FLOOD); 159 if (err) 160 goto err_out; 161 162 err = prestera_port_learning_set(port, br_port->flags & BR_LEARNING); 163 if (err) 164 goto err_out; 165 166 err = prestera_port_br_locked_set(port, 167 br_port->flags & BR_PORT_LOCKED); 168 if (err) 169 goto err_out; 170 171 return 0; 172 173err_out: 174 prestera_br_port_flags_reset(br_port, port); 175 return err; 176} 177 178static struct prestera_bridge_vlan * 179prestera_bridge_vlan_create(struct prestera_bridge_port *br_port, u16 vid) 180{ 181 struct prestera_bridge_vlan *br_vlan; 182 183 br_vlan = kzalloc(sizeof(*br_vlan), GFP_KERNEL); 184 if (!br_vlan) 185 return NULL; 186 187 INIT_LIST_HEAD(&br_vlan->port_vlan_list); 188 br_vlan->vid = vid; 189 list_add(&br_vlan->head, &br_port->vlan_list); 190 191 return br_vlan; 192} 193 194static void prestera_bridge_vlan_destroy(struct prestera_bridge_vlan *br_vlan) 195{ 196 list_del(&br_vlan->head); 197 WARN_ON(!list_empty(&br_vlan->port_vlan_list)); 198 kfree(br_vlan); 199} 200 201static struct prestera_bridge_vlan * 202prestera_bridge_vlan_by_vid(struct prestera_bridge_port *br_port, u16 vid) 203{ 204 struct prestera_bridge_vlan *br_vlan; 205 206 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 207 if (br_vlan->vid == vid) 208 return br_vlan; 209 } 210 211 return NULL; 212} 213 214static int prestera_bridge_vlan_port_count(struct prestera_bridge *bridge, 215 u16 vid) 216{ 217 struct prestera_bridge_port *br_port; 218 struct prestera_bridge_vlan *br_vlan; 219 int count = 0; 220 221 list_for_each_entry(br_port, &bridge->port_list, head) { 222 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 223 if (br_vlan->vid == vid) { 224 count += 1; 225 break; 226 } 227 } 228 } 229 230 return count; 231} 232 233static void prestera_bridge_vlan_put(struct prestera_bridge_vlan *br_vlan) 234{ 235 if (list_empty(&br_vlan->port_vlan_list)) 236 prestera_bridge_vlan_destroy(br_vlan); 237} 238 239static struct prestera_port_vlan * 240prestera_port_vlan_by_vid(struct prestera_port *port, u16 vid) 241{ 242 struct prestera_port_vlan *port_vlan; 243 244 list_for_each_entry(port_vlan, &port->vlans_list, port_head) { 245 if (port_vlan->vid == vid) 246 return port_vlan; 247 } 248 249 return NULL; 250} 251 252static struct prestera_port_vlan * 253prestera_port_vlan_create(struct prestera_port *port, u16 vid, bool untagged) 254{ 255 struct prestera_port_vlan *port_vlan; 256 int err; 257 258 port_vlan = prestera_port_vlan_by_vid(port, vid); 259 if (port_vlan) 260 return ERR_PTR(-EEXIST); 261 262 err = prestera_hw_vlan_port_set(port, vid, true, untagged); 263 if (err) 264 return ERR_PTR(err); 265 266 port_vlan = kzalloc(sizeof(*port_vlan), GFP_KERNEL); 267 if (!port_vlan) { 268 err = -ENOMEM; 269 goto err_port_vlan_alloc; 270 } 271 272 port_vlan->port = port; 273 port_vlan->vid = vid; 274 275 list_add(&port_vlan->port_head, &port->vlans_list); 276 277 return port_vlan; 278 279err_port_vlan_alloc: 280 prestera_hw_vlan_port_set(port, vid, false, false); 281 return ERR_PTR(err); 282} 283 284static int prestera_fdb_add(struct prestera_port *port, 285 const unsigned char *mac, u16 vid, bool dynamic) 286{ 287 if (prestera_port_is_lag_member(port)) 288 return prestera_hw_lag_fdb_add(port->sw, prestera_port_lag_id(port), 289 mac, vid, dynamic); 290 291 return prestera_hw_fdb_add(port, mac, vid, dynamic); 292} 293 294static int prestera_fdb_del(struct prestera_port *port, 295 const unsigned char *mac, u16 vid) 296{ 297 if (prestera_port_is_lag_member(port)) 298 return prestera_hw_lag_fdb_del(port->sw, prestera_port_lag_id(port), 299 mac, vid); 300 else 301 return prestera_hw_fdb_del(port, mac, vid); 302} 303 304static int prestera_fdb_flush_port_vlan(struct prestera_port *port, u16 vid, 305 u32 mode) 306{ 307 if (prestera_port_is_lag_member(port)) 308 return prestera_hw_fdb_flush_lag_vlan(port->sw, prestera_port_lag_id(port), 309 vid, mode); 310 else 311 return prestera_hw_fdb_flush_port_vlan(port, vid, mode); 312} 313 314static int prestera_fdb_flush_port(struct prestera_port *port, u32 mode) 315{ 316 if (prestera_port_is_lag_member(port)) 317 return prestera_hw_fdb_flush_lag(port->sw, prestera_port_lag_id(port), 318 mode); 319 else 320 return prestera_hw_fdb_flush_port(port, mode); 321} 322 323static void 324prestera_mdb_port_del(struct prestera_mdb_entry *mdb, 325 struct net_device *orig_dev) 326{ 327 struct prestera_flood_domain *fl_domain = mdb->flood_domain; 328 struct prestera_flood_domain_port *flood_domain_port; 329 330 flood_domain_port = prestera_flood_domain_port_find(fl_domain, 331 orig_dev, 332 mdb->vid); 333 if (flood_domain_port) 334 prestera_flood_domain_port_destroy(flood_domain_port); 335} 336 337static void 338prestera_br_mdb_entry_put(struct prestera_br_mdb_entry *br_mdb) 339{ 340 struct prestera_bridge_port *br_port; 341 342 if (list_empty(&br_mdb->br_mdb_port_list)) { 343 list_for_each_entry(br_port, &br_mdb->bridge->port_list, head) 344 prestera_mdb_port_del(br_mdb->mdb, br_port->dev); 345 346 prestera_mdb_entry_destroy(br_mdb->mdb); 347 list_del(&br_mdb->br_mdb_entry_node); 348 kfree(br_mdb); 349 } 350} 351 352static void 353prestera_br_mdb_port_del(struct prestera_br_mdb_entry *br_mdb, 354 struct prestera_bridge_port *br_port) 355{ 356 struct prestera_br_mdb_port *br_mdb_port, *tmp; 357 358 list_for_each_entry_safe(br_mdb_port, tmp, &br_mdb->br_mdb_port_list, 359 br_mdb_port_node) { 360 if (br_mdb_port->br_port == br_port) { 361 list_del(&br_mdb_port->br_mdb_port_node); 362 kfree(br_mdb_port); 363 } 364 } 365} 366 367static void 368prestera_mdb_flush_bridge_port(struct prestera_bridge_port *br_port) 369{ 370 struct prestera_br_mdb_port *br_mdb_port, *tmp_port; 371 struct prestera_br_mdb_entry *br_mdb, *br_mdb_tmp; 372 struct prestera_bridge *br_dev = br_port->bridge; 373 374 list_for_each_entry_safe(br_mdb, br_mdb_tmp, &br_dev->br_mdb_entry_list, 375 br_mdb_entry_node) { 376 list_for_each_entry_safe(br_mdb_port, tmp_port, 377 &br_mdb->br_mdb_port_list, 378 br_mdb_port_node) { 379 prestera_mdb_port_del(br_mdb->mdb, 380 br_mdb_port->br_port->dev); 381 prestera_br_mdb_port_del(br_mdb, br_mdb_port->br_port); 382 } 383 prestera_br_mdb_entry_put(br_mdb); 384 } 385} 386 387static void 388prestera_port_vlan_bridge_leave(struct prestera_port_vlan *port_vlan) 389{ 390 u32 fdb_flush_mode = PRESTERA_FDB_FLUSH_MODE_DYNAMIC; 391 struct prestera_port *port = port_vlan->port; 392 struct prestera_bridge_vlan *br_vlan; 393 struct prestera_bridge_port *br_port; 394 bool last_port, last_vlan; 395 u16 vid = port_vlan->vid; 396 int port_count; 397 398 br_port = port_vlan->br_port; 399 port_count = prestera_bridge_vlan_port_count(br_port->bridge, vid); 400 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid); 401 402 last_vlan = list_is_singular(&br_port->vlan_list); 403 last_port = port_count == 1; 404 405 if (last_vlan) 406 prestera_fdb_flush_port(port, fdb_flush_mode); 407 else if (last_port) 408 prestera_hw_fdb_flush_vlan(port->sw, vid, fdb_flush_mode); 409 else 410 prestera_fdb_flush_port_vlan(port, vid, fdb_flush_mode); 411 412 prestera_mdb_flush_bridge_port(br_port); 413 414 list_del(&port_vlan->br_vlan_head); 415 prestera_bridge_vlan_put(br_vlan); 416 prestera_bridge_port_put(br_port); 417 port_vlan->br_port = NULL; 418} 419 420static void prestera_port_vlan_destroy(struct prestera_port_vlan *port_vlan) 421{ 422 struct prestera_port *port = port_vlan->port; 423 u16 vid = port_vlan->vid; 424 425 if (port_vlan->br_port) 426 prestera_port_vlan_bridge_leave(port_vlan); 427 428 prestera_hw_vlan_port_set(port, vid, false, false); 429 list_del(&port_vlan->port_head); 430 kfree(port_vlan); 431} 432 433static struct prestera_bridge * 434prestera_bridge_create(struct prestera_switchdev *swdev, struct net_device *dev) 435{ 436 bool vlan_enabled = br_vlan_enabled(dev); 437 struct prestera_bridge *bridge; 438 u16 bridge_id; 439 int err; 440 441 if (vlan_enabled && swdev->bridge_8021q_exists) { 442 netdev_err(dev, "Only one VLAN-aware bridge is supported\n"); 443 return ERR_PTR(-EINVAL); 444 } 445 446 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 447 if (!bridge) 448 return ERR_PTR(-ENOMEM); 449 450 if (vlan_enabled) { 451 swdev->bridge_8021q_exists = true; 452 } else { 453 err = prestera_hw_bridge_create(swdev->sw, &bridge_id); 454 if (err) { 455 kfree(bridge); 456 return ERR_PTR(err); 457 } 458 459 bridge->bridge_id = bridge_id; 460 } 461 462 bridge->vlan_enabled = vlan_enabled; 463 bridge->swdev = swdev; 464 bridge->dev = dev; 465 bridge->multicast_enabled = br_multicast_enabled(dev); 466 467 INIT_LIST_HEAD(&bridge->port_list); 468 INIT_LIST_HEAD(&bridge->br_mdb_entry_list); 469 470 list_add(&bridge->head, &swdev->bridge_list); 471 472 return bridge; 473} 474 475static void prestera_bridge_destroy(struct prestera_bridge *bridge) 476{ 477 struct prestera_switchdev *swdev = bridge->swdev; 478 479 list_del(&bridge->head); 480 481 if (bridge->vlan_enabled) 482 swdev->bridge_8021q_exists = false; 483 else 484 prestera_hw_bridge_delete(swdev->sw, bridge->bridge_id); 485 486 WARN_ON(!list_empty(&bridge->br_mdb_entry_list)); 487 WARN_ON(!list_empty(&bridge->port_list)); 488 kfree(bridge); 489} 490 491static void prestera_bridge_put(struct prestera_bridge *bridge) 492{ 493 if (list_empty(&bridge->port_list)) 494 prestera_bridge_destroy(bridge); 495} 496 497static 498struct prestera_bridge *prestera_bridge_by_dev(struct prestera_switchdev *swdev, 499 const struct net_device *dev) 500{ 501 struct prestera_bridge *bridge; 502 503 list_for_each_entry(bridge, &swdev->bridge_list, head) 504 if (bridge->dev == dev) 505 return bridge; 506 507 return NULL; 508} 509 510static struct prestera_bridge_port * 511__prestera_bridge_port_by_dev(struct prestera_bridge *bridge, 512 struct net_device *dev) 513{ 514 struct prestera_bridge_port *br_port; 515 516 list_for_each_entry(br_port, &bridge->port_list, head) { 517 if (br_port->dev == dev) 518 return br_port; 519 } 520 521 return NULL; 522} 523 524static int prestera_match_upper_bridge_dev(struct net_device *dev, 525 struct netdev_nested_priv *priv) 526{ 527 if (netif_is_bridge_master(dev)) 528 priv->data = dev; 529 530 return 0; 531} 532 533static struct net_device *prestera_get_upper_bridge_dev(struct net_device *dev) 534{ 535 struct netdev_nested_priv priv = { }; 536 537 netdev_walk_all_upper_dev_rcu(dev, prestera_match_upper_bridge_dev, 538 &priv); 539 return priv.data; 540} 541 542static struct prestera_bridge_port * 543prestera_bridge_port_by_dev(struct prestera_switchdev *swdev, 544 struct net_device *dev) 545{ 546 struct net_device *br_dev = prestera_get_upper_bridge_dev(dev); 547 struct prestera_bridge *bridge; 548 549 if (!br_dev) 550 return NULL; 551 552 bridge = prestera_bridge_by_dev(swdev, br_dev); 553 if (!bridge) 554 return NULL; 555 556 return __prestera_bridge_port_by_dev(bridge, dev); 557} 558 559static struct prestera_bridge_port * 560prestera_bridge_port_create(struct prestera_bridge *bridge, 561 struct net_device *dev) 562{ 563 struct prestera_bridge_port *br_port; 564 565 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL); 566 if (!br_port) 567 return NULL; 568 569 br_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC | 570 BR_MCAST_FLOOD; 571 br_port->stp_state = BR_STATE_DISABLED; 572 refcount_set(&br_port->ref_count, 1); 573 br_port->bridge = bridge; 574 br_port->dev = dev; 575 576 INIT_LIST_HEAD(&br_port->vlan_list); 577 list_add(&br_port->head, &bridge->port_list); 578 INIT_LIST_HEAD(&br_port->br_mdb_port_list); 579 580 return br_port; 581} 582 583static void 584prestera_bridge_port_destroy(struct prestera_bridge_port *br_port) 585{ 586 list_del(&br_port->head); 587 WARN_ON(!list_empty(&br_port->vlan_list)); 588 WARN_ON(!list_empty(&br_port->br_mdb_port_list)); 589 kfree(br_port); 590} 591 592static void prestera_bridge_port_get(struct prestera_bridge_port *br_port) 593{ 594 refcount_inc(&br_port->ref_count); 595} 596 597static void prestera_bridge_port_put(struct prestera_bridge_port *br_port) 598{ 599 struct prestera_bridge *bridge = br_port->bridge; 600 601 if (refcount_dec_and_test(&br_port->ref_count)) { 602 prestera_bridge_port_destroy(br_port); 603 prestera_bridge_put(bridge); 604 } 605} 606 607static struct prestera_bridge_port * 608prestera_bridge_port_add(struct prestera_bridge *bridge, struct net_device *dev) 609{ 610 struct prestera_bridge_port *br_port; 611 612 br_port = __prestera_bridge_port_by_dev(bridge, dev); 613 if (br_port) { 614 prestera_bridge_port_get(br_port); 615 return br_port; 616 } 617 618 br_port = prestera_bridge_port_create(bridge, dev); 619 if (!br_port) 620 return ERR_PTR(-ENOMEM); 621 622 return br_port; 623} 624 625static int 626prestera_bridge_1d_port_join(struct prestera_bridge_port *br_port) 627{ 628 struct prestera_port *port = netdev_priv(br_port->dev); 629 struct prestera_bridge *bridge = br_port->bridge; 630 int err; 631 632 err = prestera_hw_bridge_port_add(port, bridge->bridge_id); 633 if (err) 634 return err; 635 636 err = prestera_br_port_flags_set(br_port, port); 637 if (err) 638 goto err_flags2port_set; 639 640 return 0; 641 642err_flags2port_set: 643 prestera_hw_bridge_port_delete(port, bridge->bridge_id); 644 645 return err; 646} 647 648int prestera_bridge_port_join(struct net_device *br_dev, 649 struct prestera_port *port, 650 struct netlink_ext_ack *extack) 651{ 652 struct prestera_switchdev *swdev = port->sw->swdev; 653 struct prestera_bridge_port *br_port; 654 struct prestera_bridge *bridge; 655 int err; 656 657 bridge = prestera_bridge_by_dev(swdev, br_dev); 658 if (!bridge) { 659 bridge = prestera_bridge_create(swdev, br_dev); 660 if (IS_ERR(bridge)) 661 return PTR_ERR(bridge); 662 } 663 664 br_port = prestera_bridge_port_add(bridge, port->dev); 665 if (IS_ERR(br_port)) { 666 prestera_bridge_put(bridge); 667 return PTR_ERR(br_port); 668 } 669 670 err = switchdev_bridge_port_offload(br_port->dev, port->dev, NULL, 671 NULL, NULL, false, extack); 672 if (err) 673 goto err_switchdev_offload; 674 675 if (bridge->vlan_enabled) 676 return 0; 677 678 err = prestera_bridge_1d_port_join(br_port); 679 if (err) 680 goto err_port_join; 681 682 return 0; 683 684err_port_join: 685 switchdev_bridge_port_unoffload(br_port->dev, NULL, NULL, NULL); 686err_switchdev_offload: 687 prestera_bridge_port_put(br_port); 688 return err; 689} 690 691static void prestera_bridge_1q_port_leave(struct prestera_bridge_port *br_port) 692{ 693 struct prestera_port *port = netdev_priv(br_port->dev); 694 695 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL); 696 prestera_port_pvid_set(port, PRESTERA_DEFAULT_VID); 697} 698 699static void prestera_bridge_1d_port_leave(struct prestera_bridge_port *br_port) 700{ 701 struct prestera_port *port = netdev_priv(br_port->dev); 702 703 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL); 704 prestera_hw_bridge_port_delete(port, br_port->bridge->bridge_id); 705} 706 707static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid, 708 u8 state) 709{ 710 u8 hw_state = state; 711 712 switch (state) { 713 case BR_STATE_DISABLED: 714 hw_state = PRESTERA_STP_DISABLED; 715 break; 716 717 case BR_STATE_BLOCKING: 718 case BR_STATE_LISTENING: 719 hw_state = PRESTERA_STP_BLOCK_LISTEN; 720 break; 721 722 case BR_STATE_LEARNING: 723 hw_state = PRESTERA_STP_LEARN; 724 break; 725 726 case BR_STATE_FORWARDING: 727 hw_state = PRESTERA_STP_FORWARD; 728 break; 729 730 default: 731 return -EINVAL; 732 } 733 734 return prestera_hw_vlan_port_stp_set(port, vid, hw_state); 735} 736 737void prestera_bridge_port_leave(struct net_device *br_dev, 738 struct prestera_port *port) 739{ 740 struct prestera_switchdev *swdev = port->sw->swdev; 741 struct prestera_bridge_port *br_port; 742 struct prestera_bridge *bridge; 743 744 bridge = prestera_bridge_by_dev(swdev, br_dev); 745 if (!bridge) 746 return; 747 748 br_port = __prestera_bridge_port_by_dev(bridge, port->dev); 749 if (!br_port) 750 return; 751 752 bridge = br_port->bridge; 753 754 if (bridge->vlan_enabled) 755 prestera_bridge_1q_port_leave(br_port); 756 else 757 prestera_bridge_1d_port_leave(br_port); 758 759 switchdev_bridge_port_unoffload(br_port->dev, NULL, NULL, NULL); 760 761 prestera_mdb_flush_bridge_port(br_port); 762 763 prestera_br_port_flags_reset(br_port, port); 764 prestera_port_vid_stp_set(port, PRESTERA_VID_ALL, BR_STATE_FORWARDING); 765 prestera_bridge_port_put(br_port); 766} 767 768static int prestera_port_attr_br_flags_set(struct prestera_port *port, 769 struct net_device *dev, 770 struct switchdev_brport_flags flags) 771{ 772 struct prestera_bridge_port *br_port; 773 774 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 775 if (!br_port) 776 return 0; 777 778 br_port->flags &= ~flags.mask; 779 br_port->flags |= flags.val & flags.mask; 780 return prestera_br_port_flags_set(br_port, port); 781} 782 783static int prestera_port_attr_br_ageing_set(struct prestera_port *port, 784 unsigned long ageing_clock_t) 785{ 786 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); 787 u32 ageing_time_ms = jiffies_to_msecs(ageing_jiffies); 788 struct prestera_switch *sw = port->sw; 789 790 if (ageing_time_ms < PRESTERA_MIN_AGEING_TIME_MS || 791 ageing_time_ms > PRESTERA_MAX_AGEING_TIME_MS) 792 return -ERANGE; 793 794 return prestera_hw_switch_ageing_set(sw, ageing_time_ms); 795} 796 797static int prestera_port_attr_br_vlan_set(struct prestera_port *port, 798 struct net_device *dev, 799 bool vlan_enabled) 800{ 801 struct prestera_switch *sw = port->sw; 802 struct prestera_bridge *bridge; 803 804 bridge = prestera_bridge_by_dev(sw->swdev, dev); 805 if (WARN_ON(!bridge)) 806 return -EINVAL; 807 808 if (bridge->vlan_enabled == vlan_enabled) 809 return 0; 810 811 netdev_err(bridge->dev, "VLAN filtering can't be changed for existing bridge\n"); 812 813 return -EINVAL; 814} 815 816static int prestera_port_bridge_vlan_stp_set(struct prestera_port *port, 817 struct prestera_bridge_vlan *br_vlan, 818 u8 state) 819{ 820 struct prestera_port_vlan *port_vlan; 821 822 list_for_each_entry(port_vlan, &br_vlan->port_vlan_list, br_vlan_head) { 823 if (port_vlan->port != port) 824 continue; 825 826 return prestera_port_vid_stp_set(port, br_vlan->vid, state); 827 } 828 829 return 0; 830} 831 832static int prestera_port_attr_stp_state_set(struct prestera_port *port, 833 struct net_device *dev, 834 u8 state) 835{ 836 struct prestera_bridge_port *br_port; 837 struct prestera_bridge_vlan *br_vlan; 838 int err; 839 u16 vid; 840 841 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 842 if (!br_port) 843 return 0; 844 845 if (!br_port->bridge->vlan_enabled) { 846 vid = br_port->bridge->bridge_id; 847 err = prestera_port_vid_stp_set(port, vid, state); 848 if (err) 849 goto err_port_stp_set; 850 } else { 851 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 852 err = prestera_port_bridge_vlan_stp_set(port, br_vlan, 853 state); 854 if (err) 855 goto err_port_vlan_stp_set; 856 } 857 } 858 859 br_port->stp_state = state; 860 861 return 0; 862 863err_port_vlan_stp_set: 864 list_for_each_entry_continue_reverse(br_vlan, &br_port->vlan_list, head) 865 prestera_port_bridge_vlan_stp_set(port, br_vlan, br_port->stp_state); 866 return err; 867 868err_port_stp_set: 869 prestera_port_vid_stp_set(port, vid, br_port->stp_state); 870 871 return err; 872} 873 874static int 875prestera_br_port_lag_mdb_mc_enable_sync(struct prestera_bridge_port *br_port, 876 bool enabled) 877{ 878 struct prestera_port *pr_port; 879 struct prestera_switch *sw; 880 u16 lag_id; 881 int err; 882 883 pr_port = prestera_port_dev_lower_find(br_port->dev); 884 if (!pr_port) 885 return 0; 886 887 sw = pr_port->sw; 888 err = prestera_lag_id(sw, br_port->dev, &lag_id); 889 if (err) 890 return err; 891 892 list_for_each_entry(pr_port, &sw->port_list, list) { 893 if (pr_port->lag->lag_id == lag_id) { 894 err = prestera_port_mc_flood_set(pr_port, enabled); 895 if (err) 896 return err; 897 } 898 } 899 900 return 0; 901} 902 903static int prestera_br_mdb_mc_enable_sync(struct prestera_bridge *br_dev) 904{ 905 struct prestera_bridge_port *br_port; 906 struct prestera_port *port; 907 bool enabled; 908 int err; 909 910 /* if mrouter exists: 911 * - make sure every mrouter receives unreg mcast traffic; 912 * if mrouter doesn't exists: 913 * - make sure every port receives unreg mcast traffic; 914 */ 915 list_for_each_entry(br_port, &br_dev->port_list, head) { 916 if (br_dev->multicast_enabled && br_dev->mrouter_exist) 917 enabled = br_port->mrouter; 918 else 919 enabled = br_port->flags & BR_MCAST_FLOOD; 920 921 if (netif_is_lag_master(br_port->dev)) { 922 err = prestera_br_port_lag_mdb_mc_enable_sync(br_port, 923 enabled); 924 if (err) 925 return err; 926 continue; 927 } 928 929 port = prestera_port_dev_lower_find(br_port->dev); 930 if (!port) 931 continue; 932 933 err = prestera_port_mc_flood_set(port, enabled); 934 if (err) 935 return err; 936 } 937 938 return 0; 939} 940 941static bool 942prestera_br_mdb_port_is_member(struct prestera_br_mdb_entry *br_mdb, 943 struct net_device *orig_dev) 944{ 945 struct prestera_br_mdb_port *tmp_port; 946 947 list_for_each_entry(tmp_port, &br_mdb->br_mdb_port_list, 948 br_mdb_port_node) 949 if (tmp_port->br_port->dev == orig_dev) 950 return true; 951 952 return false; 953} 954 955static int 956prestera_mdb_port_add(struct prestera_mdb_entry *mdb, 957 struct net_device *orig_dev, 958 const unsigned char addr[ETH_ALEN], u16 vid) 959{ 960 struct prestera_flood_domain *flood_domain = mdb->flood_domain; 961 int err; 962 963 if (!prestera_flood_domain_port_find(flood_domain, 964 orig_dev, vid)) { 965 err = prestera_flood_domain_port_create(flood_domain, orig_dev, 966 vid); 967 if (err) 968 return err; 969 } 970 971 return 0; 972} 973 974/* Sync bridge mdb (software table) with HW table (if MC is enabled). */ 975static int prestera_br_mdb_sync(struct prestera_bridge *br_dev) 976{ 977 struct prestera_br_mdb_port *br_mdb_port; 978 struct prestera_bridge_port *br_port; 979 struct prestera_br_mdb_entry *br_mdb; 980 struct prestera_mdb_entry *mdb; 981 struct prestera_port *pr_port; 982 int err = 0; 983 984 if (!br_dev->multicast_enabled) 985 return 0; 986 987 list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list, 988 br_mdb_entry_node) { 989 mdb = br_mdb->mdb; 990 /* Make sure every port that explicitly been added to the mdb 991 * joins the specified group. 992 */ 993 list_for_each_entry(br_mdb_port, &br_mdb->br_mdb_port_list, 994 br_mdb_port_node) { 995 br_port = br_mdb_port->br_port; 996 pr_port = prestera_port_dev_lower_find(br_port->dev); 997 998 /* Match only mdb and br_mdb ports that belong to the 999 * same broadcast domain. 1000 */ 1001 if (br_dev->vlan_enabled && 1002 !prestera_port_vlan_by_vid(pr_port, 1003 mdb->vid)) 1004 continue; 1005 1006 /* If port is not in MDB or there's no Mrouter 1007 * clear HW mdb. 1008 */ 1009 if (prestera_br_mdb_port_is_member(br_mdb, 1010 br_mdb_port->br_port->dev) && 1011 br_dev->mrouter_exist) 1012 err = prestera_mdb_port_add(mdb, br_port->dev, 1013 mdb->addr, 1014 mdb->vid); 1015 else 1016 prestera_mdb_port_del(mdb, br_port->dev); 1017 1018 if (err) 1019 return err; 1020 } 1021 1022 /* Make sure that every mrouter port joins every MC group int 1023 * broadcast domain. If it's not an mrouter - it should leave 1024 */ 1025 list_for_each_entry(br_port, &br_dev->port_list, head) { 1026 pr_port = prestera_port_dev_lower_find(br_port->dev); 1027 1028 /* Make sure mrouter woudln't receive traffci from 1029 * another broadcast domain (e.g. from a vlan, which 1030 * mrouter port is not a member of). 1031 */ 1032 if (br_dev->vlan_enabled && 1033 !prestera_port_vlan_by_vid(pr_port, 1034 mdb->vid)) 1035 continue; 1036 1037 if (br_port->mrouter) { 1038 err = prestera_mdb_port_add(mdb, br_port->dev, 1039 mdb->addr, 1040 mdb->vid); 1041 if (err) 1042 return err; 1043 } else if (!br_port->mrouter && 1044 !prestera_br_mdb_port_is_member 1045 (br_mdb, br_port->dev)) { 1046 prestera_mdb_port_del(mdb, br_port->dev); 1047 } 1048 } 1049 } 1050 1051 return 0; 1052} 1053 1054static int 1055prestera_mdb_enable_set(struct prestera_br_mdb_entry *br_mdb, bool enable) 1056{ 1057 int err; 1058 1059 if (enable != br_mdb->enabled) { 1060 if (enable) 1061 err = prestera_hw_mdb_create(br_mdb->mdb); 1062 else 1063 err = prestera_hw_mdb_destroy(br_mdb->mdb); 1064 1065 if (err) 1066 return err; 1067 1068 br_mdb->enabled = enable; 1069 } 1070 1071 return 0; 1072} 1073 1074static int 1075prestera_br_mdb_enable_set(struct prestera_bridge *br_dev, bool enable) 1076{ 1077 struct prestera_br_mdb_entry *br_mdb; 1078 int err; 1079 1080 list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list, 1081 br_mdb_entry_node) { 1082 err = prestera_mdb_enable_set(br_mdb, enable); 1083 if (err) 1084 return err; 1085 } 1086 1087 return 0; 1088} 1089 1090static int prestera_port_attr_br_mc_disabled_set(struct prestera_port *port, 1091 struct net_device *orig_dev, 1092 bool mc_disabled) 1093{ 1094 struct prestera_switch *sw = port->sw; 1095 struct prestera_bridge *br_dev; 1096 1097 br_dev = prestera_bridge_find(sw, orig_dev); 1098 if (!br_dev) 1099 return 0; 1100 1101 br_dev->multicast_enabled = !mc_disabled; 1102 1103 /* There's no point in enabling mdb back if router is missing. */ 1104 WARN_ON(prestera_br_mdb_enable_set(br_dev, br_dev->multicast_enabled && 1105 br_dev->mrouter_exist)); 1106 1107 WARN_ON(prestera_br_mdb_sync(br_dev)); 1108 1109 WARN_ON(prestera_br_mdb_mc_enable_sync(br_dev)); 1110 1111 return 0; 1112} 1113 1114static bool 1115prestera_bridge_mdb_mc_mrouter_exists(struct prestera_bridge *br_dev) 1116{ 1117 struct prestera_bridge_port *br_port; 1118 1119 list_for_each_entry(br_port, &br_dev->port_list, head) 1120 if (br_port->mrouter) 1121 return true; 1122 1123 return false; 1124} 1125 1126static int 1127prestera_port_attr_mrouter_set(struct prestera_port *port, 1128 struct net_device *orig_dev, 1129 bool is_port_mrouter) 1130{ 1131 struct prestera_bridge_port *br_port; 1132 struct prestera_bridge *br_dev; 1133 1134 br_port = prestera_bridge_port_find(port->sw, orig_dev); 1135 if (!br_port) 1136 return 0; 1137 1138 br_dev = br_port->bridge; 1139 br_port->mrouter = is_port_mrouter; 1140 1141 br_dev->mrouter_exist = prestera_bridge_mdb_mc_mrouter_exists(br_dev); 1142 1143 /* Enable MDB processing if both mrouter exists and mc is enabled. 1144 * In case if MC enabled, but there is no mrouter, device would flood 1145 * all multicast traffic (even if MDB table is not empty) with the use 1146 * of bridge's flood capabilities (without the use of flood_domain). 1147 */ 1148 WARN_ON(prestera_br_mdb_enable_set(br_dev, br_dev->multicast_enabled && 1149 br_dev->mrouter_exist)); 1150 1151 WARN_ON(prestera_br_mdb_sync(br_dev)); 1152 1153 WARN_ON(prestera_br_mdb_mc_enable_sync(br_dev)); 1154 1155 return 0; 1156} 1157 1158static int prestera_port_obj_attr_set(struct net_device *dev, const void *ctx, 1159 const struct switchdev_attr *attr, 1160 struct netlink_ext_ack *extack) 1161{ 1162 struct prestera_port *port = netdev_priv(dev); 1163 int err = 0; 1164 1165 switch (attr->id) { 1166 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 1167 err = prestera_port_attr_stp_state_set(port, attr->orig_dev, 1168 attr->u.stp_state); 1169 break; 1170 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 1171 if (attr->u.brport_flags.mask & 1172 ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_PORT_LOCKED)) 1173 err = -EINVAL; 1174 break; 1175 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 1176 err = prestera_port_attr_br_flags_set(port, attr->orig_dev, 1177 attr->u.brport_flags); 1178 break; 1179 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 1180 err = prestera_port_attr_br_ageing_set(port, 1181 attr->u.ageing_time); 1182 break; 1183 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 1184 err = prestera_port_attr_br_vlan_set(port, attr->orig_dev, 1185 attr->u.vlan_filtering); 1186 break; 1187 case SWITCHDEV_ATTR_ID_PORT_MROUTER: 1188 err = prestera_port_attr_mrouter_set(port, attr->orig_dev, 1189 attr->u.mrouter); 1190 break; 1191 case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED: 1192 err = prestera_port_attr_br_mc_disabled_set(port, attr->orig_dev, 1193 attr->u.mc_disabled); 1194 break; 1195 default: 1196 err = -EOPNOTSUPP; 1197 } 1198 1199 return err; 1200} 1201 1202static void 1203prestera_fdb_offload_notify(struct prestera_port *port, 1204 struct switchdev_notifier_fdb_info *info) 1205{ 1206 struct switchdev_notifier_fdb_info send_info = {}; 1207 1208 send_info.addr = info->addr; 1209 send_info.vid = info->vid; 1210 send_info.offloaded = true; 1211 1212 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, port->dev, 1213 &send_info.info, NULL); 1214} 1215 1216static int prestera_port_fdb_set(struct prestera_port *port, 1217 struct switchdev_notifier_fdb_info *fdb_info, 1218 bool adding) 1219{ 1220 struct prestera_switch *sw = port->sw; 1221 struct prestera_bridge_port *br_port; 1222 struct prestera_bridge *bridge; 1223 int err; 1224 u16 vid; 1225 1226 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev); 1227 if (!br_port) 1228 return -EINVAL; 1229 1230 bridge = br_port->bridge; 1231 1232 if (bridge->vlan_enabled) 1233 vid = fdb_info->vid; 1234 else 1235 vid = bridge->bridge_id; 1236 1237 if (adding) 1238 err = prestera_fdb_add(port, fdb_info->addr, vid, false); 1239 else 1240 err = prestera_fdb_del(port, fdb_info->addr, vid); 1241 1242 return err; 1243} 1244 1245static void prestera_fdb_event_work(struct work_struct *work) 1246{ 1247 struct switchdev_notifier_fdb_info *fdb_info; 1248 struct prestera_fdb_event_work *swdev_work; 1249 struct prestera_port *port; 1250 struct net_device *dev; 1251 int err; 1252 1253 swdev_work = container_of(work, struct prestera_fdb_event_work, work); 1254 dev = swdev_work->dev; 1255 1256 rtnl_lock(); 1257 1258 port = prestera_port_dev_lower_find(dev); 1259 if (!port) 1260 goto out_unlock; 1261 1262 switch (swdev_work->event) { 1263 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1264 fdb_info = &swdev_work->fdb_info; 1265 if (!fdb_info->added_by_user || fdb_info->is_local) 1266 break; 1267 1268 err = prestera_port_fdb_set(port, fdb_info, true); 1269 if (err) 1270 break; 1271 1272 prestera_fdb_offload_notify(port, fdb_info); 1273 break; 1274 1275 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1276 fdb_info = &swdev_work->fdb_info; 1277 prestera_port_fdb_set(port, fdb_info, false); 1278 break; 1279 } 1280 1281out_unlock: 1282 rtnl_unlock(); 1283 1284 kfree(swdev_work->fdb_info.addr); 1285 kfree(swdev_work); 1286 dev_put(dev); 1287} 1288 1289static int prestera_switchdev_event(struct notifier_block *unused, 1290 unsigned long event, void *ptr) 1291{ 1292 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1293 struct switchdev_notifier_fdb_info *fdb_info; 1294 struct switchdev_notifier_info *info = ptr; 1295 struct prestera_fdb_event_work *swdev_work; 1296 struct net_device *upper; 1297 int err; 1298 1299 if (event == SWITCHDEV_PORT_ATTR_SET) { 1300 err = switchdev_handle_port_attr_set(dev, ptr, 1301 prestera_netdev_check, 1302 prestera_port_obj_attr_set); 1303 return notifier_from_errno(err); 1304 } 1305 1306 if (!prestera_netdev_check(dev)) 1307 return NOTIFY_DONE; 1308 1309 upper = netdev_master_upper_dev_get_rcu(dev); 1310 if (!upper) 1311 return NOTIFY_DONE; 1312 1313 if (!netif_is_bridge_master(upper)) 1314 return NOTIFY_DONE; 1315 1316 swdev_work = kzalloc(sizeof(*swdev_work), GFP_ATOMIC); 1317 if (!swdev_work) 1318 return NOTIFY_BAD; 1319 1320 swdev_work->event = event; 1321 swdev_work->dev = dev; 1322 1323 switch (event) { 1324 case SWITCHDEV_FDB_ADD_TO_DEVICE: 1325 case SWITCHDEV_FDB_DEL_TO_DEVICE: 1326 fdb_info = container_of(info, 1327 struct switchdev_notifier_fdb_info, 1328 info); 1329 1330 INIT_WORK(&swdev_work->work, prestera_fdb_event_work); 1331 memcpy(&swdev_work->fdb_info, ptr, 1332 sizeof(swdev_work->fdb_info)); 1333 1334 swdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 1335 if (!swdev_work->fdb_info.addr) 1336 goto out_bad; 1337 1338 ether_addr_copy((u8 *)swdev_work->fdb_info.addr, 1339 fdb_info->addr); 1340 dev_hold(dev); 1341 break; 1342 1343 default: 1344 kfree(swdev_work); 1345 return NOTIFY_DONE; 1346 } 1347 1348 queue_work(swdev_wq, &swdev_work->work); 1349 return NOTIFY_DONE; 1350 1351out_bad: 1352 kfree(swdev_work); 1353 return NOTIFY_BAD; 1354} 1355 1356static int 1357prestera_port_vlan_bridge_join(struct prestera_port_vlan *port_vlan, 1358 struct prestera_bridge_port *br_port) 1359{ 1360 struct prestera_port *port = port_vlan->port; 1361 struct prestera_bridge_vlan *br_vlan; 1362 u16 vid = port_vlan->vid; 1363 int err; 1364 1365 if (port_vlan->br_port) 1366 return 0; 1367 1368 err = prestera_br_port_flags_set(br_port, port); 1369 if (err) 1370 goto err_flags2port_set; 1371 1372 err = prestera_port_vid_stp_set(port, vid, br_port->stp_state); 1373 if (err) 1374 goto err_port_vid_stp_set; 1375 1376 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid); 1377 if (!br_vlan) { 1378 br_vlan = prestera_bridge_vlan_create(br_port, vid); 1379 if (!br_vlan) { 1380 err = -ENOMEM; 1381 goto err_bridge_vlan_get; 1382 } 1383 } 1384 1385 list_add(&port_vlan->br_vlan_head, &br_vlan->port_vlan_list); 1386 1387 prestera_bridge_port_get(br_port); 1388 port_vlan->br_port = br_port; 1389 1390 return 0; 1391 1392err_bridge_vlan_get: 1393 prestera_port_vid_stp_set(port, vid, BR_STATE_FORWARDING); 1394err_port_vid_stp_set: 1395 prestera_br_port_flags_reset(br_port, port); 1396err_flags2port_set: 1397 return err; 1398} 1399 1400static int 1401prestera_bridge_port_vlan_add(struct prestera_port *port, 1402 struct prestera_bridge_port *br_port, 1403 u16 vid, bool is_untagged, bool is_pvid, 1404 struct netlink_ext_ack *extack) 1405{ 1406 struct prestera_port_vlan *port_vlan; 1407 u16 old_pvid = port->pvid; 1408 u16 pvid; 1409 int err; 1410 1411 if (is_pvid) 1412 pvid = vid; 1413 else 1414 pvid = port->pvid == vid ? 0 : port->pvid; 1415 1416 port_vlan = prestera_port_vlan_by_vid(port, vid); 1417 if (port_vlan && port_vlan->br_port != br_port) 1418 return -EEXIST; 1419 1420 if (!port_vlan) { 1421 port_vlan = prestera_port_vlan_create(port, vid, is_untagged); 1422 if (IS_ERR(port_vlan)) 1423 return PTR_ERR(port_vlan); 1424 } else { 1425 err = prestera_hw_vlan_port_set(port, vid, true, is_untagged); 1426 if (err) 1427 goto err_port_vlan_set; 1428 } 1429 1430 err = prestera_port_pvid_set(port, pvid); 1431 if (err) 1432 goto err_port_pvid_set; 1433 1434 err = prestera_port_vlan_bridge_join(port_vlan, br_port); 1435 if (err) 1436 goto err_port_vlan_bridge_join; 1437 1438 return 0; 1439 1440err_port_vlan_bridge_join: 1441 prestera_port_pvid_set(port, old_pvid); 1442err_port_pvid_set: 1443 prestera_hw_vlan_port_set(port, vid, false, false); 1444err_port_vlan_set: 1445 prestera_port_vlan_destroy(port_vlan); 1446 1447 return err; 1448} 1449 1450static void 1451prestera_bridge_port_vlan_del(struct prestera_port *port, 1452 struct prestera_bridge_port *br_port, u16 vid) 1453{ 1454 u16 pvid = port->pvid == vid ? 0 : port->pvid; 1455 struct prestera_port_vlan *port_vlan; 1456 1457 port_vlan = prestera_port_vlan_by_vid(port, vid); 1458 if (WARN_ON(!port_vlan)) 1459 return; 1460 1461 prestera_port_vlan_bridge_leave(port_vlan); 1462 prestera_port_pvid_set(port, pvid); 1463 prestera_port_vlan_destroy(port_vlan); 1464} 1465 1466static int prestera_port_vlans_add(struct prestera_port *port, 1467 const struct switchdev_obj_port_vlan *vlan, 1468 struct netlink_ext_ack *extack) 1469{ 1470 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 1471 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; 1472 struct net_device *orig_dev = vlan->obj.orig_dev; 1473 struct prestera_bridge_port *br_port; 1474 struct prestera_switch *sw = port->sw; 1475 struct prestera_bridge *bridge; 1476 1477 if (netif_is_bridge_master(orig_dev)) 1478 return 0; 1479 1480 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev); 1481 if (WARN_ON(!br_port)) 1482 return -EINVAL; 1483 1484 bridge = br_port->bridge; 1485 if (!bridge->vlan_enabled) 1486 return 0; 1487 1488 return prestera_bridge_port_vlan_add(port, br_port, 1489 vlan->vid, flag_untagged, 1490 flag_pvid, extack); 1491} 1492 1493static struct prestera_br_mdb_entry * 1494prestera_br_mdb_entry_create(struct prestera_switch *sw, 1495 struct prestera_bridge *br_dev, 1496 const unsigned char *addr, u16 vid) 1497{ 1498 struct prestera_br_mdb_entry *br_mdb_entry; 1499 struct prestera_mdb_entry *mdb_entry; 1500 1501 br_mdb_entry = kzalloc(sizeof(*br_mdb_entry), GFP_KERNEL); 1502 if (!br_mdb_entry) 1503 return NULL; 1504 1505 mdb_entry = prestera_mdb_entry_create(sw, addr, vid); 1506 if (!mdb_entry) 1507 goto err_mdb_alloc; 1508 1509 br_mdb_entry->mdb = mdb_entry; 1510 br_mdb_entry->bridge = br_dev; 1511 br_mdb_entry->enabled = true; 1512 INIT_LIST_HEAD(&br_mdb_entry->br_mdb_port_list); 1513 1514 list_add(&br_mdb_entry->br_mdb_entry_node, &br_dev->br_mdb_entry_list); 1515 1516 return br_mdb_entry; 1517 1518err_mdb_alloc: 1519 kfree(br_mdb_entry); 1520 return NULL; 1521} 1522 1523static int prestera_br_mdb_port_add(struct prestera_br_mdb_entry *br_mdb, 1524 struct prestera_bridge_port *br_port) 1525{ 1526 struct prestera_br_mdb_port *br_mdb_port; 1527 1528 list_for_each_entry(br_mdb_port, &br_mdb->br_mdb_port_list, 1529 br_mdb_port_node) 1530 if (br_mdb_port->br_port == br_port) 1531 return 0; 1532 1533 br_mdb_port = kzalloc(sizeof(*br_mdb_port), GFP_KERNEL); 1534 if (!br_mdb_port) 1535 return -ENOMEM; 1536 1537 br_mdb_port->br_port = br_port; 1538 list_add(&br_mdb_port->br_mdb_port_node, 1539 &br_mdb->br_mdb_port_list); 1540 1541 return 0; 1542} 1543 1544static struct prestera_br_mdb_entry * 1545prestera_br_mdb_entry_find(struct prestera_bridge *br_dev, 1546 const unsigned char *addr, u16 vid) 1547{ 1548 struct prestera_br_mdb_entry *br_mdb; 1549 1550 list_for_each_entry(br_mdb, &br_dev->br_mdb_entry_list, 1551 br_mdb_entry_node) 1552 if (ether_addr_equal(&br_mdb->mdb->addr[0], addr) && 1553 vid == br_mdb->mdb->vid) 1554 return br_mdb; 1555 1556 return NULL; 1557} 1558 1559static struct prestera_br_mdb_entry * 1560prestera_br_mdb_entry_get(struct prestera_switch *sw, 1561 struct prestera_bridge *br_dev, 1562 const unsigned char *addr, u16 vid) 1563{ 1564 struct prestera_br_mdb_entry *br_mdb; 1565 1566 br_mdb = prestera_br_mdb_entry_find(br_dev, addr, vid); 1567 if (br_mdb) 1568 return br_mdb; 1569 1570 return prestera_br_mdb_entry_create(sw, br_dev, addr, vid); 1571} 1572 1573static int 1574prestera_mdb_port_addr_obj_add(const struct switchdev_obj_port_mdb *mdb) 1575{ 1576 struct prestera_br_mdb_entry *br_mdb; 1577 struct prestera_bridge_port *br_port; 1578 struct prestera_bridge *br_dev; 1579 struct prestera_switch *sw; 1580 struct prestera_port *port; 1581 int err; 1582 1583 sw = prestera_switch_get(mdb->obj.orig_dev); 1584 port = prestera_port_dev_lower_find(mdb->obj.orig_dev); 1585 1586 br_port = prestera_bridge_port_find(sw, mdb->obj.orig_dev); 1587 if (!br_port) 1588 return 0; 1589 1590 br_dev = br_port->bridge; 1591 1592 if (mdb->vid && !prestera_port_vlan_by_vid(port, mdb->vid)) 1593 return 0; 1594 1595 if (mdb->vid) 1596 br_mdb = prestera_br_mdb_entry_get(sw, br_dev, &mdb->addr[0], 1597 mdb->vid); 1598 else 1599 br_mdb = prestera_br_mdb_entry_get(sw, br_dev, &mdb->addr[0], 1600 br_dev->bridge_id); 1601 1602 if (!br_mdb) 1603 return -ENOMEM; 1604 1605 /* Make sure newly allocated MDB entry gets disabled if either MC is 1606 * disabled, or the mrouter does not exist. 1607 */ 1608 WARN_ON(prestera_mdb_enable_set(br_mdb, br_dev->multicast_enabled && 1609 br_dev->mrouter_exist)); 1610 1611 err = prestera_br_mdb_port_add(br_mdb, br_port); 1612 if (err) { 1613 prestera_br_mdb_entry_put(br_mdb); 1614 return err; 1615 } 1616 1617 err = prestera_br_mdb_sync(br_dev); 1618 if (err) 1619 return err; 1620 1621 return 0; 1622} 1623 1624static int prestera_port_obj_add(struct net_device *dev, const void *ctx, 1625 const struct switchdev_obj *obj, 1626 struct netlink_ext_ack *extack) 1627{ 1628 struct prestera_port *port = netdev_priv(dev); 1629 const struct switchdev_obj_port_vlan *vlan; 1630 const struct switchdev_obj_port_mdb *mdb; 1631 int err = 0; 1632 1633 switch (obj->id) { 1634 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1635 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 1636 return prestera_port_vlans_add(port, vlan, extack); 1637 case SWITCHDEV_OBJ_ID_PORT_MDB: 1638 mdb = SWITCHDEV_OBJ_PORT_MDB(obj); 1639 err = prestera_mdb_port_addr_obj_add(mdb); 1640 break; 1641 case SWITCHDEV_OBJ_ID_HOST_MDB: 1642 fallthrough; 1643 default: 1644 err = -EOPNOTSUPP; 1645 break; 1646 } 1647 1648 return err; 1649} 1650 1651static int prestera_port_vlans_del(struct prestera_port *port, 1652 const struct switchdev_obj_port_vlan *vlan) 1653{ 1654 struct net_device *orig_dev = vlan->obj.orig_dev; 1655 struct prestera_bridge_port *br_port; 1656 struct prestera_switch *sw = port->sw; 1657 1658 if (netif_is_bridge_master(orig_dev)) 1659 return -EOPNOTSUPP; 1660 1661 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev); 1662 if (WARN_ON(!br_port)) 1663 return -EINVAL; 1664 1665 if (!br_port->bridge->vlan_enabled) 1666 return 0; 1667 1668 prestera_bridge_port_vlan_del(port, br_port, vlan->vid); 1669 1670 return 0; 1671} 1672 1673static int 1674prestera_mdb_port_addr_obj_del(struct prestera_port *port, 1675 const struct switchdev_obj_port_mdb *mdb) 1676{ 1677 struct prestera_br_mdb_entry *br_mdb; 1678 struct prestera_bridge_port *br_port; 1679 struct prestera_bridge *br_dev; 1680 int err; 1681 1682 /* Bridge port no longer exists - and so does this MDB entry */ 1683 br_port = prestera_bridge_port_find(port->sw, mdb->obj.orig_dev); 1684 if (!br_port) 1685 return 0; 1686 1687 /* Removing MDB with non-existing VLAN - not supported; */ 1688 if (mdb->vid && !prestera_port_vlan_by_vid(port, mdb->vid)) 1689 return 0; 1690 1691 br_dev = br_port->bridge; 1692 1693 if (br_port->bridge->vlan_enabled) 1694 br_mdb = prestera_br_mdb_entry_find(br_dev, &mdb->addr[0], 1695 mdb->vid); 1696 else 1697 br_mdb = prestera_br_mdb_entry_find(br_dev, &mdb->addr[0], 1698 br_port->bridge->bridge_id); 1699 1700 if (!br_mdb) 1701 return 0; 1702 1703 /* Since there might be a situation that this port was the last in the 1704 * MDB group, we have to both remove this port from software and HW MDB, 1705 * sync MDB table, and then destroy software MDB (if needed). 1706 */ 1707 prestera_br_mdb_port_del(br_mdb, br_port); 1708 1709 prestera_br_mdb_entry_put(br_mdb); 1710 1711 err = prestera_br_mdb_sync(br_dev); 1712 if (err) 1713 return err; 1714 1715 return 0; 1716} 1717 1718static int prestera_port_obj_del(struct net_device *dev, const void *ctx, 1719 const struct switchdev_obj *obj) 1720{ 1721 struct prestera_port *port = netdev_priv(dev); 1722 const struct switchdev_obj_port_mdb *mdb; 1723 int err = 0; 1724 1725 switch (obj->id) { 1726 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1727 return prestera_port_vlans_del(port, SWITCHDEV_OBJ_PORT_VLAN(obj)); 1728 case SWITCHDEV_OBJ_ID_PORT_MDB: 1729 mdb = SWITCHDEV_OBJ_PORT_MDB(obj); 1730 err = prestera_mdb_port_addr_obj_del(port, mdb); 1731 break; 1732 default: 1733 err = -EOPNOTSUPP; 1734 break; 1735 } 1736 1737 return err; 1738} 1739 1740static int prestera_switchdev_blk_event(struct notifier_block *unused, 1741 unsigned long event, void *ptr) 1742{ 1743 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1744 int err; 1745 1746 switch (event) { 1747 case SWITCHDEV_PORT_OBJ_ADD: 1748 err = switchdev_handle_port_obj_add(dev, ptr, 1749 prestera_netdev_check, 1750 prestera_port_obj_add); 1751 break; 1752 case SWITCHDEV_PORT_OBJ_DEL: 1753 err = switchdev_handle_port_obj_del(dev, ptr, 1754 prestera_netdev_check, 1755 prestera_port_obj_del); 1756 break; 1757 case SWITCHDEV_PORT_ATTR_SET: 1758 err = switchdev_handle_port_attr_set(dev, ptr, 1759 prestera_netdev_check, 1760 prestera_port_obj_attr_set); 1761 break; 1762 default: 1763 return NOTIFY_DONE; 1764 } 1765 1766 return notifier_from_errno(err); 1767} 1768 1769static void prestera_fdb_event(struct prestera_switch *sw, 1770 struct prestera_event *evt, void *arg) 1771{ 1772 struct switchdev_notifier_fdb_info info = {}; 1773 struct net_device *dev = NULL; 1774 struct prestera_port *port; 1775 struct prestera_lag *lag; 1776 1777 switch (evt->fdb_evt.type) { 1778 case PRESTERA_FDB_ENTRY_TYPE_REG_PORT: 1779 port = prestera_find_port(sw, evt->fdb_evt.dest.port_id); 1780 if (port) 1781 dev = port->dev; 1782 break; 1783 case PRESTERA_FDB_ENTRY_TYPE_LAG: 1784 lag = prestera_lag_by_id(sw, evt->fdb_evt.dest.lag_id); 1785 if (lag) 1786 dev = lag->dev; 1787 break; 1788 default: 1789 return; 1790 } 1791 1792 if (!dev) 1793 return; 1794 1795 info.addr = evt->fdb_evt.data.mac; 1796 info.vid = evt->fdb_evt.vid; 1797 info.offloaded = true; 1798 1799 rtnl_lock(); 1800 1801 switch (evt->id) { 1802 case PRESTERA_FDB_EVENT_LEARNED: 1803 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE, 1804 dev, &info.info, NULL); 1805 break; 1806 case PRESTERA_FDB_EVENT_AGED: 1807 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, 1808 dev, &info.info, NULL); 1809 break; 1810 } 1811 1812 rtnl_unlock(); 1813} 1814 1815static int prestera_fdb_init(struct prestera_switch *sw) 1816{ 1817 int err; 1818 1819 err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_FDB, 1820 prestera_fdb_event, NULL); 1821 if (err) 1822 return err; 1823 1824 err = prestera_hw_switch_ageing_set(sw, PRESTERA_DEFAULT_AGEING_TIME_MS); 1825 if (err) 1826 goto err_ageing_set; 1827 1828 return 0; 1829 1830err_ageing_set: 1831 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1832 prestera_fdb_event); 1833 return err; 1834} 1835 1836static void prestera_fdb_fini(struct prestera_switch *sw) 1837{ 1838 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1839 prestera_fdb_event); 1840} 1841 1842static int prestera_switchdev_handler_init(struct prestera_switchdev *swdev) 1843{ 1844 int err; 1845 1846 swdev->swdev_nb.notifier_call = prestera_switchdev_event; 1847 err = register_switchdev_notifier(&swdev->swdev_nb); 1848 if (err) 1849 goto err_register_swdev_notifier; 1850 1851 swdev->swdev_nb_blk.notifier_call = prestera_switchdev_blk_event; 1852 err = register_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1853 if (err) 1854 goto err_register_blk_swdev_notifier; 1855 1856 return 0; 1857 1858err_register_blk_swdev_notifier: 1859 unregister_switchdev_notifier(&swdev->swdev_nb); 1860err_register_swdev_notifier: 1861 destroy_workqueue(swdev_wq); 1862 return err; 1863} 1864 1865static void prestera_switchdev_handler_fini(struct prestera_switchdev *swdev) 1866{ 1867 unregister_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1868 unregister_switchdev_notifier(&swdev->swdev_nb); 1869} 1870 1871int prestera_switchdev_init(struct prestera_switch *sw) 1872{ 1873 struct prestera_switchdev *swdev; 1874 int err; 1875 1876 swdev = kzalloc(sizeof(*swdev), GFP_KERNEL); 1877 if (!swdev) 1878 return -ENOMEM; 1879 1880 sw->swdev = swdev; 1881 swdev->sw = sw; 1882 1883 INIT_LIST_HEAD(&swdev->bridge_list); 1884 1885 swdev_wq = alloc_ordered_workqueue("%s_ordered", 0, "prestera_br"); 1886 if (!swdev_wq) { 1887 err = -ENOMEM; 1888 goto err_alloc_wq; 1889 } 1890 1891 err = prestera_switchdev_handler_init(swdev); 1892 if (err) 1893 goto err_swdev_init; 1894 1895 err = prestera_fdb_init(sw); 1896 if (err) 1897 goto err_fdb_init; 1898 1899 return 0; 1900 1901err_fdb_init: 1902err_swdev_init: 1903 destroy_workqueue(swdev_wq); 1904err_alloc_wq: 1905 kfree(swdev); 1906 1907 return err; 1908} 1909 1910void prestera_switchdev_fini(struct prestera_switch *sw) 1911{ 1912 struct prestera_switchdev *swdev = sw->swdev; 1913 1914 prestera_fdb_fini(sw); 1915 prestera_switchdev_handler_fini(swdev); 1916 destroy_workqueue(swdev_wq); 1917 kfree(swdev); 1918} 1919