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 net_device *dev, 584 unsigned long flags) 585 { 586 struct prestera_bridge_port *br_port; 587 int err; 588 589 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 590 if (!br_port) 591 return 0; 592 593 err = prestera_hw_port_flood_set(port, flags & BR_FLOOD); 594 if (err) 595 return err; 596 597 err = prestera_hw_port_learning_set(port, flags & BR_LEARNING); 598 if (err) 599 return err; 600 601 memcpy(&br_port->flags, &flags, sizeof(flags)); 602 603 return 0; 604 } 605 606 static int prestera_port_attr_br_ageing_set(struct prestera_port *port, 607 unsigned long ageing_clock_t) 608 { 609 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t); 610 u32 ageing_time_ms = jiffies_to_msecs(ageing_jiffies); 611 struct prestera_switch *sw = port->sw; 612 613 if (ageing_time_ms < PRESTERA_MIN_AGEING_TIME_MS || 614 ageing_time_ms > PRESTERA_MAX_AGEING_TIME_MS) 615 return -ERANGE; 616 617 return prestera_hw_switch_ageing_set(sw, ageing_time_ms); 618 } 619 620 static int prestera_port_attr_br_vlan_set(struct prestera_port *port, 621 struct net_device *dev, 622 bool vlan_enabled) 623 { 624 struct prestera_switch *sw = port->sw; 625 struct prestera_bridge *bridge; 626 627 bridge = prestera_bridge_by_dev(sw->swdev, dev); 628 if (WARN_ON(!bridge)) 629 return -EINVAL; 630 631 if (bridge->vlan_enabled == vlan_enabled) 632 return 0; 633 634 netdev_err(bridge->dev, "VLAN filtering can't be changed for existing bridge\n"); 635 636 return -EINVAL; 637 } 638 639 static int prestera_port_bridge_vlan_stp_set(struct prestera_port *port, 640 struct prestera_bridge_vlan *br_vlan, 641 u8 state) 642 { 643 struct prestera_port_vlan *port_vlan; 644 645 list_for_each_entry(port_vlan, &br_vlan->port_vlan_list, br_vlan_head) { 646 if (port_vlan->port != port) 647 continue; 648 649 return prestera_port_vid_stp_set(port, br_vlan->vid, state); 650 } 651 652 return 0; 653 } 654 655 static int prestera_port_attr_stp_state_set(struct prestera_port *port, 656 struct net_device *dev, 657 u8 state) 658 { 659 struct prestera_bridge_port *br_port; 660 struct prestera_bridge_vlan *br_vlan; 661 int err; 662 u16 vid; 663 664 br_port = prestera_bridge_port_by_dev(port->sw->swdev, dev); 665 if (!br_port) 666 return 0; 667 668 if (!br_port->bridge->vlan_enabled) { 669 vid = br_port->bridge->bridge_id; 670 err = prestera_port_vid_stp_set(port, vid, state); 671 if (err) 672 goto err_port_stp_set; 673 } else { 674 list_for_each_entry(br_vlan, &br_port->vlan_list, head) { 675 err = prestera_port_bridge_vlan_stp_set(port, br_vlan, 676 state); 677 if (err) 678 goto err_port_vlan_stp_set; 679 } 680 } 681 682 br_port->stp_state = state; 683 684 return 0; 685 686 err_port_vlan_stp_set: 687 list_for_each_entry_continue_reverse(br_vlan, &br_port->vlan_list, head) 688 prestera_port_bridge_vlan_stp_set(port, br_vlan, br_port->stp_state); 689 return err; 690 691 err_port_stp_set: 692 prestera_port_vid_stp_set(port, vid, br_port->stp_state); 693 694 return err; 695 } 696 697 static int prestera_port_obj_attr_set(struct net_device *dev, 698 const struct switchdev_attr *attr) 699 { 700 struct prestera_port *port = netdev_priv(dev); 701 int err = 0; 702 703 switch (attr->id) { 704 case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 705 err = prestera_port_attr_stp_state_set(port, attr->orig_dev, 706 attr->u.stp_state); 707 break; 708 case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 709 if (attr->u.brport_flags & 710 ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD)) 711 err = -EINVAL; 712 break; 713 case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 714 err = prestera_port_attr_br_flags_set(port, attr->orig_dev, 715 attr->u.brport_flags); 716 break; 717 case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME: 718 err = prestera_port_attr_br_ageing_set(port, 719 attr->u.ageing_time); 720 break; 721 case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 722 err = prestera_port_attr_br_vlan_set(port, attr->orig_dev, 723 attr->u.vlan_filtering); 724 break; 725 default: 726 err = -EOPNOTSUPP; 727 } 728 729 return err; 730 } 731 732 static void 733 prestera_fdb_offload_notify(struct prestera_port *port, 734 struct switchdev_notifier_fdb_info *info) 735 { 736 struct switchdev_notifier_fdb_info send_info; 737 738 send_info.addr = info->addr; 739 send_info.vid = info->vid; 740 send_info.offloaded = true; 741 742 call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, port->dev, 743 &send_info.info, NULL); 744 } 745 746 static int prestera_port_fdb_set(struct prestera_port *port, 747 struct switchdev_notifier_fdb_info *fdb_info, 748 bool adding) 749 { 750 struct prestera_switch *sw = port->sw; 751 struct prestera_bridge_port *br_port; 752 struct prestera_bridge *bridge; 753 int err; 754 u16 vid; 755 756 br_port = prestera_bridge_port_by_dev(sw->swdev, port->dev); 757 if (!br_port) 758 return -EINVAL; 759 760 bridge = br_port->bridge; 761 762 if (bridge->vlan_enabled) 763 vid = fdb_info->vid; 764 else 765 vid = bridge->bridge_id; 766 767 if (adding) 768 err = prestera_hw_fdb_add(port, fdb_info->addr, vid, false); 769 else 770 err = prestera_hw_fdb_del(port, fdb_info->addr, vid); 771 772 return err; 773 } 774 775 static void prestera_fdb_event_work(struct work_struct *work) 776 { 777 struct switchdev_notifier_fdb_info *fdb_info; 778 struct prestera_fdb_event_work *swdev_work; 779 struct prestera_port *port; 780 struct net_device *dev; 781 int err; 782 783 swdev_work = container_of(work, struct prestera_fdb_event_work, work); 784 dev = swdev_work->dev; 785 786 rtnl_lock(); 787 788 port = prestera_port_dev_lower_find(dev); 789 if (!port) 790 goto out_unlock; 791 792 switch (swdev_work->event) { 793 case SWITCHDEV_FDB_ADD_TO_DEVICE: 794 fdb_info = &swdev_work->fdb_info; 795 if (!fdb_info->added_by_user) 796 break; 797 798 err = prestera_port_fdb_set(port, fdb_info, true); 799 if (err) 800 break; 801 802 prestera_fdb_offload_notify(port, fdb_info); 803 break; 804 805 case SWITCHDEV_FDB_DEL_TO_DEVICE: 806 fdb_info = &swdev_work->fdb_info; 807 prestera_port_fdb_set(port, fdb_info, false); 808 break; 809 } 810 811 out_unlock: 812 rtnl_unlock(); 813 814 kfree(swdev_work->fdb_info.addr); 815 kfree(swdev_work); 816 dev_put(dev); 817 } 818 819 static int prestera_switchdev_event(struct notifier_block *unused, 820 unsigned long event, void *ptr) 821 { 822 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 823 struct switchdev_notifier_fdb_info *fdb_info; 824 struct switchdev_notifier_info *info = ptr; 825 struct prestera_fdb_event_work *swdev_work; 826 struct net_device *upper; 827 int err; 828 829 if (event == SWITCHDEV_PORT_ATTR_SET) { 830 err = switchdev_handle_port_attr_set(dev, ptr, 831 prestera_netdev_check, 832 prestera_port_obj_attr_set); 833 return notifier_from_errno(err); 834 } 835 836 if (!prestera_netdev_check(dev)) 837 return NOTIFY_DONE; 838 839 upper = netdev_master_upper_dev_get_rcu(dev); 840 if (!upper) 841 return NOTIFY_DONE; 842 843 if (!netif_is_bridge_master(upper)) 844 return NOTIFY_DONE; 845 846 swdev_work = kzalloc(sizeof(*swdev_work), GFP_ATOMIC); 847 if (!swdev_work) 848 return NOTIFY_BAD; 849 850 swdev_work->event = event; 851 swdev_work->dev = dev; 852 853 switch (event) { 854 case SWITCHDEV_FDB_ADD_TO_DEVICE: 855 case SWITCHDEV_FDB_DEL_TO_DEVICE: 856 fdb_info = container_of(info, 857 struct switchdev_notifier_fdb_info, 858 info); 859 860 INIT_WORK(&swdev_work->work, prestera_fdb_event_work); 861 memcpy(&swdev_work->fdb_info, ptr, 862 sizeof(swdev_work->fdb_info)); 863 864 swdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 865 if (!swdev_work->fdb_info.addr) 866 goto out_bad; 867 868 ether_addr_copy((u8 *)swdev_work->fdb_info.addr, 869 fdb_info->addr); 870 dev_hold(dev); 871 break; 872 873 default: 874 kfree(swdev_work); 875 return NOTIFY_DONE; 876 } 877 878 queue_work(swdev_wq, &swdev_work->work); 879 return NOTIFY_DONE; 880 881 out_bad: 882 kfree(swdev_work); 883 return NOTIFY_BAD; 884 } 885 886 static int 887 prestera_port_vlan_bridge_join(struct prestera_port_vlan *port_vlan, 888 struct prestera_bridge_port *br_port) 889 { 890 struct prestera_port *port = port_vlan->port; 891 struct prestera_bridge_vlan *br_vlan; 892 u16 vid = port_vlan->vid; 893 int err; 894 895 if (port_vlan->br_port) 896 return 0; 897 898 err = prestera_hw_port_flood_set(port, br_port->flags & BR_FLOOD); 899 if (err) 900 return err; 901 902 err = prestera_hw_port_learning_set(port, br_port->flags & BR_LEARNING); 903 if (err) 904 goto err_port_learning_set; 905 906 err = prestera_port_vid_stp_set(port, vid, br_port->stp_state); 907 if (err) 908 goto err_port_vid_stp_set; 909 910 br_vlan = prestera_bridge_vlan_by_vid(br_port, vid); 911 if (!br_vlan) { 912 br_vlan = prestera_bridge_vlan_create(br_port, vid); 913 if (!br_vlan) { 914 err = -ENOMEM; 915 goto err_bridge_vlan_get; 916 } 917 } 918 919 list_add(&port_vlan->br_vlan_head, &br_vlan->port_vlan_list); 920 921 prestera_bridge_port_get(br_port); 922 port_vlan->br_port = br_port; 923 924 return 0; 925 926 err_bridge_vlan_get: 927 prestera_port_vid_stp_set(port, vid, BR_STATE_FORWARDING); 928 err_port_vid_stp_set: 929 prestera_hw_port_learning_set(port, false); 930 err_port_learning_set: 931 return err; 932 } 933 934 static int 935 prestera_bridge_port_vlan_add(struct prestera_port *port, 936 struct prestera_bridge_port *br_port, 937 u16 vid, bool is_untagged, bool is_pvid, 938 struct netlink_ext_ack *extack) 939 { 940 struct prestera_port_vlan *port_vlan; 941 u16 old_pvid = port->pvid; 942 u16 pvid; 943 int err; 944 945 if (is_pvid) 946 pvid = vid; 947 else 948 pvid = port->pvid == vid ? 0 : port->pvid; 949 950 port_vlan = prestera_port_vlan_by_vid(port, vid); 951 if (port_vlan && port_vlan->br_port != br_port) 952 return -EEXIST; 953 954 if (!port_vlan) { 955 port_vlan = prestera_port_vlan_create(port, vid, is_untagged); 956 if (IS_ERR(port_vlan)) 957 return PTR_ERR(port_vlan); 958 } else { 959 err = prestera_hw_vlan_port_set(port, vid, true, is_untagged); 960 if (err) 961 goto err_port_vlan_set; 962 } 963 964 err = prestera_port_pvid_set(port, pvid); 965 if (err) 966 goto err_port_pvid_set; 967 968 err = prestera_port_vlan_bridge_join(port_vlan, br_port); 969 if (err) 970 goto err_port_vlan_bridge_join; 971 972 return 0; 973 974 err_port_vlan_bridge_join: 975 prestera_port_pvid_set(port, old_pvid); 976 err_port_pvid_set: 977 prestera_hw_vlan_port_set(port, vid, false, false); 978 err_port_vlan_set: 979 prestera_port_vlan_destroy(port_vlan); 980 981 return err; 982 } 983 984 static void 985 prestera_bridge_port_vlan_del(struct prestera_port *port, 986 struct prestera_bridge_port *br_port, u16 vid) 987 { 988 u16 pvid = port->pvid == vid ? 0 : port->pvid; 989 struct prestera_port_vlan *port_vlan; 990 991 port_vlan = prestera_port_vlan_by_vid(port, vid); 992 if (WARN_ON(!port_vlan)) 993 return; 994 995 prestera_port_vlan_bridge_leave(port_vlan); 996 prestera_port_pvid_set(port, pvid); 997 prestera_port_vlan_destroy(port_vlan); 998 } 999 1000 static int prestera_port_vlans_add(struct prestera_port *port, 1001 const struct switchdev_obj_port_vlan *vlan, 1002 struct netlink_ext_ack *extack) 1003 { 1004 bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED; 1005 bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID; 1006 struct net_device *dev = vlan->obj.orig_dev; 1007 struct prestera_bridge_port *br_port; 1008 struct prestera_switch *sw = port->sw; 1009 struct prestera_bridge *bridge; 1010 1011 if (netif_is_bridge_master(dev)) 1012 return 0; 1013 1014 br_port = prestera_bridge_port_by_dev(sw->swdev, dev); 1015 if (WARN_ON(!br_port)) 1016 return -EINVAL; 1017 1018 bridge = br_port->bridge; 1019 if (!bridge->vlan_enabled) 1020 return 0; 1021 1022 return prestera_bridge_port_vlan_add(port, br_port, 1023 vlan->vid, flag_untagged, 1024 flag_pvid, extack); 1025 } 1026 1027 static int prestera_port_obj_add(struct net_device *dev, 1028 const struct switchdev_obj *obj, 1029 struct netlink_ext_ack *extack) 1030 { 1031 struct prestera_port *port = netdev_priv(dev); 1032 const struct switchdev_obj_port_vlan *vlan; 1033 1034 switch (obj->id) { 1035 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1036 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj); 1037 return prestera_port_vlans_add(port, vlan, extack); 1038 default: 1039 return -EOPNOTSUPP; 1040 } 1041 } 1042 1043 static int prestera_port_vlans_del(struct prestera_port *port, 1044 const struct switchdev_obj_port_vlan *vlan) 1045 { 1046 struct net_device *dev = vlan->obj.orig_dev; 1047 struct prestera_bridge_port *br_port; 1048 struct prestera_switch *sw = port->sw; 1049 1050 if (netif_is_bridge_master(dev)) 1051 return -EOPNOTSUPP; 1052 1053 br_port = prestera_bridge_port_by_dev(sw->swdev, dev); 1054 if (WARN_ON(!br_port)) 1055 return -EINVAL; 1056 1057 if (!br_port->bridge->vlan_enabled) 1058 return 0; 1059 1060 prestera_bridge_port_vlan_del(port, br_port, vlan->vid); 1061 1062 return 0; 1063 } 1064 1065 static int prestera_port_obj_del(struct net_device *dev, 1066 const struct switchdev_obj *obj) 1067 { 1068 struct prestera_port *port = netdev_priv(dev); 1069 1070 switch (obj->id) { 1071 case SWITCHDEV_OBJ_ID_PORT_VLAN: 1072 return prestera_port_vlans_del(port, SWITCHDEV_OBJ_PORT_VLAN(obj)); 1073 default: 1074 return -EOPNOTSUPP; 1075 } 1076 } 1077 1078 static int prestera_switchdev_blk_event(struct notifier_block *unused, 1079 unsigned long event, void *ptr) 1080 { 1081 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 1082 int err; 1083 1084 switch (event) { 1085 case SWITCHDEV_PORT_OBJ_ADD: 1086 err = switchdev_handle_port_obj_add(dev, ptr, 1087 prestera_netdev_check, 1088 prestera_port_obj_add); 1089 break; 1090 case SWITCHDEV_PORT_OBJ_DEL: 1091 err = switchdev_handle_port_obj_del(dev, ptr, 1092 prestera_netdev_check, 1093 prestera_port_obj_del); 1094 break; 1095 case SWITCHDEV_PORT_ATTR_SET: 1096 err = switchdev_handle_port_attr_set(dev, ptr, 1097 prestera_netdev_check, 1098 prestera_port_obj_attr_set); 1099 break; 1100 default: 1101 err = -EOPNOTSUPP; 1102 } 1103 1104 return notifier_from_errno(err); 1105 } 1106 1107 static void prestera_fdb_event(struct prestera_switch *sw, 1108 struct prestera_event *evt, void *arg) 1109 { 1110 struct switchdev_notifier_fdb_info info; 1111 struct prestera_port *port; 1112 1113 port = prestera_find_port(sw, evt->fdb_evt.port_id); 1114 if (!port) 1115 return; 1116 1117 info.addr = evt->fdb_evt.data.mac; 1118 info.vid = evt->fdb_evt.vid; 1119 info.offloaded = true; 1120 1121 rtnl_lock(); 1122 1123 switch (evt->id) { 1124 case PRESTERA_FDB_EVENT_LEARNED: 1125 call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE, 1126 port->dev, &info.info, NULL); 1127 break; 1128 case PRESTERA_FDB_EVENT_AGED: 1129 call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE, 1130 port->dev, &info.info, NULL); 1131 break; 1132 } 1133 1134 rtnl_unlock(); 1135 } 1136 1137 static int prestera_fdb_init(struct prestera_switch *sw) 1138 { 1139 int err; 1140 1141 err = prestera_hw_event_handler_register(sw, PRESTERA_EVENT_TYPE_FDB, 1142 prestera_fdb_event, NULL); 1143 if (err) 1144 return err; 1145 1146 err = prestera_hw_switch_ageing_set(sw, PRESTERA_DEFAULT_AGEING_TIME_MS); 1147 if (err) 1148 goto err_ageing_set; 1149 1150 return 0; 1151 1152 err_ageing_set: 1153 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1154 prestera_fdb_event); 1155 return err; 1156 } 1157 1158 static void prestera_fdb_fini(struct prestera_switch *sw) 1159 { 1160 prestera_hw_event_handler_unregister(sw, PRESTERA_EVENT_TYPE_FDB, 1161 prestera_fdb_event); 1162 } 1163 1164 static int prestera_switchdev_handler_init(struct prestera_switchdev *swdev) 1165 { 1166 int err; 1167 1168 swdev->swdev_nb.notifier_call = prestera_switchdev_event; 1169 err = register_switchdev_notifier(&swdev->swdev_nb); 1170 if (err) 1171 goto err_register_swdev_notifier; 1172 1173 swdev->swdev_nb_blk.notifier_call = prestera_switchdev_blk_event; 1174 err = register_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1175 if (err) 1176 goto err_register_blk_swdev_notifier; 1177 1178 return 0; 1179 1180 err_register_blk_swdev_notifier: 1181 unregister_switchdev_notifier(&swdev->swdev_nb); 1182 err_register_swdev_notifier: 1183 destroy_workqueue(swdev_wq); 1184 return err; 1185 } 1186 1187 static void prestera_switchdev_handler_fini(struct prestera_switchdev *swdev) 1188 { 1189 unregister_switchdev_blocking_notifier(&swdev->swdev_nb_blk); 1190 unregister_switchdev_notifier(&swdev->swdev_nb); 1191 } 1192 1193 int prestera_switchdev_init(struct prestera_switch *sw) 1194 { 1195 struct prestera_switchdev *swdev; 1196 int err; 1197 1198 swdev = kzalloc(sizeof(*swdev), GFP_KERNEL); 1199 if (!swdev) 1200 return -ENOMEM; 1201 1202 sw->swdev = swdev; 1203 swdev->sw = sw; 1204 1205 INIT_LIST_HEAD(&swdev->bridge_list); 1206 1207 swdev_wq = alloc_ordered_workqueue("%s_ordered", 0, "prestera_br"); 1208 if (!swdev_wq) { 1209 err = -ENOMEM; 1210 goto err_alloc_wq; 1211 } 1212 1213 err = prestera_switchdev_handler_init(swdev); 1214 if (err) 1215 goto err_swdev_init; 1216 1217 err = prestera_fdb_init(sw); 1218 if (err) 1219 goto err_fdb_init; 1220 1221 return 0; 1222 1223 err_fdb_init: 1224 err_swdev_init: 1225 destroy_workqueue(swdev_wq); 1226 err_alloc_wq: 1227 kfree(swdev); 1228 1229 return err; 1230 } 1231 1232 void prestera_switchdev_fini(struct prestera_switch *sw) 1233 { 1234 struct prestera_switchdev *swdev = sw->swdev; 1235 1236 prestera_fdb_fini(sw); 1237 prestera_switchdev_handler_fini(swdev); 1238 destroy_workqueue(swdev_wq); 1239 kfree(swdev); 1240 } 1241