drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/types.h>
   6 #include <linux/netdevice.h>
   7 #include <linux/etherdevice.h>
   8 #include <linux/slab.h>
   9 #include <linux/device.h>
  10 #include <linux/skbuff.h>
  11 #include <linux/if_vlan.h>
  12 #include <linux/if_bridge.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/jiffies.h>
  15 #include <linux/rtnetlink.h>
  16 #include <linux/netlink.h>
  17 #include <net/switchdev.h>
  18
  19 #include "spectrum_span.h"
  20 #include "spectrum_router.h"
  21 #include "spectrum_switchdev.h"
  22 #include "spectrum.h"
  23 #include "core.h"
  24 #include "reg.h"
  25
  26 struct mlxsw_sp_bridge_ops;
  27
  28 struct mlxsw_sp_bridge {
  29         struct mlxsw_sp *mlxsw_sp;
  30         struct {
  31                 struct delayed_work dw;
  32 #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
  33                 unsigned int interval; /* ms */
  34         } fdb_notify;
  35 #define MLXSW_SP_MIN_AGEING_TIME 10
  36 #define MLXSW_SP_MAX_AGEING_TIME 1000000
  37 #define MLXSW_SP_DEFAULT_AGEING_TIME 300
  38         u32 ageing_time;
  39         bool vlan_enabled_exists;
  40         struct list_head bridges_list;
  41         DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
  42         const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
  43         const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
  44 };
  45
  46 struct mlxsw_sp_bridge_device {
  47         struct net_device *dev;
  48         struct list_head list;
  49         struct list_head ports_list;
  50         struct list_head mids_list;
  51         u8 vlan_enabled:1,
  52            multicast_enabled:1,
  53            mrouter:1;
  54         const struct mlxsw_sp_bridge_ops *ops;
  55 };
  56
  57 struct mlxsw_sp_bridge_port {
  58         struct net_device *dev;
  59         struct mlxsw_sp_bridge_device *bridge_device;
  60         struct list_head list;
  61         struct list_head vlans_list;
  62         unsigned int ref_count;
  63         u8 stp_state;
  64         unsigned long flags;
  65         bool mrouter;
  66         bool lagged;
  67         union {
  68                 u16 lag_id;
  69                 u16 system_port;
  70         };
  71 };
  72
  73 struct mlxsw_sp_bridge_vlan {
  74         struct list_head list;
  75         struct list_head port_vlan_list;
  76         u16 vid;
  77 };
  78
  79 struct mlxsw_sp_bridge_ops {
  80         int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
  81                          struct mlxsw_sp_bridge_port *bridge_port,
  82                          struct mlxsw_sp_port *mlxsw_sp_port,
  83                          struct netlink_ext_ack *extack);
  84         void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
  85                            struct mlxsw_sp_bridge_port *bridge_port,
  86                            struct mlxsw_sp_port *mlxsw_sp_port);
  87         struct mlxsw_sp_fid *
  88                 (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
  89                            u16 vid);
  90 };
  91
  92 static int
  93 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
  94                                struct mlxsw_sp_bridge_port *bridge_port,
  95                                u16 fid_index);
  96
  97 static void
  98 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
  99                                struct mlxsw_sp_bridge_port *bridge_port);
 100
 101 static void
 102 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
 103                                    struct mlxsw_sp_bridge_device
 104                                    *bridge_device);
 105
 106 static void
 107 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
 108                                  struct mlxsw_sp_bridge_port *bridge_port,
 109                                  bool add);
 110
 111 static struct mlxsw_sp_bridge_device *
 112 mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
 113                             const struct net_device *br_dev)
 114 {
 115         struct mlxsw_sp_bridge_device *bridge_device;
 116
 117         list_for_each_entry(bridge_device, &bridge->bridges_list, list)
 118                 if (bridge_device->dev == br_dev)
 119                         return bridge_device;
 120
 121         return NULL;
 122 }
 123
 124 bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
 125                                          const struct net_device *br_dev)
 126 {
 127         return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
 128 }
 129
 130 static struct mlxsw_sp_bridge_device *
 131 mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
 132                               struct net_device *br_dev)
 133 {
 134         struct device *dev = bridge->mlxsw_sp->bus_info->dev;
 135         struct mlxsw_sp_bridge_device *bridge_device;
 136         bool vlan_enabled = br_vlan_enabled(br_dev);
 137
 138         if (vlan_enabled && bridge->vlan_enabled_exists) {
 139                 dev_err(dev, "Only one VLAN-aware bridge is supported\n");
 140                 return ERR_PTR(-EINVAL);
 141         }
 142
 143         bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
 144         if (!bridge_device)
 145                 return ERR_PTR(-ENOMEM);
 146
 147         bridge_device->dev = br_dev;
 148         bridge_device->vlan_enabled = vlan_enabled;
 149         bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
 150         bridge_device->mrouter = br_multicast_router(br_dev);
 151         INIT_LIST_HEAD(&bridge_device->ports_list);
 152         if (vlan_enabled) {
 153                 bridge->vlan_enabled_exists = true;
 154                 bridge_device->ops = bridge->bridge_8021q_ops;
 155         } else {
 156                 bridge_device->ops = bridge->bridge_8021d_ops;
 157         }
 158         INIT_LIST_HEAD(&bridge_device->mids_list);
 159         list_add(&bridge_device->list, &bridge->bridges_list);
 160
 161         return bridge_device;
 162 }
 163
 164 static void
 165 mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
 166                                struct mlxsw_sp_bridge_device *bridge_device)
 167 {
 168         list_del(&bridge_device->list);
 169         if (bridge_device->vlan_enabled)
 170                 bridge->vlan_enabled_exists = false;
 171         WARN_ON(!list_empty(&bridge_device->ports_list));
 172         WARN_ON(!list_empty(&bridge_device->mids_list));
 173         kfree(bridge_device);
 174 }
 175
 176 static struct mlxsw_sp_bridge_device *
 177 mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
 178                            struct net_device *br_dev)
 179 {
 180         struct mlxsw_sp_bridge_device *bridge_device;
 181
 182         bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
 183         if (bridge_device)
 184                 return bridge_device;
 185
 186         return mlxsw_sp_bridge_device_create(bridge, br_dev);
 187 }
 188
 189 static void
 190 mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
 191                            struct mlxsw_sp_bridge_device *bridge_device)
 192 {
 193         if (list_empty(&bridge_device->ports_list))
 194                 mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
 195 }
 196
 197 static struct mlxsw_sp_bridge_port *
 198 __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
 199                             const struct net_device *brport_dev)
 200 {
 201         struct mlxsw_sp_bridge_port *bridge_port;
 202
 203         list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
 204                 if (bridge_port->dev == brport_dev)
 205                         return bridge_port;
 206         }
 207
 208         return NULL;
 209 }
 210
 211 struct mlxsw_sp_bridge_port *
 212 mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
 213                           struct net_device *brport_dev)
 214 {
 215         struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
 216         struct mlxsw_sp_bridge_device *bridge_device;
 217
 218         if (!br_dev)
 219                 return NULL;
 220
 221         bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
 222         if (!bridge_device)
 223                 return NULL;
 224
 225         return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
 226 }
 227
 228 static struct mlxsw_sp_bridge_port *
 229 mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
 230                             struct net_device *brport_dev)
 231 {
 232         struct mlxsw_sp_bridge_port *bridge_port;
 233         struct mlxsw_sp_port *mlxsw_sp_port;
 234
 235         bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
 236         if (!bridge_port)
 237                 return NULL;
 238
 239         mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
 240         bridge_port->lagged = mlxsw_sp_port->lagged;
 241         if (bridge_port->lagged)
 242                 bridge_port->lag_id = mlxsw_sp_port->lag_id;
 243         else
 244                 bridge_port->system_port = mlxsw_sp_port->local_port;
 245         bridge_port->dev = brport_dev;
 246         bridge_port->bridge_device = bridge_device;
 247         bridge_port->stp_state = BR_STATE_DISABLED;
 248         bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
 249                              BR_MCAST_FLOOD;
 250         INIT_LIST_HEAD(&bridge_port->vlans_list);
 251         list_add(&bridge_port->list, &bridge_device->ports_list);
 252         bridge_port->ref_count = 1;
 253
 254         return bridge_port;
 255 }
 256
 257 static void
 258 mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
 259 {
 260         list_del(&bridge_port->list);
 261         WARN_ON(!list_empty(&bridge_port->vlans_list));
 262         kfree(bridge_port);
 263 }
 264
 265 static bool
 266 mlxsw_sp_bridge_port_should_destroy(const struct mlxsw_sp_bridge_port *
 267                                     bridge_port)
 268 {
 269         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_port->dev);
 270
 271         /* In case ports were pulled from out of a bridged LAG, then
 272          * it's possible the reference count isn't zero, yet the bridge
 273          * port should be destroyed, as it's no longer an upper of ours.
 274          */
 275         if (!mlxsw_sp && list_empty(&bridge_port->vlans_list))
 276                 return true;
 277         else if (bridge_port->ref_count == 0)
 278                 return true;
 279         else
 280                 return false;
 281 }
 282
 283 static struct mlxsw_sp_bridge_port *
 284 mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
 285                          struct net_device *brport_dev)
 286 {
 287         struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
 288         struct mlxsw_sp_bridge_device *bridge_device;
 289         struct mlxsw_sp_bridge_port *bridge_port;
 290         int err;
 291
 292         bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
 293         if (bridge_port) {
 294                 bridge_port->ref_count++;
 295                 return bridge_port;
 296         }
 297
 298         bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev);
 299         if (IS_ERR(bridge_device))
 300                 return ERR_CAST(bridge_device);
 301
 302         bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev);
 303         if (!bridge_port) {
 304                 err = -ENOMEM;
 305                 goto err_bridge_port_create;
 306         }
 307
 308         return bridge_port;
 309
 310 err_bridge_port_create:
 311         mlxsw_sp_bridge_device_put(bridge, bridge_device);
 312         return ERR_PTR(err);
 313 }
 314
 315 static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
 316                                      struct mlxsw_sp_bridge_port *bridge_port)
 317 {
 318         struct mlxsw_sp_bridge_device *bridge_device;
 319
 320         bridge_port->ref_count--;
 321         if (!mlxsw_sp_bridge_port_should_destroy(bridge_port))
 322                 return;
 323         bridge_device = bridge_port->bridge_device;
 324         mlxsw_sp_bridge_port_destroy(bridge_port);
 325         mlxsw_sp_bridge_device_put(bridge, bridge_device);
 326 }
 327
 328 static struct mlxsw_sp_port_vlan *
 329 mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
 330                                   const struct mlxsw_sp_bridge_device *
 331                                   bridge_device,
 332                                   u16 vid)
 333 {
 334         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 335
 336         list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
 337                             list) {
 338                 if (!mlxsw_sp_port_vlan->bridge_port)
 339                         continue;
 340                 if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
 341                     bridge_device)
 342                         continue;
 343                 if (bridge_device->vlan_enabled &&
 344                     mlxsw_sp_port_vlan->vid != vid)
 345                         continue;
 346                 return mlxsw_sp_port_vlan;
 347         }
 348
 349         return NULL;
 350 }
 351
 352 static struct mlxsw_sp_port_vlan*
 353 mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
 354                                u16 fid_index)
 355 {
 356         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 357
 358         list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
 359                             list) {
 360                 struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
 361
 362                 if (fid && mlxsw_sp_fid_index(fid) == fid_index)
 363                         return mlxsw_sp_port_vlan;
 364         }
 365
 366         return NULL;
 367 }
 368
 369 static struct mlxsw_sp_bridge_vlan *
 370 mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
 371                           u16 vid)
 372 {
 373         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 374
 375         list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
 376                 if (bridge_vlan->vid == vid)
 377                         return bridge_vlan;
 378         }
 379
 380         return NULL;
 381 }
 382
 383 static struct mlxsw_sp_bridge_vlan *
 384 mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
 385 {
 386         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 387
 388         bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
 389         if (!bridge_vlan)
 390                 return NULL;
 391
 392         INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
 393         bridge_vlan->vid = vid;
 394         list_add(&bridge_vlan->list, &bridge_port->vlans_list);
 395
 396         return bridge_vlan;
 397 }
 398
 399 static void
 400 mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
 401 {
 402         list_del(&bridge_vlan->list);
 403         WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
 404         kfree(bridge_vlan);
 405 }
 406
 407 static struct mlxsw_sp_bridge_vlan *
 408 mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
 409 {
 410         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 411
 412         bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
 413         if (bridge_vlan)
 414                 return bridge_vlan;
 415
 416         return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
 417 }
 418
 419 static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
 420 {
 421         if (list_empty(&bridge_vlan->port_vlan_list))
 422                 mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
 423 }
 424
 425 static void mlxsw_sp_port_bridge_flags_get(struct mlxsw_sp_bridge *bridge,
 426                                            struct net_device *dev,
 427                                            unsigned long *brport_flags)
 428 {
 429         struct mlxsw_sp_bridge_port *bridge_port;
 430
 431         bridge_port = mlxsw_sp_bridge_port_find(bridge, dev);
 432         if (WARN_ON(!bridge_port))
 433                 return;
 434
 435         memcpy(brport_flags, &bridge_port->flags, sizeof(*brport_flags));
 436 }
 437
 438 static int mlxsw_sp_port_attr_get(struct net_device *dev,
 439                                   struct switchdev_attr *attr)
 440 {
 441         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 442         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 443
 444         switch (attr->id) {
 445         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
 446                 attr->u.ppid.id_len = sizeof(mlxsw_sp->base_mac);
 447                 memcpy(&attr->u.ppid.id, &mlxsw_sp->base_mac,
 448                        attr->u.ppid.id_len);
 449                 break;
 450         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
 451                 mlxsw_sp_port_bridge_flags_get(mlxsw_sp->bridge, attr->orig_dev,
 452                                                &attr->u.brport_flags);
 453                 break;
 454         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS_SUPPORT:
 455                 attr->u.brport_flags_support = BR_LEARNING | BR_FLOOD |
 456                                                BR_MCAST_FLOOD;
 457                 break;
 458         default:
 459                 return -EOPNOTSUPP;
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int
 466 mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
 467                                   struct mlxsw_sp_bridge_vlan *bridge_vlan,
 468                                   u8 state)
 469 {
 470         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 471
 472         list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
 473                             bridge_vlan_node) {
 474                 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
 475                         continue;
 476                 return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
 477                                                  bridge_vlan->vid, state);
 478         }
 479
 480         return 0;
 481 }
 482
 483 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
 484                                             struct switchdev_trans *trans,
 485                                             struct net_device *orig_dev,
 486                                             u8 state)
 487 {
 488         struct mlxsw_sp_bridge_port *bridge_port;
 489         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 490         int err;
 491
 492         if (switchdev_trans_ph_prepare(trans))
 493                 return 0;
 494
 495         /* It's possible we failed to enslave the port, yet this
 496          * operation is executed due to it being deferred.
 497          */
 498         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
 499                                                 orig_dev);
 500         if (!bridge_port)
 501                 return 0;
 502
 503         list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
 504                 err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
 505                                                         bridge_vlan, state);
 506                 if (err)
 507                         goto err_port_bridge_vlan_stp_set;
 508         }
 509
 510         bridge_port->stp_state = state;
 511
 512         return 0;
 513
 514 err_port_bridge_vlan_stp_set:
 515         list_for_each_entry_continue_reverse(bridge_vlan,
 516                                              &bridge_port->vlans_list, list)
 517                 mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
 518                                                   bridge_port->stp_state);
 519         return err;
 520 }
 521
 522 static int
 523 mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
 524                                     struct mlxsw_sp_bridge_vlan *bridge_vlan,
 525                                     enum mlxsw_sp_flood_type packet_type,
 526                                     bool member)
 527 {
 528         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 529
 530         list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
 531                             bridge_vlan_node) {
 532                 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
 533                         continue;
 534                 return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
 535                                               packet_type,
 536                                               mlxsw_sp_port->local_port,
 537                                               member);
 538         }
 539
 540         return 0;
 541 }
 542
 543 static int
 544 mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
 545                                      struct mlxsw_sp_bridge_port *bridge_port,
 546                                      enum mlxsw_sp_flood_type packet_type,
 547                                      bool member)
 548 {
 549         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 550         int err;
 551
 552         list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
 553                 err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
 554                                                           bridge_vlan,
 555                                                           packet_type,
 556                                                           member);
 557                 if (err)
 558                         goto err_port_bridge_vlan_flood_set;
 559         }
 560
 561         return 0;
 562
 563 err_port_bridge_vlan_flood_set:
 564         list_for_each_entry_continue_reverse(bridge_vlan,
 565                                              &bridge_port->vlans_list, list)
 566                 mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
 567                                                     packet_type, !member);
 568         return err;
 569 }
 570
 571 static int
 572 mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
 573                                        struct mlxsw_sp_bridge_vlan *bridge_vlan,
 574                                        bool set)
 575 {
 576         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 577         u16 vid = bridge_vlan->vid;
 578
 579         list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
 580                             bridge_vlan_node) {
 581                 if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
 582                         continue;
 583                 return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
 584         }
 585
 586         return 0;
 587 }
 588
 589 static int
 590 mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
 591                                   struct mlxsw_sp_bridge_port *bridge_port,
 592                                   bool set)
 593 {
 594         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 595         int err;
 596
 597         list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
 598                 err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
 599                                                              bridge_vlan, set);
 600                 if (err)
 601                         goto err_port_bridge_vlan_learning_set;
 602         }
 603
 604         return 0;
 605
 606 err_port_bridge_vlan_learning_set:
 607         list_for_each_entry_continue_reverse(bridge_vlan,
 608                                              &bridge_port->vlans_list, list)
 609                 mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
 610                                                        bridge_vlan, !set);
 611         return err;
 612 }
 613
 614 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
 615                                            struct switchdev_trans *trans,
 616                                            struct net_device *orig_dev,
 617                                            unsigned long brport_flags)
 618 {
 619         struct mlxsw_sp_bridge_port *bridge_port;
 620         int err;
 621
 622         if (switchdev_trans_ph_prepare(trans))
 623                 return 0;
 624
 625         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
 626                                                 orig_dev);
 627         if (!bridge_port)
 628                 return 0;
 629
 630         err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
 631                                                    MLXSW_SP_FLOOD_TYPE_UC,
 632                                                    brport_flags & BR_FLOOD);
 633         if (err)
 634                 return err;
 635
 636         err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port, bridge_port,
 637                                                 brport_flags & BR_LEARNING);
 638         if (err)
 639                 return err;
 640
 641         if (bridge_port->bridge_device->multicast_enabled)
 642                 goto out;
 643
 644         err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
 645                                                    MLXSW_SP_FLOOD_TYPE_MC,
 646                                                    brport_flags &
 647                                                    BR_MCAST_FLOOD);
 648         if (err)
 649                 return err;
 650
 651 out:
 652         memcpy(&bridge_port->flags, &brport_flags, sizeof(brport_flags));
 653         return 0;
 654 }
 655
 656 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
 657 {
 658         char sfdat_pl[MLXSW_REG_SFDAT_LEN];
 659         int err;
 660
 661         mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
 662         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
 663         if (err)
 664                 return err;
 665         mlxsw_sp->bridge->ageing_time = ageing_time;
 666         return 0;
 667 }
 668
 669 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
 670                                             struct switchdev_trans *trans,
 671                                             unsigned long ageing_clock_t)
 672 {
 673         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 674         unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
 675         u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
 676
 677         if (switchdev_trans_ph_prepare(trans)) {
 678                 if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
 679                     ageing_time > MLXSW_SP_MAX_AGEING_TIME)
 680                         return -ERANGE;
 681                 else
 682                         return 0;
 683         }
 684
 685         return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
 686 }
 687
 688 static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
 689                                           struct switchdev_trans *trans,
 690                                           struct net_device *orig_dev,
 691                                           bool vlan_enabled)
 692 {
 693         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 694         struct mlxsw_sp_bridge_device *bridge_device;
 695
 696         if (!switchdev_trans_ph_prepare(trans))
 697                 return 0;
 698
 699         bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
 700         if (WARN_ON(!bridge_device))
 701                 return -EINVAL;
 702
 703         if (bridge_device->vlan_enabled == vlan_enabled)
 704                 return 0;
 705
 706         netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
 707         return -EINVAL;
 708 }
 709
 710 static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
 711                                           struct switchdev_trans *trans,
 712                                           struct net_device *orig_dev,
 713                                           bool is_port_mrouter)
 714 {
 715         struct mlxsw_sp_bridge_port *bridge_port;
 716         int err;
 717
 718         if (switchdev_trans_ph_prepare(trans))
 719                 return 0;
 720
 721         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
 722                                                 orig_dev);
 723         if (!bridge_port)
 724                 return 0;
 725
 726         if (!bridge_port->bridge_device->multicast_enabled)
 727                 goto out;
 728
 729         err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
 730                                                    MLXSW_SP_FLOOD_TYPE_MC,
 731                                                    is_port_mrouter);
 732         if (err)
 733                 return err;
 734
 735         mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
 736                                          is_port_mrouter);
 737 out:
 738         bridge_port->mrouter = is_port_mrouter;
 739         return 0;
 740 }
 741
 742 static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
 743 {
 744         const struct mlxsw_sp_bridge_device *bridge_device;
 745
 746         bridge_device = bridge_port->bridge_device;
 747         return bridge_device->multicast_enabled ? bridge_port->mrouter :
 748                                         bridge_port->flags & BR_MCAST_FLOOD;
 749 }
 750
 751 static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
 752                                          struct switchdev_trans *trans,
 753                                          struct net_device *orig_dev,
 754                                          bool mc_disabled)
 755 {
 756         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 757         struct mlxsw_sp_bridge_device *bridge_device;
 758         struct mlxsw_sp_bridge_port *bridge_port;
 759         int err;
 760
 761         if (switchdev_trans_ph_prepare(trans))
 762                 return 0;
 763
 764         /* It's possible we failed to enslave the port, yet this
 765          * operation is executed due to it being deferred.
 766          */
 767         bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
 768         if (!bridge_device)
 769                 return 0;
 770
 771         if (bridge_device->multicast_enabled != !mc_disabled) {
 772                 bridge_device->multicast_enabled = !mc_disabled;
 773                 mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port,
 774                                                    bridge_device);
 775         }
 776
 777         list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
 778                 enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
 779                 bool member = mlxsw_sp_mc_flood(bridge_port);
 780
 781                 err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
 782                                                            bridge_port,
 783                                                            packet_type, member);
 784                 if (err)
 785                         return err;
 786         }
 787
 788         bridge_device->multicast_enabled = !mc_disabled;
 789
 790         return 0;
 791 }
 792
 793 static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp,
 794                                          u16 mid_idx, bool add)
 795 {
 796         char *smid_pl;
 797         int err;
 798
 799         smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
 800         if (!smid_pl)
 801                 return -ENOMEM;
 802
 803         mlxsw_reg_smid_pack(smid_pl, mid_idx,
 804                             mlxsw_sp_router_port(mlxsw_sp), add);
 805         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
 806         kfree(smid_pl);
 807         return err;
 808 }
 809
 810 static void
 811 mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
 812                                    struct mlxsw_sp_bridge_device *bridge_device,
 813                                    bool add)
 814 {
 815         struct mlxsw_sp_mid *mid;
 816
 817         list_for_each_entry(mid, &bridge_device->mids_list, list)
 818                 mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add);
 819 }
 820
 821 static int
 822 mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
 823                                   struct switchdev_trans *trans,
 824                                   struct net_device *orig_dev,
 825                                   bool is_mrouter)
 826 {
 827         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 828         struct mlxsw_sp_bridge_device *bridge_device;
 829
 830         if (switchdev_trans_ph_prepare(trans))
 831                 return 0;
 832
 833         /* It's possible we failed to enslave the port, yet this
 834          * operation is executed due to it being deferred.
 835          */
 836         bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
 837         if (!bridge_device)
 838                 return 0;
 839
 840         if (bridge_device->mrouter != is_mrouter)
 841                 mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
 842                                                    is_mrouter);
 843         bridge_device->mrouter = is_mrouter;
 844         return 0;
 845 }
 846
 847 static int mlxsw_sp_port_attr_set(struct net_device *dev,
 848                                   const struct switchdev_attr *attr,
 849                                   struct switchdev_trans *trans)
 850 {
 851         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 852         int err;
 853
 854         switch (attr->id) {
 855         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
 856                 err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port, trans,
 857                                                        attr->orig_dev,
 858                                                        attr->u.stp_state);
 859                 break;
 860         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
 861                 err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port, trans,
 862                                                       attr->orig_dev,
 863                                                       attr->u.brport_flags);
 864                 break;
 865         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
 866                 err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port, trans,
 867                                                        attr->u.ageing_time);
 868                 break;
 869         case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
 870                 err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port, trans,
 871                                                      attr->orig_dev,
 872                                                      attr->u.vlan_filtering);
 873                 break;
 874         case SWITCHDEV_ATTR_ID_PORT_MROUTER:
 875                 err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port, trans,
 876                                                      attr->orig_dev,
 877                                                      attr->u.mrouter);
 878                 break;
 879         case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
 880                 err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port, trans,
 881                                                     attr->orig_dev,
 882                                                     attr->u.mc_disabled);
 883                 break;
 884         case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
 885                 err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port, trans,
 886                                                         attr->orig_dev,
 887                                                         attr->u.mrouter);
 888                 break;
 889         default:
 890                 err = -EOPNOTSUPP;
 891                 break;
 892         }
 893
 894         if (switchdev_trans_ph_commit(trans))
 895                 mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
 896
 897         return err;
 898 }
 899
 900 static int
 901 mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
 902                             struct mlxsw_sp_bridge_port *bridge_port)
 903 {
 904         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
 905         struct mlxsw_sp_bridge_device *bridge_device;
 906         u8 local_port = mlxsw_sp_port->local_port;
 907         u16 vid = mlxsw_sp_port_vlan->vid;
 908         struct mlxsw_sp_fid *fid;
 909         int err;
 910
 911         bridge_device = bridge_port->bridge_device;
 912         fid = bridge_device->ops->fid_get(bridge_device, vid);
 913         if (IS_ERR(fid))
 914                 return PTR_ERR(fid);
 915
 916         err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
 917                                      bridge_port->flags & BR_FLOOD);
 918         if (err)
 919                 goto err_fid_uc_flood_set;
 920
 921         err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
 922                                      mlxsw_sp_mc_flood(bridge_port));
 923         if (err)
 924                 goto err_fid_mc_flood_set;
 925
 926         err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
 927                                      true);
 928         if (err)
 929                 goto err_fid_bc_flood_set;
 930
 931         err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
 932         if (err)
 933                 goto err_fid_port_vid_map;
 934
 935         mlxsw_sp_port_vlan->fid = fid;
 936
 937         return 0;
 938
 939 err_fid_port_vid_map:
 940         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
 941 err_fid_bc_flood_set:
 942         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
 943 err_fid_mc_flood_set:
 944         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
 945 err_fid_uc_flood_set:
 946         mlxsw_sp_fid_put(fid);
 947         return err;
 948 }
 949
 950 static void
 951 mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
 952 {
 953         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
 954         struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
 955         u8 local_port = mlxsw_sp_port->local_port;
 956         u16 vid = mlxsw_sp_port_vlan->vid;
 957
 958         mlxsw_sp_port_vlan->fid = NULL;
 959         mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
 960         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
 961         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
 962         mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
 963         mlxsw_sp_fid_put(fid);
 964 }
 965
 966 static u16
 967 mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
 968                              u16 vid, bool is_pvid)
 969 {
 970         if (is_pvid)
 971                 return vid;
 972         else if (mlxsw_sp_port->pvid == vid)
 973                 return 0;       /* Dis-allow untagged packets */
 974         else
 975                 return mlxsw_sp_port->pvid;
 976 }
 977
 978 static int
 979 mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
 980                                struct mlxsw_sp_bridge_port *bridge_port)
 981 {
 982         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
 983         struct mlxsw_sp_bridge_vlan *bridge_vlan;
 984         u16 vid = mlxsw_sp_port_vlan->vid;
 985         int err;
 986
 987         /* No need to continue if only VLAN flags were changed */
 988         if (mlxsw_sp_port_vlan->bridge_port) {
 989                 mlxsw_sp_port_vlan_put(mlxsw_sp_port_vlan);
 990                 return 0;
 991         }
 992
 993         err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port);
 994         if (err)
 995                 return err;
 996
 997         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
 998                                              bridge_port->flags & BR_LEARNING);
 999         if (err)
1000                 goto err_port_vid_learning_set;
1001
1002         err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
1003                                         bridge_port->stp_state);
1004         if (err)
1005                 goto err_port_vid_stp_set;
1006
1007         bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
1008         if (!bridge_vlan) {
1009                 err = -ENOMEM;
1010                 goto err_bridge_vlan_get;
1011         }
1012
1013         list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
1014                  &bridge_vlan->port_vlan_list);
1015
1016         mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
1017                                  bridge_port->dev);
1018         mlxsw_sp_port_vlan->bridge_port = bridge_port;
1019
1020         return 0;
1021
1022 err_bridge_vlan_get:
1023         mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1024 err_port_vid_stp_set:
1025         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1026 err_port_vid_learning_set:
1027         mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1028         return err;
1029 }
1030
1031 void
1032 mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1033 {
1034         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1035         struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1036         struct mlxsw_sp_bridge_vlan *bridge_vlan;
1037         struct mlxsw_sp_bridge_port *bridge_port;
1038         u16 vid = mlxsw_sp_port_vlan->vid;
1039         bool last_port, last_vlan;
1040
1041         if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
1042                     mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
1043                 return;
1044
1045         bridge_port = mlxsw_sp_port_vlan->bridge_port;
1046         last_vlan = list_is_singular(&bridge_port->vlans_list);
1047         bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
1048         last_port = list_is_singular(&bridge_vlan->port_vlan_list);
1049
1050         list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
1051         mlxsw_sp_bridge_vlan_put(bridge_vlan);
1052         mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1053         mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1054         if (last_port)
1055                 mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
1056                                                bridge_port,
1057                                                mlxsw_sp_fid_index(fid));
1058         if (last_vlan)
1059                 mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port);
1060
1061         mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1062
1063         mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
1064         mlxsw_sp_port_vlan->bridge_port = NULL;
1065 }
1066
1067 static int
1068 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
1069                               struct mlxsw_sp_bridge_port *bridge_port,
1070                               u16 vid, bool is_untagged, bool is_pvid)
1071 {
1072         u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
1073         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1074         u16 old_pvid = mlxsw_sp_port->pvid;
1075         int err;
1076
1077         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_get(mlxsw_sp_port, vid);
1078         if (IS_ERR(mlxsw_sp_port_vlan))
1079                 return PTR_ERR(mlxsw_sp_port_vlan);
1080
1081         err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
1082                                      is_untagged);
1083         if (err)
1084                 goto err_port_vlan_set;
1085
1086         err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid);
1087         if (err)
1088                 goto err_port_pvid_set;
1089
1090         err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port);
1091         if (err)
1092                 goto err_port_vlan_bridge_join;
1093
1094         return 0;
1095
1096 err_port_vlan_bridge_join:
1097         mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid);
1098 err_port_pvid_set:
1099         mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1100 err_port_vlan_set:
1101         mlxsw_sp_port_vlan_put(mlxsw_sp_port_vlan);
1102         return err;
1103 }
1104
1105 static int
1106 mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
1107                                 const struct net_device *br_dev,
1108                                 const struct switchdev_obj_port_vlan *vlan)
1109 {
1110         struct mlxsw_sp_rif *rif;
1111         struct mlxsw_sp_fid *fid;
1112         u16 pvid;
1113         u16 vid;
1114
1115         rif = mlxsw_sp_rif_find_by_dev(mlxsw_sp, br_dev);
1116         if (!rif)
1117                 return 0;
1118         fid = mlxsw_sp_rif_fid(rif);
1119         pvid = mlxsw_sp_fid_8021q_vid(fid);
1120
1121         for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
1122                 if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
1123                         if (vid != pvid) {
1124                                 netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
1125                                 return -EBUSY;
1126                         }
1127                 } else {
1128                         if (vid == pvid) {
1129                                 netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
1130                                 return -EBUSY;
1131                         }
1132                 }
1133         }
1134
1135         return 0;
1136 }
1137
1138 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
1139                                    const struct switchdev_obj_port_vlan *vlan,
1140                                    struct switchdev_trans *trans)
1141 {
1142         bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1143         bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1144         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1145         struct net_device *orig_dev = vlan->obj.orig_dev;
1146         struct mlxsw_sp_bridge_port *bridge_port;
1147         u16 vid;
1148
1149         if (netif_is_bridge_master(orig_dev)) {
1150                 int err = 0;
1151
1152                 if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) &&
1153                     br_vlan_enabled(orig_dev) &&
1154                     switchdev_trans_ph_prepare(trans))
1155                         err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
1156                                                               orig_dev, vlan);
1157                 if (!err)
1158                         err = -EOPNOTSUPP;
1159                 return err;
1160         }
1161
1162         if (switchdev_trans_ph_prepare(trans))
1163                 return 0;
1164
1165         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1166         if (WARN_ON(!bridge_port))
1167                 return -EINVAL;
1168
1169         if (!bridge_port->bridge_device->vlan_enabled)
1170                 return 0;
1171
1172         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++) {
1173                 int err;
1174
1175                 err = mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
1176                                                     vid, flag_untagged,
1177                                                     flag_pvid);
1178                 if (err)
1179                         return err;
1180         }
1181
1182         return 0;
1183 }
1184
1185 static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
1186 {
1187         return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
1188                         MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
1189 }
1190
1191 static int
1192 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
1193                                struct mlxsw_sp_bridge_port *bridge_port,
1194                                u16 fid_index)
1195 {
1196         bool lagged = bridge_port->lagged;
1197         char sfdf_pl[MLXSW_REG_SFDF_LEN];
1198         u16 system_port;
1199
1200         system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
1201         mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
1202         mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
1203         mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);
1204
1205         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
1206 }
1207
1208 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
1209 {
1210         return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
1211                          MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY;
1212 }
1213
1214 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
1215 {
1216         return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
1217                         MLXSW_REG_SFD_OP_WRITE_REMOVE;
1218 }
1219
1220 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1221                                      const char *mac, u16 fid, bool adding,
1222                                      enum mlxsw_reg_sfd_rec_action action,
1223                                      bool dynamic)
1224 {
1225         char *sfd_pl;
1226         u8 num_rec;
1227         int err;
1228
1229         sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1230         if (!sfd_pl)
1231                 return -ENOMEM;
1232
1233         mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1234         mlxsw_reg_sfd_uc_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1235                               mac, fid, action, local_port);
1236         num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1237         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1238         if (err)
1239                 goto out;
1240
1241         if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1242                 err = -EBUSY;
1243
1244 out:
1245         kfree(sfd_pl);
1246         return err;
1247 }
1248
1249 static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1250                                    const char *mac, u16 fid, bool adding,
1251                                    bool dynamic)
1252 {
1253         return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
1254                                          MLXSW_REG_SFD_REC_ACTION_NOP, dynamic);
1255 }
1256
1257 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
1258                         bool adding)
1259 {
1260         return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
1261                                          MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1262                                          false);
1263 }
1264
1265 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
1266                                        const char *mac, u16 fid, u16 lag_vid,
1267                                        bool adding, bool dynamic)
1268 {
1269         char *sfd_pl;
1270         u8 num_rec;
1271         int err;
1272
1273         sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1274         if (!sfd_pl)
1275                 return -ENOMEM;
1276
1277         mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1278         mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1279                                   mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1280                                   lag_vid, lag_id);
1281         num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1282         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1283         if (err)
1284                 goto out;
1285
1286         if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1287                 err = -EBUSY;
1288
1289 out:
1290         kfree(sfd_pl);
1291         return err;
1292 }
1293
1294 static int
1295 mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
1296                       struct switchdev_notifier_fdb_info *fdb_info, bool adding)
1297 {
1298         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1299         struct net_device *orig_dev = fdb_info->info.dev;
1300         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1301         struct mlxsw_sp_bridge_device *bridge_device;
1302         struct mlxsw_sp_bridge_port *bridge_port;
1303         u16 fid_index, vid;
1304
1305         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1306         if (!bridge_port)
1307                 return -EINVAL;
1308
1309         bridge_device = bridge_port->bridge_device;
1310         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1311                                                                bridge_device,
1312                                                                fdb_info->vid);
1313         if (!mlxsw_sp_port_vlan)
1314                 return 0;
1315
1316         fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1317         vid = mlxsw_sp_port_vlan->vid;
1318
1319         if (!bridge_port->lagged)
1320                 return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
1321                                                bridge_port->system_port,
1322                                                fdb_info->addr, fid_index,
1323                                                adding, false);
1324         else
1325                 return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1326                                                    bridge_port->lag_id,
1327                                                    fdb_info->addr, fid_index,
1328                                                    vid, adding, false);
1329 }
1330
1331 static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr,
1332                                 u16 fid, u16 mid_idx, bool adding)
1333 {
1334         char *sfd_pl;
1335         u8 num_rec;
1336         int err;
1337
1338         sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1339         if (!sfd_pl)
1340                 return -ENOMEM;
1341
1342         mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1343         mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid,
1344                               MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx);
1345         num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1346         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1347         if (err)
1348                 goto out;
1349
1350         if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1351                 err = -EBUSY;
1352
1353 out:
1354         kfree(sfd_pl);
1355         return err;
1356 }
1357
1358 static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx,
1359                                          long *ports_bitmap,
1360                                          bool set_router_port)
1361 {
1362         char *smid_pl;
1363         int err, i;
1364
1365         smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1366         if (!smid_pl)
1367                 return -ENOMEM;
1368
1369         mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false);
1370         for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) {
1371                 if (mlxsw_sp->ports[i])
1372                         mlxsw_reg_smid_port_mask_set(smid_pl, i, 1);
1373         }
1374
1375         mlxsw_reg_smid_port_mask_set(smid_pl,
1376                                      mlxsw_sp_router_port(mlxsw_sp), 1);
1377
1378         for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core))
1379                 mlxsw_reg_smid_port_set(smid_pl, i, 1);
1380
1381         mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp),
1382                                 set_router_port);
1383
1384         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1385         kfree(smid_pl);
1386         return err;
1387 }
1388
1389 static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port,
1390                                   u16 mid_idx, bool add)
1391 {
1392         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1393         char *smid_pl;
1394         int err;
1395
1396         smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1397         if (!smid_pl)
1398                 return -ENOMEM;
1399
1400         mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add);
1401         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1402         kfree(smid_pl);
1403         return err;
1404 }
1405
1406 static struct
1407 mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device,
1408                                 const unsigned char *addr,
1409                                 u16 fid)
1410 {
1411         struct mlxsw_sp_mid *mid;
1412
1413         list_for_each_entry(mid, &bridge_device->mids_list, list) {
1414                 if (ether_addr_equal(mid->addr, addr) && mid->fid == fid)
1415                         return mid;
1416         }
1417         return NULL;
1418 }
1419
1420 static void
1421 mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
1422                                       struct mlxsw_sp_bridge_port *bridge_port,
1423                                       unsigned long *ports_bitmap)
1424 {
1425         struct mlxsw_sp_port *mlxsw_sp_port;
1426         u64 max_lag_members, i;
1427         int lag_id;
1428
1429         if (!bridge_port->lagged) {
1430                 set_bit(bridge_port->system_port, ports_bitmap);
1431         } else {
1432                 max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1433                                                      MAX_LAG_MEMBERS);
1434                 lag_id = bridge_port->lag_id;
1435                 for (i = 0; i < max_lag_members; i++) {
1436                         mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
1437                                                                  lag_id, i);
1438                         if (mlxsw_sp_port)
1439                                 set_bit(mlxsw_sp_port->local_port,
1440                                         ports_bitmap);
1441                 }
1442         }
1443 }
1444
1445 static void
1446 mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap,
1447                                 struct mlxsw_sp_bridge_device *bridge_device,
1448                                 struct mlxsw_sp *mlxsw_sp)
1449 {
1450         struct mlxsw_sp_bridge_port *bridge_port;
1451
1452         list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
1453                 if (bridge_port->mrouter) {
1454                         mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
1455                                                               bridge_port,
1456                                                               flood_bitmap);
1457                 }
1458         }
1459 }
1460
1461 static bool
1462 mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1463                             struct mlxsw_sp_mid *mid,
1464                             struct mlxsw_sp_bridge_device *bridge_device)
1465 {
1466         long *flood_bitmap;
1467         int num_of_ports;
1468         int alloc_size;
1469         u16 mid_idx;
1470         int err;
1471
1472         mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap,
1473                                       MLXSW_SP_MID_MAX);
1474         if (mid_idx == MLXSW_SP_MID_MAX)
1475                 return false;
1476
1477         num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core);
1478         alloc_size = sizeof(long) * BITS_TO_LONGS(num_of_ports);
1479         flood_bitmap = kzalloc(alloc_size, GFP_KERNEL);
1480         if (!flood_bitmap)
1481                 return false;
1482
1483         bitmap_copy(flood_bitmap,  mid->ports_in_mid, num_of_ports);
1484         mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp);
1485
1486         mid->mid = mid_idx;
1487         err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap,
1488                                             bridge_device->mrouter);
1489         kfree(flood_bitmap);
1490         if (err)
1491                 return false;
1492
1493         err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx,
1494                                    true);
1495         if (err)
1496                 return false;
1497
1498         set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap);
1499         mid->in_hw = true;
1500         return true;
1501 }
1502
1503 static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1504                                         struct mlxsw_sp_mid *mid)
1505 {
1506         if (!mid->in_hw)
1507                 return 0;
1508
1509         clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap);
1510         mid->in_hw = false;
1511         return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid,
1512                                     false);
1513 }
1514
1515 static struct
1516 mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp,
1517                                   struct mlxsw_sp_bridge_device *bridge_device,
1518                                   const unsigned char *addr,
1519                                   u16 fid)
1520 {
1521         struct mlxsw_sp_mid *mid;
1522         size_t alloc_size;
1523
1524         mid = kzalloc(sizeof(*mid), GFP_KERNEL);
1525         if (!mid)
1526                 return NULL;
1527
1528         alloc_size = sizeof(unsigned long) *
1529                      BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core));
1530
1531         mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL);
1532         if (!mid->ports_in_mid)
1533                 goto err_ports_in_mid_alloc;
1534
1535         ether_addr_copy(mid->addr, addr);
1536         mid->fid = fid;
1537         mid->in_hw = false;
1538
1539         if (!bridge_device->multicast_enabled)
1540                 goto out;
1541
1542         if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device))
1543                 goto err_write_mdb_entry;
1544
1545 out:
1546         list_add_tail(&mid->list, &bridge_device->mids_list);
1547         return mid;
1548
1549 err_write_mdb_entry:
1550         kfree(mid->ports_in_mid);
1551 err_ports_in_mid_alloc:
1552         kfree(mid);
1553         return NULL;
1554 }
1555
1556 static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port,
1557                                          struct mlxsw_sp_mid *mid)
1558 {
1559         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1560         int err = 0;
1561
1562         clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1563         if (bitmap_empty(mid->ports_in_mid,
1564                          mlxsw_core_max_ports(mlxsw_sp->core))) {
1565                 err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1566                 list_del(&mid->list);
1567                 kfree(mid->ports_in_mid);
1568                 kfree(mid);
1569         }
1570         return err;
1571 }
1572
1573 static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
1574                                  const struct switchdev_obj_port_mdb *mdb,
1575                                  struct switchdev_trans *trans)
1576 {
1577         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1578         struct net_device *orig_dev = mdb->obj.orig_dev;
1579         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1580         struct net_device *dev = mlxsw_sp_port->dev;
1581         struct mlxsw_sp_bridge_device *bridge_device;
1582         struct mlxsw_sp_bridge_port *bridge_port;
1583         struct mlxsw_sp_mid *mid;
1584         u16 fid_index;
1585         int err = 0;
1586
1587         if (switchdev_trans_ph_prepare(trans))
1588                 return 0;
1589
1590         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1591         if (!bridge_port)
1592                 return 0;
1593
1594         bridge_device = bridge_port->bridge_device;
1595         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1596                                                                bridge_device,
1597                                                                mdb->vid);
1598         if (!mlxsw_sp_port_vlan)
1599                 return 0;
1600
1601         fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1602
1603         mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1604         if (!mid) {
1605                 mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr,
1606                                           fid_index);
1607                 if (!mid) {
1608                         netdev_err(dev, "Unable to allocate MC group\n");
1609                         return -ENOMEM;
1610                 }
1611         }
1612         set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1613
1614         if (!bridge_device->multicast_enabled)
1615                 return 0;
1616
1617         if (bridge_port->mrouter)
1618                 return 0;
1619
1620         err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true);
1621         if (err) {
1622                 netdev_err(dev, "Unable to set SMID\n");
1623                 goto err_out;
1624         }
1625
1626         return 0;
1627
1628 err_out:
1629         mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1630         return err;
1631 }
1632
1633 static void
1634 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
1635                                    struct mlxsw_sp_bridge_device
1636                                    *bridge_device)
1637 {
1638         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1639         struct mlxsw_sp_mid *mid;
1640         bool mc_enabled;
1641
1642         mc_enabled = bridge_device->multicast_enabled;
1643
1644         list_for_each_entry(mid, &bridge_device->mids_list, list) {
1645                 if (mc_enabled)
1646                         mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid,
1647                                                     bridge_device);
1648                 else
1649                         mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1650         }
1651 }
1652
1653 static void
1654 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
1655                                  struct mlxsw_sp_bridge_port *bridge_port,
1656                                  bool add)
1657 {
1658         struct mlxsw_sp_bridge_device *bridge_device;
1659         struct mlxsw_sp_mid *mid;
1660
1661         bridge_device = bridge_port->bridge_device;
1662
1663         list_for_each_entry(mid, &bridge_device->mids_list, list) {
1664                 if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid))
1665                         mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add);
1666         }
1667 }
1668
1669 struct mlxsw_sp_span_respin_work {
1670         struct work_struct work;
1671         struct mlxsw_sp *mlxsw_sp;
1672 };
1673
1674 static void mlxsw_sp_span_respin_work(struct work_struct *work)
1675 {
1676         struct mlxsw_sp_span_respin_work *respin_work =
1677                 container_of(work, struct mlxsw_sp_span_respin_work, work);
1678
1679         rtnl_lock();
1680         mlxsw_sp_span_respin(respin_work->mlxsw_sp);
1681         rtnl_unlock();
1682         kfree(respin_work);
1683 }
1684
1685 static void mlxsw_sp_span_respin_schedule(struct mlxsw_sp *mlxsw_sp)
1686 {
1687         struct mlxsw_sp_span_respin_work *respin_work;
1688
1689         respin_work = kzalloc(sizeof(*respin_work), GFP_ATOMIC);
1690         if (!respin_work)
1691                 return;
1692
1693         INIT_WORK(&respin_work->work, mlxsw_sp_span_respin_work);
1694         respin_work->mlxsw_sp = mlxsw_sp;
1695
1696         mlxsw_core_schedule_work(&respin_work->work);
1697 }
1698
1699 static int mlxsw_sp_port_obj_add(struct net_device *dev,
1700                                  const struct switchdev_obj *obj,
1701                                  struct switchdev_trans *trans)
1702 {
1703         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1704         const struct switchdev_obj_port_vlan *vlan;
1705         int err = 0;
1706
1707         switch (obj->id) {
1708         case SWITCHDEV_OBJ_ID_PORT_VLAN:
1709                 vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1710                 err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, trans);
1711
1712                 if (switchdev_trans_ph_prepare(trans)) {
1713                         /* The event is emitted before the changes are actually
1714                          * applied to the bridge. Therefore schedule the respin
1715                          * call for later, so that the respin logic sees the
1716                          * updated bridge state.
1717                          */
1718                         mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp);
1719                 }
1720                 break;
1721         case SWITCHDEV_OBJ_ID_PORT_MDB:
1722                 err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
1723                                             SWITCHDEV_OBJ_PORT_MDB(obj),
1724                                             trans);
1725                 break;
1726         default:
1727                 err = -EOPNOTSUPP;
1728                 break;
1729         }
1730
1731         return err;
1732 }
1733
1734 static void
1735 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
1736                               struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
1737 {
1738         u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : vid;
1739         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1740
1741         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1742         if (WARN_ON(!mlxsw_sp_port_vlan))
1743                 return;
1744
1745         mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
1746         mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid);
1747         mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1748         mlxsw_sp_port_vlan_put(mlxsw_sp_port_vlan);
1749 }
1750
1751 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
1752                                    const struct switchdev_obj_port_vlan *vlan)
1753 {
1754         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1755         struct net_device *orig_dev = vlan->obj.orig_dev;
1756         struct mlxsw_sp_bridge_port *bridge_port;
1757         u16 vid;
1758
1759         if (netif_is_bridge_master(orig_dev))
1760                 return -EOPNOTSUPP;
1761
1762         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1763         if (WARN_ON(!bridge_port))
1764                 return -EINVAL;
1765
1766         if (!bridge_port->bridge_device->vlan_enabled)
1767                 return 0;
1768
1769         for (vid = vlan->vid_begin; vid <= vlan->vid_end; vid++)
1770                 mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vid);
1771
1772         return 0;
1773 }
1774
1775 static int
1776 __mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1777                         struct mlxsw_sp_bridge_port *bridge_port,
1778                         struct mlxsw_sp_mid *mid)
1779 {
1780         struct net_device *dev = mlxsw_sp_port->dev;
1781         int err;
1782
1783         if (bridge_port->bridge_device->multicast_enabled &&
1784             !bridge_port->mrouter) {
1785                 err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1786                 if (err)
1787                         netdev_err(dev, "Unable to remove port from SMID\n");
1788         }
1789
1790         err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1791         if (err)
1792                 netdev_err(dev, "Unable to remove MC SFD\n");
1793
1794         return err;
1795 }
1796
1797 static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1798                                  const struct switchdev_obj_port_mdb *mdb)
1799 {
1800         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1801         struct net_device *orig_dev = mdb->obj.orig_dev;
1802         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1803         struct mlxsw_sp_bridge_device *bridge_device;
1804         struct net_device *dev = mlxsw_sp_port->dev;
1805         struct mlxsw_sp_bridge_port *bridge_port;
1806         struct mlxsw_sp_mid *mid;
1807         u16 fid_index;
1808
1809         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1810         if (!bridge_port)
1811                 return 0;
1812
1813         bridge_device = bridge_port->bridge_device;
1814         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1815                                                                bridge_device,
1816                                                                mdb->vid);
1817         if (!mlxsw_sp_port_vlan)
1818                 return 0;
1819
1820         fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1821
1822         mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1823         if (!mid) {
1824                 netdev_err(dev, "Unable to remove port from MC DB\n");
1825                 return -EINVAL;
1826         }
1827
1828         return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid);
1829 }
1830
1831 static void
1832 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
1833                                struct mlxsw_sp_bridge_port *bridge_port)
1834 {
1835         struct mlxsw_sp_bridge_device *bridge_device;
1836         struct mlxsw_sp_mid *mid, *tmp;
1837
1838         bridge_device = bridge_port->bridge_device;
1839
1840         list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) {
1841                 if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) {
1842                         __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port,
1843                                                 mid);
1844                 } else if (bridge_device->multicast_enabled &&
1845                            bridge_port->mrouter) {
1846                         mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1847                 }
1848         }
1849 }
1850
1851 static int mlxsw_sp_port_obj_del(struct net_device *dev,
1852                                  const struct switchdev_obj *obj)
1853 {
1854         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1855         int err = 0;
1856
1857         switch (obj->id) {
1858         case SWITCHDEV_OBJ_ID_PORT_VLAN:
1859                 err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
1860                                               SWITCHDEV_OBJ_PORT_VLAN(obj));
1861                 break;
1862         case SWITCHDEV_OBJ_ID_PORT_MDB:
1863                 err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
1864                                             SWITCHDEV_OBJ_PORT_MDB(obj));
1865                 break;
1866         default:
1867                 err = -EOPNOTSUPP;
1868                 break;
1869         }
1870
1871         mlxsw_sp_span_respin_schedule(mlxsw_sp_port->mlxsw_sp);
1872
1873         return err;
1874 }
1875
1876 static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
1877                                                    u16 lag_id)
1878 {
1879         struct mlxsw_sp_port *mlxsw_sp_port;
1880         u64 max_lag_members;
1881         int i;
1882
1883         max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1884                                              MAX_LAG_MEMBERS);
1885         for (i = 0; i < max_lag_members; i++) {
1886                 mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
1887                 if (mlxsw_sp_port)
1888                         return mlxsw_sp_port;
1889         }
1890         return NULL;
1891 }
1892
1893 static const struct switchdev_ops mlxsw_sp_port_switchdev_ops = {
1894         .switchdev_port_attr_get        = mlxsw_sp_port_attr_get,
1895         .switchdev_port_attr_set        = mlxsw_sp_port_attr_set,
1896         .switchdev_port_obj_add         = mlxsw_sp_port_obj_add,
1897         .switchdev_port_obj_del         = mlxsw_sp_port_obj_del,
1898 };
1899
1900 static int
1901 mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
1902                                 struct mlxsw_sp_bridge_port *bridge_port,
1903                                 struct mlxsw_sp_port *mlxsw_sp_port,
1904                                 struct netlink_ext_ack *extack)
1905 {
1906         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1907
1908         if (is_vlan_dev(bridge_port->dev)) {
1909                 NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
1910                 return -EINVAL;
1911         }
1912
1913         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, 1);
1914         if (WARN_ON(!mlxsw_sp_port_vlan))
1915                 return -EINVAL;
1916
1917         /* Let VLAN-aware bridge take care of its own VLANs */
1918         mlxsw_sp_port_vlan_put(mlxsw_sp_port_vlan);
1919
1920         return 0;
1921 }
1922
1923 static void
1924 mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
1925                                  struct mlxsw_sp_bridge_port *bridge_port,
1926                                  struct mlxsw_sp_port *mlxsw_sp_port)
1927 {
1928         mlxsw_sp_port_vlan_get(mlxsw_sp_port, 1);
1929         /* Make sure untagged frames are allowed to ingress */
1930         mlxsw_sp_port_pvid_set(mlxsw_sp_port, 1);
1931 }
1932
1933 static struct mlxsw_sp_fid *
1934 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
1935                               u16 vid)
1936 {
1937         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
1938
1939         return mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
1940 }
1941
1942 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
1943         .port_join      = mlxsw_sp_bridge_8021q_port_join,
1944         .port_leave     = mlxsw_sp_bridge_8021q_port_leave,
1945         .fid_get        = mlxsw_sp_bridge_8021q_fid_get,
1946 };
1947
1948 static bool
1949 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
1950                            const struct net_device *br_dev)
1951 {
1952         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1953
1954         list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
1955                             list) {
1956                 if (mlxsw_sp_port_vlan->bridge_port &&
1957                     mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
1958                     br_dev)
1959                         return true;
1960         }
1961
1962         return false;
1963 }
1964
1965 static int
1966 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
1967                                 struct mlxsw_sp_bridge_port *bridge_port,
1968                                 struct mlxsw_sp_port *mlxsw_sp_port,
1969                                 struct netlink_ext_ack *extack)
1970 {
1971         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1972         struct net_device *dev = bridge_port->dev;
1973         u16 vid;
1974
1975         vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : 1;
1976         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1977         if (WARN_ON(!mlxsw_sp_port_vlan))
1978                 return -EINVAL;
1979
1980         if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
1981                 NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
1982                 return -EINVAL;
1983         }
1984
1985         /* Port is no longer usable as a router interface */
1986         if (mlxsw_sp_port_vlan->fid)
1987                 mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
1988
1989         return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port);
1990 }
1991
1992 static void
1993 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
1994                                  struct mlxsw_sp_bridge_port *bridge_port,
1995                                  struct mlxsw_sp_port *mlxsw_sp_port)
1996 {
1997         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1998         struct net_device *dev = bridge_port->dev;
1999         u16 vid;
2000
2001         vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : 1;
2002         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2003         if (WARN_ON(!mlxsw_sp_port_vlan))
2004                 return;
2005
2006         mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2007 }
2008
2009 static struct mlxsw_sp_fid *
2010 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2011                               u16 vid)
2012 {
2013         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2014
2015         return mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2016 }
2017
2018 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
2019         .port_join      = mlxsw_sp_bridge_8021d_port_join,
2020         .port_leave     = mlxsw_sp_bridge_8021d_port_leave,
2021         .fid_get        = mlxsw_sp_bridge_8021d_fid_get,
2022 };
2023
2024 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
2025                               struct net_device *brport_dev,
2026                               struct net_device *br_dev,
2027                               struct netlink_ext_ack *extack)
2028 {
2029         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2030         struct mlxsw_sp_bridge_device *bridge_device;
2031         struct mlxsw_sp_bridge_port *bridge_port;
2032         int err;
2033
2034         bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev);
2035         if (IS_ERR(bridge_port))
2036                 return PTR_ERR(bridge_port);
2037         bridge_device = bridge_port->bridge_device;
2038
2039         err = bridge_device->ops->port_join(bridge_device, bridge_port,
2040                                             mlxsw_sp_port, extack);
2041         if (err)
2042                 goto err_port_join;
2043
2044         return 0;
2045
2046 err_port_join:
2047         mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2048         return err;
2049 }
2050
2051 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2052                                 struct net_device *brport_dev,
2053                                 struct net_device *br_dev)
2054 {
2055         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2056         struct mlxsw_sp_bridge_device *bridge_device;
2057         struct mlxsw_sp_bridge_port *bridge_port;
2058
2059         bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2060         if (!bridge_device)
2061                 return;
2062         bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
2063         if (!bridge_port)
2064                 return;
2065
2066         bridge_device->ops->port_leave(bridge_device, bridge_port,
2067                                        mlxsw_sp_port);
2068         mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2069 }
2070
2071 static void
2072 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
2073                             const char *mac, u16 vid,
2074                             struct net_device *dev)
2075 {
2076         struct switchdev_notifier_fdb_info info;
2077
2078         info.addr = mac;
2079         info.vid = vid;
2080         call_switchdev_notifiers(type, dev, &info.info);
2081 }
2082
2083 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
2084                                             char *sfn_pl, int rec_index,
2085                                             bool adding)
2086 {
2087         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2088         struct mlxsw_sp_bridge_device *bridge_device;
2089         struct mlxsw_sp_bridge_port *bridge_port;
2090         struct mlxsw_sp_port *mlxsw_sp_port;
2091         enum switchdev_notifier_type type;
2092         char mac[ETH_ALEN];
2093         u8 local_port;
2094         u16 vid, fid;
2095         bool do_notification = true;
2096         int err;
2097
2098         mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);
2099         mlxsw_sp_port = mlxsw_sp->ports[local_port];
2100         if (!mlxsw_sp_port) {
2101                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
2102                 goto just_remove;
2103         }
2104
2105         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2106         if (!mlxsw_sp_port_vlan) {
2107                 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2108                 goto just_remove;
2109         }
2110
2111         bridge_port = mlxsw_sp_port_vlan->bridge_port;
2112         if (!bridge_port) {
2113                 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2114                 goto just_remove;
2115         }
2116
2117         bridge_device = bridge_port->bridge_device;
2118         vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2119
2120 do_fdb_op:
2121         err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid,
2122                                       adding, true);
2123         if (err) {
2124                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2125                 return;
2126         }
2127
2128         if (!do_notification)
2129                 return;
2130         type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2131         mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev);
2132
2133         return;
2134
2135 just_remove:
2136         adding = false;
2137         do_notification = false;
2138         goto do_fdb_op;
2139 }
2140
2141 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
2142                                                 char *sfn_pl, int rec_index,
2143                                                 bool adding)
2144 {
2145         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2146         struct mlxsw_sp_bridge_device *bridge_device;
2147         struct mlxsw_sp_bridge_port *bridge_port;
2148         struct mlxsw_sp_port *mlxsw_sp_port;
2149         enum switchdev_notifier_type type;
2150         char mac[ETH_ALEN];
2151         u16 lag_vid = 0;
2152         u16 lag_id;
2153         u16 vid, fid;
2154         bool do_notification = true;
2155         int err;
2156
2157         mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
2158         mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
2159         if (!mlxsw_sp_port) {
2160                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
2161                 goto just_remove;
2162         }
2163
2164         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2165         if (!mlxsw_sp_port_vlan) {
2166                 netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2167                 goto just_remove;
2168         }
2169
2170         bridge_port = mlxsw_sp_port_vlan->bridge_port;
2171         if (!bridge_port) {
2172                 netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2173                 goto just_remove;
2174         }
2175
2176         bridge_device = bridge_port->bridge_device;
2177         vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2178         lag_vid = mlxsw_sp_port_vlan->vid;
2179
2180 do_fdb_op:
2181         err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
2182                                           adding, true);
2183         if (err) {
2184                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2185                 return;
2186         }
2187
2188         if (!do_notification)
2189                 return;
2190         type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2191         mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev);
2192
2193         return;
2194
2195 just_remove:
2196         adding = false;
2197         do_notification = false;
2198         goto do_fdb_op;
2199 }
2200
2201 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
2202                                             char *sfn_pl, int rec_index)
2203 {
2204         switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
2205         case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
2206                 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2207                                                 rec_index, true);
2208                 break;
2209         case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
2210                 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2211                                                 rec_index, false);
2212                 break;
2213         case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
2214                 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2215                                                     rec_index, true);
2216                 break;
2217         case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
2218                 mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2219                                                     rec_index, false);
2220                 break;
2221         }
2222 }
2223
2224 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp)
2225 {
2226         struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
2227
2228         mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
2229                                msecs_to_jiffies(bridge->fdb_notify.interval));
2230 }
2231
2232 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
2233 {
2234         struct mlxsw_sp_bridge *bridge;
2235         struct mlxsw_sp *mlxsw_sp;
2236         char *sfn_pl;
2237         u8 num_rec;
2238         int i;
2239         int err;
2240
2241         sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
2242         if (!sfn_pl)
2243                 return;
2244
2245         bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
2246         mlxsw_sp = bridge->mlxsw_sp;
2247
2248         rtnl_lock();
2249         mlxsw_reg_sfn_pack(sfn_pl);
2250         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
2251         if (err) {
2252                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
2253                 goto out;
2254         }
2255         num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
2256         for (i = 0; i < num_rec; i++)
2257                 mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
2258
2259 out:
2260         rtnl_unlock();
2261         kfree(sfn_pl);
2262         mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
2263 }
2264
2265 struct mlxsw_sp_switchdev_event_work {
2266         struct work_struct work;
2267         struct switchdev_notifier_fdb_info fdb_info;
2268         struct net_device *dev;
2269         unsigned long event;
2270 };
2271
2272 static void mlxsw_sp_switchdev_event_work(struct work_struct *work)
2273 {
2274         struct mlxsw_sp_switchdev_event_work *switchdev_work =
2275                 container_of(work, struct mlxsw_sp_switchdev_event_work, work);
2276         struct net_device *dev = switchdev_work->dev;
2277         struct switchdev_notifier_fdb_info *fdb_info;
2278         struct mlxsw_sp_port *mlxsw_sp_port;
2279         int err;
2280
2281         rtnl_lock();
2282         mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
2283         if (!mlxsw_sp_port)
2284                 goto out;
2285
2286         switch (switchdev_work->event) {
2287         case SWITCHDEV_FDB_ADD_TO_DEVICE:
2288                 fdb_info = &switchdev_work->fdb_info;
2289                 if (!fdb_info->added_by_user)
2290                         break;
2291                 err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
2292                 if (err)
2293                         break;
2294                 mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2295                                             fdb_info->addr,
2296                                             fdb_info->vid, dev);
2297                 break;
2298         case SWITCHDEV_FDB_DEL_TO_DEVICE:
2299                 fdb_info = &switchdev_work->fdb_info;
2300                 if (!fdb_info->added_by_user)
2301                         break;
2302                 mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false);
2303                 break;
2304         case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */
2305         case SWITCHDEV_FDB_DEL_TO_BRIDGE:
2306                 /* These events are only used to potentially update an existing
2307                  * SPAN mirror.
2308                  */
2309                 break;
2310         }
2311
2312         mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2313
2314 out:
2315         rtnl_unlock();
2316         kfree(switchdev_work->fdb_info.addr);
2317         kfree(switchdev_work);
2318         dev_put(dev);
2319 }
2320
2321 /* Called under rcu_read_lock() */
2322 static int mlxsw_sp_switchdev_event(struct notifier_block *unused,
2323                                     unsigned long event, void *ptr)
2324 {
2325         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
2326         struct mlxsw_sp_switchdev_event_work *switchdev_work;
2327         struct switchdev_notifier_fdb_info *fdb_info = ptr;
2328
2329         if (!mlxsw_sp_port_dev_lower_find_rcu(dev))
2330                 return NOTIFY_DONE;
2331
2332         switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
2333         if (!switchdev_work)
2334                 return NOTIFY_BAD;
2335
2336         INIT_WORK(&switchdev_work->work, mlxsw_sp_switchdev_event_work);
2337         switchdev_work->dev = dev;
2338         switchdev_work->event = event;
2339
2340         switch (event) {
2341         case SWITCHDEV_FDB_ADD_TO_DEVICE: /* fall through */
2342         case SWITCHDEV_FDB_DEL_TO_DEVICE: /* fall through */
2343         case SWITCHDEV_FDB_ADD_TO_BRIDGE: /* fall through */
2344         case SWITCHDEV_FDB_DEL_TO_BRIDGE:
2345                 memcpy(&switchdev_work->fdb_info, ptr,
2346                        sizeof(switchdev_work->fdb_info));
2347                 switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
2348                 if (!switchdev_work->fdb_info.addr)
2349                         goto err_addr_alloc;
2350                 ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
2351                                 fdb_info->addr);
2352                 /* Take a reference on the device. This can be either
2353                  * upper device containig mlxsw_sp_port or just a
2354                  * mlxsw_sp_port
2355                  */
2356                 dev_hold(dev);
2357                 break;
2358         default:
2359                 kfree(switchdev_work);
2360                 return NOTIFY_DONE;
2361         }
2362
2363         mlxsw_core_schedule_work(&switchdev_work->work);
2364
2365         return NOTIFY_DONE;
2366
2367 err_addr_alloc:
2368         kfree(switchdev_work);
2369         return NOTIFY_BAD;
2370 }
2371
2372 static struct notifier_block mlxsw_sp_switchdev_notifier = {
2373         .notifier_call = mlxsw_sp_switchdev_event,
2374 };
2375
2376 u8
2377 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
2378 {
2379         return bridge_port->stp_state;
2380 }
2381
2382 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
2383 {
2384         struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
2385         int err;
2386
2387         err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
2388         if (err) {
2389                 dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
2390                 return err;
2391         }
2392
2393         err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
2394         if (err) {
2395                 dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n");
2396                 return err;
2397         }
2398
2399         INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
2400         bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
2401         mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
2402         return 0;
2403 }
2404
2405 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
2406 {
2407         cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
2408         unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
2409
2410 }
2411
2412 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
2413 {
2414         struct mlxsw_sp_bridge *bridge;
2415
2416         bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL);
2417         if (!bridge)
2418                 return -ENOMEM;
2419         mlxsw_sp->bridge = bridge;
2420         bridge->mlxsw_sp = mlxsw_sp;
2421
2422         INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list);
2423
2424         bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops;
2425         bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops;
2426
2427         return mlxsw_sp_fdb_init(mlxsw_sp);
2428 }
2429
2430 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
2431 {
2432         mlxsw_sp_fdb_fini(mlxsw_sp);
2433         WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list));
2434         kfree(mlxsw_sp->bridge);
2435 }
2436
2437 void mlxsw_sp_port_switchdev_init(struct mlxsw_sp_port *mlxsw_sp_port)
2438 {
2439         mlxsw_sp_port->dev->switchdev_ops = &mlxsw_sp_port_switchdev_ops;
2440 }
2441
2442 void mlxsw_sp_port_switchdev_fini(struct mlxsw_sp_port *mlxsw_sp_port)
2443 {
2444 }