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 22 struct 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 29 struct 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 37 struct prestera_bridge { 38 struct list_head head; 39 struct net_device *dev; 40 struct prestera_switchdev *swdev; 41 struct list_head port_list; 42 bool vlan_enabled; 43 u16 bridge_id; 44 }; 45 46 struct prestera_bridge_port { 47 struct list_head head; 48 struct net_device *dev; 49 struct prestera_bridge *bridge; 50 struct list_head vlan_list; 51 refcount_t ref_count; 52 unsigned long flags; 53 u8 stp_state; 54 }; 55 56 struct prestera_bridge_vlan { 57 struct list_head head; 58 struct list_head port_vlan_list; 59 u16 vid; 60 }; 61 62 struct prestera_port_vlan { 63 struct list_head br_vlan_head; 64 struct list_head port_head; 65 struct prestera_port *port; 66 struct prestera_bridge_port *br_port; 67 u16 vid; 68 }; 69 70 static struct workqueue_struct *swdev_wq; 71 72 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port); 73 74 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid, 75 u8 state); 76 77 static struct prestera_bridge_vlan * 78 prestera_bridge_vlan_create(struct prestera_bridge_port *br_port, u16 vid) 79 { 80 struct prestera_bridge_vlan *br_vlan; 81 82 br_vlan = kzalloc(sizeof(*br_vlan), GFP_KERNEL); 83 if (!br_vlan) 84 return NULL; 85 86 INIT_LIST_HEAD(&br_vlan->port_vlan_list); 87 br_vlan->vid = vid; 88 list_add(&br_vlan->head, &br_port->vlan_list); 89 90 return br_vlan; 91 } 92 93 static void prestera_bridge_vlan_destroy(struct prestera_bridge_vlan *br_vlan) 94 { 95 list_del(&br_vlan->head); 96 WARN_ON(!list_empty(&br_vlan->port_vlan_list)); 97 kfree(br_vlan); 98 } 99 100 static struct prestera_bridge_vlan * 101 prestera_bridge_vlan_by_vid(struct prestera_bridge_port *br_port, u16 vid) 102 { 103 struct prestera_bridge_vlan *br_vlan; 104 105 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 106 if (br_vlan->vid == vid) 107 return br_vlan; 108 } 109 110 return NULL; 111 } 112 113 static int prestera_bridge_vlan_port_count(struct prestera_bridge *bridge, 114 u16 vid) 115 { 116 struct prestera_bridge_port *br_port; 117 struct prestera_bridge_vlan *br_vlan; 118 int count = 0; 119 120 list_for_each_entry(br_port, &bridge->port_list, head) { 121 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 122 if (br_vlan->vid == vid) { 123 count += 1; 124 break; 125 } 126 } 127 } 128 129 return count; 130 } 131 132 static void prestera_bridge_vlan_put(struct prestera_bridge_vlan *br_vlan) 133 { 134 if (list_empty(&br_vlan->port_vlan_list)) 135 prestera_bridge_vlan_destroy(br_vlan); 136 } 137 138 static struct prestera_port_vlan * 139 prestera_port_vlan_by_vid(struct prestera_port *port, u16 vid) 140 { 141 struct prestera_port_vlan *port_vlan; 142 143 list_for_each_entry(port_vlan, &port->vlans_list, port_head) { 144 if (port_vlan->vid == vid) 145 return port_vlan; 146 } 147 148 return NULL; 149 } 150 151 static struct prestera_port_vlan * 152 prestera_port_vlan_create(struct prestera_port *port, u16 vid, bool untagged) 153 { 154 struct prestera_port_vlan *port_vlan; 155 int err; 156 157 port_vlan = prestera_port_vlan_by_vid(port, vid); 158 if (port_vlan) 159 return ERR_PTR(-EEXIST); 160 161 err = prestera_hw_vlan_port_set(port, vid, true, untagged); 162 if (err) 163 return ERR_PTR(err); 164 165 port_vlan = kzalloc(sizeof(*port_vlan), GFP_KERNEL); 166 if (!port_vlan) { 167 err = -ENOMEM; 168 goto err_port_vlan_alloc; 169 } 170 171 port_vlan->port = port; 172 port_vlan->vid = vid; 173 174 list_add(&port_vlan->port_head, &port->vlans_list); 175 176 return port_vlan; 177 178 err_port_vlan_alloc: 179 prestera_hw_vlan_port_set(port, vid, false, false); 180 return ERR_PTR(err); 181 } 182 183 static void 184 prestera_port_vlan_bridge_leave(struct prestera_port_vlan *port_vlan) 185 { 186 u32 fdb_flush_mode = PRESTERA_FDB_FLUSH_MODE_DYNAMIC; 187 struct prestera_port *port = port_vlan->port; 188 struct prestera_bridge_vlan *br_vlan; 189 struct prestera_bridge_port *br_port; 190 bool last_port, last_vlan; 191 u16 vid = port_vlan->vid; 192 int port_count; 193 194 br_port = port_vlan->br_port; 195 port_count = prestera_bridge_vlan_port_count(br_port->bridge, vid); 196 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid); 197 198 last_vlan = list_is_singular(&br_port->vlan_list); 199 last_port = port_count == 1; 200 201 if (last_vlan) 202 prestera_hw_fdb_flush_port(port, fdb_flush_mode); 203 else if (last_port) 204 prestera_hw_fdb_flush_vlan(port->sw, vid, fdb_flush_mode); 205 else 206 prestera_hw_fdb_flush_port_vlan(port, vid, fdb_flush_mode); 207 208 list_del(&port_vlan->br_vlan_head); 209 prestera_bridge_vlan_put(br_vlan); 210 prestera_bridge_port_put(br_port); 211 port_vlan->br_port = NULL; 212 } 213 214 static void prestera_port_vlan_destroy(struct prestera_port_vlan *port_vlan) 215 { 216 struct prestera_port *port = port_vlan->port; 217 u16 vid = port_vlan->vid; 218 219 if (port_vlan->br_port) 220 prestera_port_vlan_bridge_leave(port_vlan); 221 222 prestera_hw_vlan_port_set(port, vid, false, false); 223 list_del(&port_vlan->port_head); 224 kfree(port_vlan); 225 } 226 227 static struct prestera_bridge * 228 prestera_bridge_create(struct prestera_switchdev *swdev, struct net_device *dev) 229 { 230 bool vlan_enabled = br_vlan_enabled(dev); 231 struct prestera_bridge *bridge; 232 u16 bridge_id; 233 int err; 234 235 if (vlan_enabled && swdev->bridge_8021q_exists) { 236 netdev_err(dev, "Only one VLAN-aware bridge is supported\n"); 237 return ERR_PTR(-EINVAL); 238 } 239 240 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 241 if (!bridge) 242 return ERR_PTR(-ENOMEM); 243 244 if (vlan_enabled) { 245 swdev->bridge_8021q_exists = true; 246 } else { 247 err = prestera_hw_bridge_create(swdev->sw, &bridge_id); 248 if (err) { 249 kfree(bridge); 250 return ERR_PTR(err); 251 } 252 253 bridge->bridge_id = bridge_id; 254 } 255 256 bridge->vlan_enabled = vlan_enabled; 257 bridge->swdev = swdev; 258 bridge->dev = dev; 259 260 INIT_LIST_HEAD(&bridge->port_list); 261 262 list_add(&bridge->head, &swdev->bridge_list); 263 264 return bridge; 265 } 266 267 static void prestera_bridge_destroy(struct prestera_bridge *bridge) 268 { 269 struct prestera_switchdev *swdev = bridge->swdev; 270 271 list_del(&bridge->head); 272 273 if (bridge->vlan_enabled) 274 swdev->bridge_8021q_exists = false; 275 else 276 prestera_hw_bridge_delete(swdev->sw, bridge->bridge_id); 277 278 WARN_ON(!list_empty(&bridge->port_list)); 279 kfree(bridge); 280 } 281 282 static void prestera_bridge_put(struct prestera_bridge *bridge) 283 { 284 if (list_empty(&bridge->port_list)) 285 prestera_bridge_destroy(bridge); 286 } 287 288 static 289 struct prestera_bridge *prestera_bridge_by_dev(struct prestera_switchdev *swdev, 290 const struct net_device *dev) 291 { 292 struct prestera_bridge *bridge; 293 294 list_for_each_entry(bridge, &swdev->bridge_list, head) 295 if (bridge->dev == dev) 296 return bridge; 297 298 return NULL; 299 } 300 301 static struct prestera_bridge_port * 302 __prestera_bridge_port_by_dev(struct prestera_bridge *bridge, 303 struct net_device *dev) 304 { 305 struct prestera_bridge_port *br_port; 306 307 list_for_each_entry(br_port, &bridge->port_list, head) { 308 if (br_port->dev == dev) 309 return br_port; 310 } 311 312 return NULL; 313 } 314 315 static struct prestera_bridge_port * 316 prestera_bridge_port_by_dev(struct prestera_switchdev *swdev, 317 struct net_device *dev) 318 { 319 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 320 struct prestera_bridge *bridge; 321 322 if (!br_dev) 323 return NULL; 324 325 bridge = prestera_bridge_by_dev(swdev, br_dev); 326 if (!bridge) 327 return NULL; 328 329 return __prestera_bridge_port_by_dev(bridge, dev); 330 } 331 332 static struct prestera_bridge_port * 333 prestera_bridge_port_create(struct prestera_bridge *bridge, 334 struct net_device *dev) 335 { 336 struct prestera_bridge_port *br_port; 337 338 br_port = kzalloc(sizeof(*br_port), GFP_KERNEL); 339 if (!br_port) 340 return NULL; 341 342 br_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC | 343 BR_MCAST_FLOOD; 344 br_port->stp_state = BR_STATE_DISABLED; 345 refcount_set(&br_port->ref_count, 1); 346 br_port->bridge = bridge; 347 br_port->dev = dev; 348 349 INIT_LIST_HEAD(&br_port->vlan_list); 350 list_add(&br_port->head, &bridge->port_list); 351 352 return br_port; 353 } 354 355 static void 356 prestera_bridge_port_destroy(struct prestera_bridge_port *br_port) 357 { 358 list_del(&br_port->head); 359 WARN_ON(!list_empty(&br_port->vlan_list)); 360 kfree(br_port); 361 } 362 363 static void prestera_bridge_port_get(struct prestera_bridge_port *br_port) 364 { 365 refcount_inc(&br_port->ref_count); 366 } 367 368 static void prestera_bridge_port_put(struct prestera_bridge_port *br_port) 369 { 370 struct prestera_bridge *bridge = br_port->bridge; 371 372 if (refcount_dec_and_test(&br_port->ref_count)) { 373 prestera_bridge_port_destroy(br_port); 374 prestera_bridge_put(bridge); 375 } 376 } 377 378 static struct prestera_bridge_port * 379 prestera_bridge_port_add(struct prestera_bridge *bridge, struct net_device *dev) 380 { 381 struct prestera_bridge_port *br_port; 382 383 br_port = __prestera_bridge_port_by_dev(bridge, dev); 384 if (br_port) { 385 prestera_bridge_port_get(br_port); 386 return br_port; 387 } 388 389 br_port = prestera_bridge_port_create(bridge, dev); 390 if (!br_port) 391 return ERR_PTR(-ENOMEM); 392 393 return br_port; 394 } 395 396 static int 397 prestera_bridge_1d_port_join(struct prestera_bridge_port *br_port) 398 { 399 struct prestera_port *port = netdev_priv(br_port->dev); 400 struct prestera_bridge *bridge = br_port->bridge; 401 int err; 402 403 err = prestera_hw_bridge_port_add(port, bridge->bridge_id); 404 if (err) 405 return err; 406 407 err = prestera_hw_port_flood_set(port, br_port->flags & BR_FLOOD); 408 if (err) 409 goto err_port_flood_set; 410 411 err = prestera_hw_port_learning_set(port, br_port->flags & BR_LEARNING); 412 if (err) 413 goto err_port_learning_set; 414 415 return 0; 416 417 err_port_learning_set: 418 prestera_hw_port_flood_set(port, false); 419 err_port_flood_set: 420 prestera_hw_bridge_port_delete(port, bridge->bridge_id); 421 422 return err; 423 } 424 425 static int prestera_port_bridge_join(struct prestera_port *port, 426 struct net_device *upper) 427 { 428 struct prestera_switchdev *swdev = port->sw->swdev; 429 struct prestera_bridge_port *br_port; 430 struct prestera_bridge *bridge; 431 int err; 432 433 bridge = prestera_bridge_by_dev(swdev, upper); 434 if (!bridge) { 435 bridge = prestera_bridge_create(swdev, upper); 436 if (IS_ERR(bridge)) 437 return PTR_ERR(bridge); 438 } 439 440 br_port = prestera_bridge_port_add(bridge, port->dev); 441 if (IS_ERR(br_port)) { 442 err = PTR_ERR(br_port); 443 goto err_brport_create; 444 } 445 446 if (bridge->vlan_enabled) 447 return 0; 448 449 err = prestera_bridge_1d_port_join(br_port); 450 if (err) 451 goto err_port_join; 452 453 return 0; 454 455 err_port_join: 456 prestera_bridge_port_put(br_port); 457 err_brport_create: 458 prestera_bridge_put(bridge); 459 return err; 460 } 461 462 static void prestera_bridge_1q_port_leave(struct prestera_bridge_port *br_port) 463 { 464 struct prestera_port *port = netdev_priv(br_port->dev); 465 466 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL); 467 prestera_port_pvid_set(port, PRESTERA_DEFAULT_VID); 468 } 469 470 static void prestera_bridge_1d_port_leave(struct prestera_bridge_port *br_port) 471 { 472 struct prestera_port *port = netdev_priv(br_port->dev); 473 474 prestera_hw_fdb_flush_port(port, PRESTERA_FDB_FLUSH_MODE_ALL); 475 prestera_hw_bridge_port_delete(port, br_port->bridge->bridge_id); 476 } 477 478 static int prestera_port_vid_stp_set(struct prestera_port *port, u16 vid, 479 u8 state) 480 { 481 u8 hw_state = state; 482 483 switch (state) { 484 case BR_STATE_DISABLED: 485 hw_state = PRESTERA_STP_DISABLED; 486 break; 487 488 case BR_STATE_BLOCKING: 489 case BR_STATE_LISTENING: 490 hw_state = PRESTERA_STP_BLOCK_LISTEN; 491 break; 492 493 case BR_STATE_LEARNING: 494 hw_state = PRESTERA_STP_LEARN; 495 break; 496 497 case BR_STATE_FORWARDING: 498 hw_state = PRESTERA_STP_FORWARD; 499 break; 500 501 default: 502 return -EINVAL; 503 } 504 505 return prestera_hw_vlan_port_stp_set(port, vid, hw_state); 506 } 507 508 static void prestera_port_bridge_leave(struct prestera_port *port, 509 struct net_device *upper) 510 { 511 struct prestera_switchdev *swdev = port->sw->swdev; 512 struct prestera_bridge_port *br_port; 513 struct prestera_bridge *bridge; 514 515 bridge = prestera_bridge_by_dev(swdev, upper); 516 if (!bridge) 517 return; 518 519 br_port = __prestera_bridge_port_by_dev(bridge, port->dev); 520 if (!br_port) 521 return; 522 523 bridge = br_port->bridge; 524 525 if (bridge->vlan_enabled) 526 prestera_bridge_1q_port_leave(br_port); 527 else 528 prestera_bridge_1d_port_leave(br_port); 529 530 prestera_hw_port_learning_set(port, false); 531 prestera_hw_port_flood_set(port, false); 532 prestera_port_vid_stp_set(port, PRESTERA_VID_ALL, BR_STATE_FORWARDING); 533 prestera_bridge_port_put(br_port); 534 } 535 536 int prestera_bridge_port_event(struct net_device *dev, unsigned long event, 537 void *ptr) 538 { 539 struct netdev_notifier_changeupper_info *info = ptr; 540 struct netlink_ext_ack *extack; 541 struct prestera_port *port; 542 struct net_device *upper; 543 int err; 544 545 extack = netdev_notifier_info_to_extack(&info->info); 546 port = netdev_priv(dev); 547 upper = info->upper_dev; 548 549 switch (event) { 550 case NETDEV_PRECHANGEUPPER: 551 if (!netif_is_bridge_master(upper)) { 552 NL_SET_ERR_MSG_MOD(extack, "Unknown upper device type"); 553 return -EINVAL; 554 } 555 556 if (!info->linking) 557 break; 558 559 if (netdev_has_any_upper_dev(upper)) { 560 NL_SET_ERR_MSG_MOD(extack, "Upper device is already enslaved"); 561 return -EINVAL; 562 } 563 break; 564 565 case NETDEV_CHANGEUPPER: 566 if (!netif_is_bridge_master(upper)) 567 break; 568 569 if (info->linking) { 570 err = prestera_port_bridge_join(port, upper); 571 if (err) 572 return err; 573 } else { 574 prestera_port_bridge_leave(port, upper); 575 } 576 break; 577 } 578 579 return 0; 580 } 581 582 static int prestera_port_attr_br_flags_set(struct prestera_port *port, 583 struct switchdev_trans *trans, 584 struct net_device *dev, 585 unsigned long flags) 586 { 587 struct prestera_bridge_port *br_port; 588 int err; 589 590 if (switchdev_trans_ph_prepare(trans)) 591 return 0; 592 593 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 594 if (!br_port) 595 return 0; 596 597 err = prestera_hw_port_flood_set(port, flags & BR_FLOOD); 598 if (err) 599 return err; 600 601 err = prestera_hw_port_learning_set(port, flags & BR_LEARNING); 602 if (err) 603 return err; 604 605 memcpy(&br_port->flags, &flags, sizeof(flags)); 606 607 return 0; 608 } 609 610 static int prestera_port_attr_br_ageing_set(struct prestera_port *port, 611 struct switchdev_trans *trans, 612 unsigned long ageing_clock_t) 613 { 614 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); 615 u32 ageing_time_ms = jiffies_to_msecs(ageing_jiffies); 616 struct prestera_switch *sw = port->sw; 617 618 if (switchdev_trans_ph_prepare(trans)) { 619 if (ageing_time_ms < PRESTERA_MIN_AGEING_TIME_MS || 620 ageing_time_ms > PRESTERA_MAX_AGEING_TIME_MS) 621 return -ERANGE; 622 else 623 return 0; 624 } 625 626 return prestera_hw_switch_ageing_set(sw, ageing_time_ms); 627 } 628 629 static int prestera_port_attr_br_vlan_set(struct prestera_port *port, 630 struct switchdev_trans *trans, 631 struct net_device *dev, 632 bool vlan_enabled) 633 { 634 struct prestera_switch *sw = port->sw; 635 struct prestera_bridge *bridge; 636 637 if (!switchdev_trans_ph_prepare(trans)) 638 return 0; 639 640 bridge = prestera_bridge_by_dev(sw->swdev, dev); 641 if (WARN_ON(!bridge)) 642 return -EINVAL; 643 644 if (bridge->vlan_enabled == vlan_enabled) 645 return 0; 646 647 netdev_err(bridge->dev, "VLAN filtering can't be changed for existing bridge\n"); 648 649 return -EINVAL; 650 } 651 652 static int prestera_port_bridge_vlan_stp_set(struct prestera_port *port, 653 struct prestera_bridge_vlan *br_vlan, 654 u8 state) 655 { 656 struct prestera_port_vlan *port_vlan; 657 658 list_for_each_entry(port_vlan, &br_vlan->port_vlan_list, br_vlan_head) { 659 if (port_vlan->port != port) 660 continue; 661 662 return prestera_port_vid_stp_set(port, br_vlan->vid, state); 663 } 664 665 return 0; 666 } 667 668 static int presterar_port_attr_stp_state_set(struct prestera_port *port, 669 struct switchdev_trans *trans, 670 struct net_device *dev, 671 u8 state) 672 { 673 struct prestera_bridge_port *br_port; 674 struct prestera_bridge_vlan *br_vlan; 675 int err; 676 u16 vid; 677 678 if (switchdev_trans_ph_prepare(trans)) 679 return 0; 680 681 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 682 if (!br_port) 683 return 0; 684 685 if (!br_port->bridge->vlan_enabled) { 686 vid = br_port->bridge->bridge_id; 687 err = prestera_port_vid_stp_set(port, vid, state); 688 if (err) 689 goto err_port_stp_set; 690 } else { 691 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 692 err = prestera_port_bridge_vlan_stp_set(port, br_vlan, 693 state); 694 if (err) 695 goto err_port_vlan_stp_set; 696 } 697 } 698 699 br_port->stp_state = state; 700 701 return 0; 702 703 err_port_vlan_stp_set: 704 list_for_each_entry_continue_reverse(br_vlan, &br_port->vlan_list, head) 705 prestera_port_bridge_vlan_stp_set(port, br_vlan, br_port->stp_state); 706 return err; 707 708 err_port_stp_set: 709 prestera_port_vid_stp_set(port, vid, br_port->stp_state); 710 711 return err; 712 } 713 714 static int prestera_port_obj_attr_set(struct net_device *dev, 715 const struct switchdev_attr *attr, 716 struct switchdev_trans *trans) 717 { 718 struct prestera_port *port = netdev_priv(dev); 719 int err = 0; 720 721 switch (attr->id) { 722 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 723 err = presterar_port_attr_stp_state_set(port, trans, 724 attr->orig_dev, 725 attr->u.stp_state); 726 break; 727 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 728 if (attr->u.brport_flags & 729 ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD)) 730 err = -EINVAL; 731 break; 732 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 733 err = prestera_port_attr_br_flags_set(port, trans, 734 attr->orig_dev, 735 attr->u.brport_flags); 736 break; 737 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 738 err = prestera_port_attr_br_ageing_set(port, trans, 739 attr->u.ageing_time); 740 break; 741 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 742 err = prestera_port_attr_br_vlan_set(port, trans, 743 attr->orig_dev, 744 attr->u.vlan_filtering); 745 break; 746 default: 747 err = -EOPNOTSUPP; 748 } 749 750 return err; 751 } 752 753 static void 754 prestera_fdb_offload_notify(struct prestera_port *port, 755 struct switchdev_notifier_fdb_info *info) 756 { 757 struct switchdev_notifier_fdb_info send_info; 758 759 send_info.addr = info->addr; 760 send_info.vid = info->vid; 761 send_info.offloaded = true; 762 763 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, port->dev, 764 &send_info.info, NULL); 765 } 766 767 static int prestera_port_fdb_set(struct prestera_port *port, 768 struct switchdev_notifier_fdb_info *fdb_info, 769 bool adding) 770 { 771 struct prestera_switch *sw = port->sw; 772 struct prestera_bridge_port *br_port; 773 struct prestera_bridge *bridge; 774 int err; 775 u16 vid; 776 777 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev); 778 if (!br_port) 779 return -EINVAL; 780 781 bridge = br_port->bridge; 782 783 if (bridge->vlan_enabled) 784 vid = fdb_info->vid; 785 else 786 vid = bridge->bridge_id; 787 788 if (adding) 789 err = prestera_hw_fdb_add(port, fdb_info->addr, vid, false); 790 else 791 err = prestera_hw_fdb_del(port, fdb_info->addr, vid); 792 793 return err; 794 } 795 796 static void prestera_fdb_event_work(struct work_struct *work) 797 { 798 struct switchdev_notifier_fdb_info *fdb_info; 799 struct prestera_fdb_event_work *swdev_work; 800 struct prestera_port *port; 801 struct net_device *dev; 802 int err; 803 804 swdev_work = container_of(work, struct prestera_fdb_event_work, work); 805 dev = swdev_work->dev; 806 807 rtnl_lock(); 808 809 port = prestera_port_dev_lower_find(dev); 810 if (!port) 811 goto out_unlock; 812 813 switch (swdev_work->event) { 814 case SWITCHDEV_FDB_ADD_TO_DEVICE: 815 fdb_info = &swdev_work->fdb_info; 816 if (!fdb_info->added_by_user) 817 break; 818 819 err = prestera_port_fdb_set(port, fdb_info, true); 820 if (err) 821 break; 822 823 prestera_fdb_offload_notify(port, fdb_info); 824 break; 825 826 case SWITCHDEV_FDB_DEL_TO_DEVICE: 827 fdb_info = &swdev_work->fdb_info; 828 prestera_port_fdb_set(port, fdb_info, false); 829 break; 830 } 831 832 out_unlock: 833 rtnl_unlock(); 834 835 kfree(swdev_work->fdb_info.addr); 836 kfree(swdev_work); 837 dev_put(dev); 838 } 839 840 static int prestera_switchdev_event(struct notifier_block *unused, 841 unsigned long event, void *ptr) 842 { 843 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 844 struct switchdev_notifier_fdb_info *fdb_info; 845 struct switchdev_notifier_info *info = ptr; 846 struct prestera_fdb_event_work *swdev_work; 847 struct net_device *upper; 848 int err; 849 850 if (event == SWITCHDEV_PORT_ATTR_SET) { 851 err = switchdev_handle_port_attr_set(dev, ptr, 852 prestera_netdev_check, 853 prestera_port_obj_attr_set); 854 return notifier_from_errno(err); 855 } 856 857 if (!prestera_netdev_check(dev)) 858 return NOTIFY_DONE; 859 860 upper = netdev_master_upper_dev_get_rcu(dev); 861 if (!upper) 862 return NOTIFY_DONE; 863 864 if (!netif_is_bridge_master(upper)) 865 return NOTIFY_DONE; 866 867 swdev_work = kzalloc(sizeof(*swdev_work), GFP_ATOMIC); 868 if (!swdev_work) 869 return NOTIFY_BAD; 870 871 swdev_work->event = event; 872 swdev_work->dev = dev; 873 874 switch (event) { 875 case SWITCHDEV_FDB_ADD_TO_DEVICE: 876 case SWITCHDEV_FDB_DEL_TO_DEVICE: 877 fdb_info = container_of(info, 878 struct switchdev_notifier_fdb_info, 879 info); 880 881 INIT_WORK(&swdev_work->work, prestera_fdb_event_work); 882 memcpy(&swdev_work->fdb_info, ptr, 883 sizeof(swdev_work->fdb_info)); 884 885 swdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 886 if (!swdev_work->fdb_info.addr) 887 goto out_bad; 888 889 ether_addr_copy((u8 *)swdev_work->fdb_info.addr, 890 fdb_info->addr); 891 dev_hold(dev); 892 break; 893 894 default: 895 kfree(swdev_work); 896 return NOTIFY_DONE; 897 } 898 899 queue_work(swdev_wq, &swdev_work->work); 900 return NOTIFY_DONE; 901 902 out_bad: 903 kfree(swdev_work); 904 return NOTIFY_BAD; 905 } 906 907 static int 908 prestera_port_vlan_bridge_join(struct prestera_port_vlan *port_vlan, 909 struct prestera_bridge_port *br_port) 910 { 911 struct prestera_port *port = port_vlan->port; 912 struct prestera_bridge_vlan *br_vlan; 913 u16 vid = port_vlan->vid; 914 int err; 915 916 if (port_vlan->br_port) 917 return 0; 918 919 err = prestera_hw_port_flood_set(port, br_port->flags & BR_FLOOD); 920 if (err) 921 return err; 922 923 err = prestera_hw_port_learning_set(port, br_port->flags & BR_LEARNING); 924 if (err) 925 goto err_port_learning_set; 926 927 err = prestera_port_vid_stp_set(port, vid, br_port->stp_state); 928 if (err) 929 goto err_port_vid_stp_set; 930 931 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid); 932 if (!br_vlan) { 933 br_vlan = prestera_bridge_vlan_create(br_port, vid); 934 if (!br_vlan) { 935 err = -ENOMEM; 936 goto err_bridge_vlan_get; 937 } 938 } 939 940 list_add(&port_vlan->br_vlan_head, &br_vlan->port_vlan_list); 941 942 prestera_bridge_port_get(br_port); 943 port_vlan->br_port = br_port; 944 945 return 0; 946 947 err_bridge_vlan_get: 948 prestera_port_vid_stp_set(port, vid, BR_STATE_FORWARDING); 949 err_port_vid_stp_set: 950 prestera_hw_port_learning_set(port, false); 951 err_port_learning_set: 952 return err; 953 } 954 955 static int 956 prestera_bridge_port_vlan_add(struct prestera_port *port, 957 struct prestera_bridge_port *br_port, 958 u16 vid, bool is_untagged, bool is_pvid, 959 struct netlink_ext_ack *extack) 960 { 961 struct prestera_port_vlan *port_vlan; 962 u16 old_pvid = port->pvid; 963 u16 pvid; 964 int err; 965 966 if (is_pvid) 967 pvid = vid; 968 else 969 pvid = port->pvid == vid ? 0 : port->pvid; 970 971 port_vlan = prestera_port_vlan_by_vid(port, vid); 972 if (port_vlan && port_vlan->br_port != br_port) 973 return -EEXIST; 974 975 if (!port_vlan) { 976 port_vlan = prestera_port_vlan_create(port, vid, is_untagged); 977 if (IS_ERR(port_vlan)) 978 return PTR_ERR(port_vlan); 979 } else { 980 err = prestera_hw_vlan_port_set(port, vid, true, is_untagged); 981 if (err) 982 goto err_port_vlan_set; 983 } 984 985 err = prestera_port_pvid_set(port, pvid); 986 if (err) 987 goto err_port_pvid_set; 988 989 err = prestera_port_vlan_bridge_join(port_vlan, br_port); 990 if (err) 991 goto err_port_vlan_bridge_join; 992 993 return 0; 994 995 err_port_vlan_bridge_join: 996 prestera_port_pvid_set(port, old_pvid); 997 err_port_pvid_set: 998 prestera_hw_vlan_port_set(port, vid, false, false); 999 err_port_vlan_set: 1000 prestera_port_vlan_destroy(port_vlan); 1001 1002 return err; 1003 } 1004 1005 static void 1006 prestera_bridge_port_vlan_del(struct prestera_port *port, 1007 struct prestera_bridge_port *br_port, u16 vid) 1008 { 1009 u16 pvid = port->pvid == vid ? 0 : port->pvid; 1010 struct prestera_port_vlan *port_vlan; 1011 1012 port_vlan = prestera_port_vlan_by_vid(port, vid); 1013 if (WARN_ON(!port_vlan)) 1014 return; 1015 1016 prestera_port_vlan_bridge_leave(port_vlan); 1017 prestera_port_pvid_set(port, pvid); 1018 prestera_port_vlan_destroy(port_vlan); 1019 } 1020 1021 static int prestera_port_vlans_add(struct prestera_port *port, 1022 const struct switchdev_obj_port_vlan *vlan, 1023 struct switchdev_trans *trans, 1024 struct netlink_ext_ack *extack) 1025 { 1026 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 1027 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; 1028 struct net_device *dev = vlan->obj.orig_dev; 1029 struct prestera_bridge_port *br_port; 1030 struct prestera_switch *sw = port->sw; 1031 struct prestera_bridge *bridge; 1032 u16 vid; 1033 1034 if (netif_is_bridge_master(dev)) 1035 return 0; 1036 1037 if (switchdev_trans_ph_commit(trans)) 1038 return 0; 1039 1040 br_port = prestera_bridge_port_by_dev(sw->swdev, dev); 1041 if (WARN_ON(!br_port)) 1042 return -EINVAL; 1043 1044 bridge = br_port->bridge; 1045 if (!bridge->vlan_enabled) 1046 return 0; 1047 1048 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) { 1049 int err; 1050 1051 err = prestera_bridge_port_vlan_add(port, br_port, 1052 vid, flag_untagged, 1053 flag_pvid, extack); 1054 if (err) 1055 return err; 1056 } 1057 1058 return 0; 1059 } 1060 1061 static int prestera_port_obj_add(struct net_device *dev, 1062 const struct switchdev_obj *obj, 1063 struct switchdev_trans *trans, 1064 struct netlink_ext_ack *extack) 1065 { 1066 struct prestera_port *port = netdev_priv(dev); 1067 const struct switchdev_obj_port_vlan *vlan; 1068 1069 switch (obj->id) { 1070 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1071 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 1072 return prestera_port_vlans_add(port, vlan, trans, extack); 1073 default: 1074 return -EOPNOTSUPP; 1075 } 1076 } 1077 1078 static int prestera_port_vlans_del(struct prestera_port *port, 1079 const struct switchdev_obj_port_vlan *vlan) 1080 { 1081 struct net_device *dev = vlan->obj.orig_dev; 1082 struct prestera_bridge_port *br_port; 1083 struct prestera_switch *sw = port->sw; 1084 u16 vid; 1085 1086 if (netif_is_bridge_master(dev)) 1087 return -EOPNOTSUPP; 1088 1089 br_port = prestera_bridge_port_by_dev(sw->swdev, dev); 1090 if (WARN_ON(!br_port)) 1091 return -EINVAL; 1092 1093 if (!br_port->bridge->vlan_enabled) 1094 return 0; 1095 1096 for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) 1097 prestera_bridge_port_vlan_del(port, br_port, vid); 1098 1099 return 0; 1100 } 1101 1102 static int prestera_port_obj_del(struct net_device *dev, 1103 const struct switchdev_obj *obj) 1104 { 1105 struct prestera_port *port = netdev_priv(dev); 1106 1107 switch (obj->id) { 1108 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1109 return prestera_port_vlans_del(port, SWITCHDEV_OBJ_PORT_VLAN(obj)); 1110 default: 1111 return -EOPNOTSUPP; 1112 } 1113 } 1114 1115 static int prestera_switchdev_blk_event(struct notifier_block *unused, 1116 unsigned long event, void *ptr) 1117 { 1118 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1119 int err; 1120 1121 switch (event) { 1122 case SWITCHDEV_PORT_OBJ_ADD: 1123 err = switchdev_handle_port_obj_add(dev, ptr, 1124 prestera_netdev_check, 1125 prestera_port_obj_add); 1126 break; 1127 case SWITCHDEV_PORT_OBJ_DEL: 1128 err = switchdev_handle_port_obj_del(dev, ptr, 1129 prestera_netdev_check, 1130 prestera_port_obj_del); 1131 break; 1132 case SWITCHDEV_PORT_ATTR_SET: 1133 err = switchdev_handle_port_attr_set(dev, ptr, 1134 prestera_netdev_check, 1135 prestera_port_obj_attr_set); 1136 break; 1137 default: 1138 err = -EOPNOTSUPP; 1139 } 1140 1141 return notifier_from_errno(err); 1142 } 1143 1144 static void prestera_fdb_event(struct prestera_switch *sw, 1145 struct prestera_event *evt, void *arg) 1146 { 1147 struct switchdev_notifier_fdb_info info; 1148 struct prestera_port *port; 1149 1150 port = prestera_find_port(sw, evt->fdb_evt.port_id); 1151 if (!port) 1152 return; 1153 1154 info.addr = evt->fdb_evt.data.mac; 1155 info.vid = evt->fdb_evt.vid; 1156 info.offloaded = true; 1157 1158 rtnl_lock(); 1159 1160 switch (evt->id) { 1161 case PRESTERA_FDB_EVENT_LEARNED: 1162 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE, 1163 port->dev, &info.info, NULL); 1164 break; 1165 case PRESTERA_FDB_EVENT_AGED: 1166 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, 1167 port->dev, &info.info, NULL); 1168 break; 1169 } 1170 1171 rtnl_unlock(); 1172 } 1173 1174 static int prestera_fdb_init(struct prestera_switch *sw) 1175 { 1176 int err; 1177 1178 err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_FDB, 1179 prestera_fdb_event, NULL); 1180 if (err) 1181 return err; 1182 1183 err = prestera_hw_switch_ageing_set(sw, PRESTERA_DEFAULT_AGEING_TIME_MS); 1184 if (err) 1185 goto err_ageing_set; 1186 1187 return 0; 1188 1189 err_ageing_set: 1190 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1191 prestera_fdb_event); 1192 return err; 1193 } 1194 1195 static void prestera_fdb_fini(struct prestera_switch *sw) 1196 { 1197 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1198 prestera_fdb_event); 1199 } 1200 1201 static int prestera_switchdev_handler_init(struct prestera_switchdev *swdev) 1202 { 1203 int err; 1204 1205 swdev->swdev_nb.notifier_call = prestera_switchdev_event; 1206 err = register_switchdev_notifier(&swdev->swdev_nb); 1207 if (err) 1208 goto err_register_swdev_notifier; 1209 1210 swdev->swdev_nb_blk.notifier_call = prestera_switchdev_blk_event; 1211 err = register_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1212 if (err) 1213 goto err_register_blk_swdev_notifier; 1214 1215 return 0; 1216 1217 err_register_blk_swdev_notifier: 1218 unregister_switchdev_notifier(&swdev->swdev_nb); 1219 err_register_swdev_notifier: 1220 destroy_workqueue(swdev_wq); 1221 return err; 1222 } 1223 1224 static void prestera_switchdev_handler_fini(struct prestera_switchdev *swdev) 1225 { 1226 unregister_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1227 unregister_switchdev_notifier(&swdev->swdev_nb); 1228 } 1229 1230 int prestera_switchdev_init(struct prestera_switch *sw) 1231 { 1232 struct prestera_switchdev *swdev; 1233 int err; 1234 1235 swdev = kzalloc(sizeof(*swdev), GFP_KERNEL); 1236 if (!swdev) 1237 return -ENOMEM; 1238 1239 sw->swdev = swdev; 1240 swdev->sw = sw; 1241 1242 INIT_LIST_HEAD(&swdev->bridge_list); 1243 1244 swdev_wq = alloc_ordered_workqueue("%s_ordered", 0, "prestera_br"); 1245 if (!swdev_wq) { 1246 err = -ENOMEM; 1247 goto err_alloc_wq; 1248 } 1249 1250 err = prestera_switchdev_handler_init(swdev); 1251 if (err) 1252 goto err_swdev_init; 1253 1254 err = prestera_fdb_init(sw); 1255 if (err) 1256 goto err_fdb_init; 1257 1258 return 0; 1259 1260 err_fdb_init: 1261 err_swdev_init: 1262 destroy_workqueue(swdev_wq); 1263 err_alloc_wq: 1264 kfree(swdev); 1265 1266 return err; 1267 } 1268 1269 void prestera_switchdev_fini(struct prestera_switch *sw) 1270 { 1271 struct prestera_switchdev *swdev = sw->swdev; 1272 1273 prestera_fdb_fini(sw); 1274 prestera_switchdev_handler_fini(swdev); 1275 destroy_workqueue(swdev_wq); 1276 kfree(swdev); 1277 } 1278