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