drivers/net/ethernet/marvell/prestera/prestera_switchdev.c

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