net/dsa/switch.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Handling of a single switch chip, part of a switch fabric
   4  *
   5  * Copyright (c) 2017 Savoir-faire Linux Inc.
   6  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
   7  */
   8
   9 #include <linux/if_bridge.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/notifier.h>
  12 #include <linux/if_vlan.h>
  13 #include <net/switchdev.h>
  14
  15 #include "dsa_priv.h"
  16
  17 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
  18                                                    unsigned int ageing_time)
  19 {
  20         int i;
  21
  22         for (i = 0; i < ds->num_ports; ++i) {
  23                 struct dsa_port *dp = dsa_to_port(ds, i);
  24
  25                 if (dp->ageing_time && dp->ageing_time < ageing_time)
  26                         ageing_time = dp->ageing_time;
  27         }
  28
  29         return ageing_time;
  30 }
  31
  32 static int dsa_switch_ageing_time(struct dsa_switch *ds,
  33                                   struct dsa_notifier_ageing_time_info *info)
  34 {
  35         unsigned int ageing_time = info->ageing_time;
  36
  37         if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
  38                 return -ERANGE;
  39
  40         if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
  41                 return -ERANGE;
  42
  43         /* Program the fastest ageing time in case of multiple bridges */
  44         ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
  45
  46         if (ds->ops->set_ageing_time)
  47                 return ds->ops->set_ageing_time(ds, ageing_time);
  48
  49         return 0;
  50 }
  51
  52 static bool dsa_switch_mtu_match(struct dsa_switch *ds, int port,
  53                                  struct dsa_notifier_mtu_info *info)
  54 {
  55         if (ds->index == info->sw_index && port == info->port)
  56                 return true;
  57
  58         /* Do not propagate to other switches in the tree if the notifier was
  59          * targeted for a single switch.
  60          */
  61         if (info->targeted_match)
  62                 return false;
  63
  64         if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
  65                 return true;
  66
  67         return false;
  68 }
  69
  70 static int dsa_switch_mtu(struct dsa_switch *ds,
  71                           struct dsa_notifier_mtu_info *info)
  72 {
  73         int port, ret;
  74
  75         if (!ds->ops->port_change_mtu)
  76                 return -EOPNOTSUPP;
  77
  78         for (port = 0; port < ds->num_ports; port++) {
  79                 if (dsa_switch_mtu_match(ds, port, info)) {
  80                         ret = ds->ops->port_change_mtu(ds, port, info->mtu);
  81                         if (ret)
  82                                 return ret;
  83                 }
  84         }
  85
  86         return 0;
  87 }
  88
  89 static int dsa_switch_bridge_join(struct dsa_switch *ds,
  90                                   struct dsa_notifier_bridge_info *info)
  91 {
  92         struct dsa_switch_tree *dst = ds->dst;
  93
  94         if (dst->index == info->tree_index && ds->index == info->sw_index &&
  95             ds->ops->port_bridge_join)
  96                 return ds->ops->port_bridge_join(ds, info->port, info->br);
  97
  98         if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
  99             ds->ops->crosschip_bridge_join)
 100                 return ds->ops->crosschip_bridge_join(ds, info->tree_index,
 101                                                       info->sw_index,
 102                                                       info->port, info->br);
 103
 104         return 0;
 105 }
 106
 107 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
 108                                    struct dsa_notifier_bridge_info *info)
 109 {
 110         bool unset_vlan_filtering = br_vlan_enabled(info->br);
 111         struct dsa_switch_tree *dst = ds->dst;
 112         struct netlink_ext_ack extack = {0};
 113         int err, port;
 114
 115         if (dst->index == info->tree_index && ds->index == info->sw_index &&
 116             ds->ops->port_bridge_leave)
 117                 ds->ops->port_bridge_leave(ds, info->port, info->br);
 118
 119         if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
 120             ds->ops->crosschip_bridge_leave)
 121                 ds->ops->crosschip_bridge_leave(ds, info->tree_index,
 122                                                 info->sw_index, info->port,
 123                                                 info->br);
 124
 125         /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
 126          * event for changing vlan_filtering setting upon slave ports leaving
 127          * it. That is a good thing, because that lets us handle it and also
 128          * handle the case where the switch's vlan_filtering setting is global
 129          * (not per port). When that happens, the correct moment to trigger the
 130          * vlan_filtering callback is only when the last port leaves the last
 131          * VLAN-aware bridge.
 132          */
 133         if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
 134                 for (port = 0; port < ds->num_ports; port++) {
 135                         struct net_device *bridge_dev;
 136
 137                         bridge_dev = dsa_to_port(ds, port)->bridge_dev;
 138
 139                         if (bridge_dev && br_vlan_enabled(bridge_dev)) {
 140                                 unset_vlan_filtering = false;
 141                                 break;
 142                         }
 143                 }
 144         }
 145         if (unset_vlan_filtering) {
 146                 err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
 147                                               false, &extack);
 148                 if (extack._msg)
 149                         dev_err(ds->dev, "port %d: %s\n", info->port,
 150                                 extack._msg);
 151                 if (err && err != EOPNOTSUPP)
 152                         return err;
 153         }
 154         return 0;
 155 }
 156
 157 /* Matches for all upstream-facing ports (the CPU port and all upstream-facing
 158  * DSA links) that sit between the targeted port on which the notifier was
 159  * emitted and its dedicated CPU port.
 160  */
 161 static bool dsa_switch_host_address_match(struct dsa_switch *ds, int port,
 162                                           int info_sw_index, int info_port)
 163 {
 164         struct dsa_port *targeted_dp, *cpu_dp;
 165         struct dsa_switch *targeted_ds;
 166
 167         targeted_ds = dsa_switch_find(ds->dst->index, info_sw_index);
 168         targeted_dp = dsa_to_port(targeted_ds, info_port);
 169         cpu_dp = targeted_dp->cpu_dp;
 170
 171         if (dsa_switch_is_upstream_of(ds, targeted_ds))
 172                 return port == dsa_towards_port(ds, cpu_dp->ds->index,
 173                                                 cpu_dp->index);
 174
 175         return false;
 176 }
 177
 178 static struct dsa_mac_addr *dsa_mac_addr_find(struct list_head *addr_list,
 179                                               const unsigned char *addr,
 180                                               u16 vid)
 181 {
 182         struct dsa_mac_addr *a;
 183
 184         list_for_each_entry(a, addr_list, list)
 185                 if (ether_addr_equal(a->addr, addr) && a->vid == vid)
 186                         return a;
 187
 188         return NULL;
 189 }
 190
 191 static int dsa_switch_do_mdb_add(struct dsa_switch *ds, int port,
 192                                  const struct switchdev_obj_port_mdb *mdb)
 193 {
 194         struct dsa_port *dp = dsa_to_port(ds, port);
 195         struct dsa_mac_addr *a;
 196         int err;
 197
 198         /* No need to bother with refcounting for user ports */
 199         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 200                 return ds->ops->port_mdb_add(ds, port, mdb);
 201
 202         a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
 203         if (a) {
 204                 refcount_inc(&a->refcount);
 205                 return 0;
 206         }
 207
 208         a = kzalloc(sizeof(*a), GFP_KERNEL);
 209         if (!a)
 210                 return -ENOMEM;
 211
 212         err = ds->ops->port_mdb_add(ds, port, mdb);
 213         if (err) {
 214                 kfree(a);
 215                 return err;
 216         }
 217
 218         ether_addr_copy(a->addr, mdb->addr);
 219         a->vid = mdb->vid;
 220         refcount_set(&a->refcount, 1);
 221         list_add_tail(&a->list, &dp->mdbs);
 222
 223         return 0;
 224 }
 225
 226 static int dsa_switch_do_mdb_del(struct dsa_switch *ds, int port,
 227                                  const struct switchdev_obj_port_mdb *mdb)
 228 {
 229         struct dsa_port *dp = dsa_to_port(ds, port);
 230         struct dsa_mac_addr *a;
 231         int err;
 232
 233         /* No need to bother with refcounting for user ports */
 234         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 235                 return ds->ops->port_mdb_del(ds, port, mdb);
 236
 237         a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
 238         if (!a)
 239                 return -ENOENT;
 240
 241         if (!refcount_dec_and_test(&a->refcount))
 242                 return 0;
 243
 244         err = ds->ops->port_mdb_del(ds, port, mdb);
 245         if (err) {
 246                 refcount_inc(&a->refcount);
 247                 return err;
 248         }
 249
 250         list_del(&a->list);
 251         kfree(a);
 252
 253         return 0;
 254 }
 255
 256 static int dsa_switch_do_fdb_add(struct dsa_switch *ds, int port,
 257                                  const unsigned char *addr, u16 vid)
 258 {
 259         struct dsa_port *dp = dsa_to_port(ds, port);
 260         struct dsa_mac_addr *a;
 261         int err;
 262
 263         /* No need to bother with refcounting for user ports */
 264         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 265                 return ds->ops->port_fdb_add(ds, port, addr, vid);
 266
 267         a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
 268         if (a) {
 269                 refcount_inc(&a->refcount);
 270                 return 0;
 271         }
 272
 273         a = kzalloc(sizeof(*a), GFP_KERNEL);
 274         if (!a)
 275                 return -ENOMEM;
 276
 277         err = ds->ops->port_fdb_add(ds, port, addr, vid);
 278         if (err) {
 279                 kfree(a);
 280                 return err;
 281         }
 282
 283         ether_addr_copy(a->addr, addr);
 284         a->vid = vid;
 285         refcount_set(&a->refcount, 1);
 286         list_add_tail(&a->list, &dp->fdbs);
 287
 288         return 0;
 289 }
 290
 291 static int dsa_switch_do_fdb_del(struct dsa_switch *ds, int port,
 292                                  const unsigned char *addr, u16 vid)
 293 {
 294         struct dsa_port *dp = dsa_to_port(ds, port);
 295         struct dsa_mac_addr *a;
 296         int err;
 297
 298         /* No need to bother with refcounting for user ports */
 299         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 300                 return ds->ops->port_fdb_del(ds, port, addr, vid);
 301
 302         a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
 303         if (!a)
 304                 return -ENOENT;
 305
 306         if (!refcount_dec_and_test(&a->refcount))
 307                 return 0;
 308
 309         err = ds->ops->port_fdb_del(ds, port, addr, vid);
 310         if (err) {
 311                 refcount_inc(&a->refcount);
 312                 return err;
 313         }
 314
 315         list_del(&a->list);
 316         kfree(a);
 317
 318         return 0;
 319 }
 320
 321 static int dsa_switch_host_fdb_add(struct dsa_switch *ds,
 322                                    struct dsa_notifier_fdb_info *info)
 323 {
 324         int err = 0;
 325         int port;
 326
 327         if (!ds->ops->port_fdb_add)
 328                 return -EOPNOTSUPP;
 329
 330         for (port = 0; port < ds->num_ports; port++) {
 331                 if (dsa_switch_host_address_match(ds, port, info->sw_index,
 332                                                   info->port)) {
 333                         err = dsa_switch_do_fdb_add(ds, port, info->addr,
 334                                                     info->vid);
 335                         if (err)
 336                                 break;
 337                 }
 338         }
 339
 340         return err;
 341 }
 342
 343 static int dsa_switch_host_fdb_del(struct dsa_switch *ds,
 344                                    struct dsa_notifier_fdb_info *info)
 345 {
 346         int err = 0;
 347         int port;
 348
 349         if (!ds->ops->port_fdb_del)
 350                 return -EOPNOTSUPP;
 351
 352         for (port = 0; port < ds->num_ports; port++) {
 353                 if (dsa_switch_host_address_match(ds, port, info->sw_index,
 354                                                   info->port)) {
 355                         err = dsa_switch_do_fdb_del(ds, port, info->addr,
 356                                                     info->vid);
 357                         if (err)
 358                                 break;
 359                 }
 360         }
 361
 362         return err;
 363 }
 364
 365 static int dsa_switch_fdb_add(struct dsa_switch *ds,
 366                               struct dsa_notifier_fdb_info *info)
 367 {
 368         int port = dsa_towards_port(ds, info->sw_index, info->port);
 369
 370         if (!ds->ops->port_fdb_add)
 371                 return -EOPNOTSUPP;
 372
 373         return dsa_switch_do_fdb_add(ds, port, info->addr, info->vid);
 374 }
 375
 376 static int dsa_switch_fdb_del(struct dsa_switch *ds,
 377                               struct dsa_notifier_fdb_info *info)
 378 {
 379         int port = dsa_towards_port(ds, info->sw_index, info->port);
 380
 381         if (!ds->ops->port_fdb_del)
 382                 return -EOPNOTSUPP;
 383
 384         return dsa_switch_do_fdb_del(ds, port, info->addr, info->vid);
 385 }
 386
 387 static int dsa_switch_hsr_join(struct dsa_switch *ds,
 388                                struct dsa_notifier_hsr_info *info)
 389 {
 390         if (ds->index == info->sw_index && ds->ops->port_hsr_join)
 391                 return ds->ops->port_hsr_join(ds, info->port, info->hsr);
 392
 393         return -EOPNOTSUPP;
 394 }
 395
 396 static int dsa_switch_hsr_leave(struct dsa_switch *ds,
 397                                 struct dsa_notifier_hsr_info *info)
 398 {
 399         if (ds->index == info->sw_index && ds->ops->port_hsr_leave)
 400                 return ds->ops->port_hsr_leave(ds, info->port, info->hsr);
 401
 402         return -EOPNOTSUPP;
 403 }
 404
 405 static int dsa_switch_lag_change(struct dsa_switch *ds,
 406                                  struct dsa_notifier_lag_info *info)
 407 {
 408         if (ds->index == info->sw_index && ds->ops->port_lag_change)
 409                 return ds->ops->port_lag_change(ds, info->port);
 410
 411         if (ds->index != info->sw_index && ds->ops->crosschip_lag_change)
 412                 return ds->ops->crosschip_lag_change(ds, info->sw_index,
 413                                                      info->port);
 414
 415         return 0;
 416 }
 417
 418 static int dsa_switch_lag_join(struct dsa_switch *ds,
 419                                struct dsa_notifier_lag_info *info)
 420 {
 421         if (ds->index == info->sw_index && ds->ops->port_lag_join)
 422                 return ds->ops->port_lag_join(ds, info->port, info->lag,
 423                                               info->info);
 424
 425         if (ds->index != info->sw_index && ds->ops->crosschip_lag_join)
 426                 return ds->ops->crosschip_lag_join(ds, info->sw_index,
 427                                                    info->port, info->lag,
 428                                                    info->info);
 429
 430         return -EOPNOTSUPP;
 431 }
 432
 433 static int dsa_switch_lag_leave(struct dsa_switch *ds,
 434                                 struct dsa_notifier_lag_info *info)
 435 {
 436         if (ds->index == info->sw_index && ds->ops->port_lag_leave)
 437                 return ds->ops->port_lag_leave(ds, info->port, info->lag);
 438
 439         if (ds->index != info->sw_index && ds->ops->crosschip_lag_leave)
 440                 return ds->ops->crosschip_lag_leave(ds, info->sw_index,
 441                                                     info->port, info->lag);
 442
 443         return -EOPNOTSUPP;
 444 }
 445
 446 static int dsa_switch_mdb_add(struct dsa_switch *ds,
 447                               struct dsa_notifier_mdb_info *info)
 448 {
 449         int port = dsa_towards_port(ds, info->sw_index, info->port);
 450
 451         if (!ds->ops->port_mdb_add)
 452                 return -EOPNOTSUPP;
 453
 454         return dsa_switch_do_mdb_add(ds, port, info->mdb);
 455 }
 456
 457 static int dsa_switch_mdb_del(struct dsa_switch *ds,
 458                               struct dsa_notifier_mdb_info *info)
 459 {
 460         int port = dsa_towards_port(ds, info->sw_index, info->port);
 461
 462         if (!ds->ops->port_mdb_del)
 463                 return -EOPNOTSUPP;
 464
 465         return dsa_switch_do_mdb_del(ds, port, info->mdb);
 466 }
 467
 468 static int dsa_switch_host_mdb_add(struct dsa_switch *ds,
 469                                    struct dsa_notifier_mdb_info *info)
 470 {
 471         int err = 0;
 472         int port;
 473
 474         if (!ds->ops->port_mdb_add)
 475                 return -EOPNOTSUPP;
 476
 477         for (port = 0; port < ds->num_ports; port++) {
 478                 if (dsa_switch_host_address_match(ds, port, info->sw_index,
 479                                                   info->port)) {
 480                         err = dsa_switch_do_mdb_add(ds, port, info->mdb);
 481                         if (err)
 482                                 break;
 483                 }
 484         }
 485
 486         return err;
 487 }
 488
 489 static int dsa_switch_host_mdb_del(struct dsa_switch *ds,
 490                                    struct dsa_notifier_mdb_info *info)
 491 {
 492         int err = 0;
 493         int port;
 494
 495         if (!ds->ops->port_mdb_del)
 496                 return -EOPNOTSUPP;
 497
 498         for (port = 0; port < ds->num_ports; port++) {
 499                 if (dsa_switch_host_address_match(ds, port, info->sw_index,
 500                                                   info->port)) {
 501                         err = dsa_switch_do_mdb_del(ds, port, info->mdb);
 502                         if (err)
 503                                 break;
 504                 }
 505         }
 506
 507         return err;
 508 }
 509
 510 static bool dsa_switch_vlan_match(struct dsa_switch *ds, int port,
 511                                   struct dsa_notifier_vlan_info *info)
 512 {
 513         if (ds->index == info->sw_index && port == info->port)
 514                 return true;
 515
 516         if (dsa_is_dsa_port(ds, port))
 517                 return true;
 518
 519         return false;
 520 }
 521
 522 static int dsa_switch_vlan_add(struct dsa_switch *ds,
 523                                struct dsa_notifier_vlan_info *info)
 524 {
 525         int port, err;
 526
 527         if (!ds->ops->port_vlan_add)
 528                 return -EOPNOTSUPP;
 529
 530         for (port = 0; port < ds->num_ports; port++) {
 531                 if (dsa_switch_vlan_match(ds, port, info)) {
 532                         err = ds->ops->port_vlan_add(ds, port, info->vlan,
 533                                                      info->extack);
 534                         if (err)
 535                                 return err;
 536                 }
 537         }
 538
 539         return 0;
 540 }
 541
 542 static int dsa_switch_vlan_del(struct dsa_switch *ds,
 543                                struct dsa_notifier_vlan_info *info)
 544 {
 545         if (!ds->ops->port_vlan_del)
 546                 return -EOPNOTSUPP;
 547
 548         if (ds->index == info->sw_index)
 549                 return ds->ops->port_vlan_del(ds, info->port, info->vlan);
 550
 551         /* Do not deprogram the DSA links as they may be used as conduit
 552          * for other VLAN members in the fabric.
 553          */
 554         return 0;
 555 }
 556
 557 static int dsa_switch_change_tag_proto(struct dsa_switch *ds,
 558                                        struct dsa_notifier_tag_proto_info *info)
 559 {
 560         const struct dsa_device_ops *tag_ops = info->tag_ops;
 561         int port, err;
 562
 563         if (!ds->ops->change_tag_protocol)
 564                 return -EOPNOTSUPP;
 565
 566         ASSERT_RTNL();
 567
 568         for (port = 0; port < ds->num_ports; port++) {
 569                 if (!dsa_is_cpu_port(ds, port))
 570                         continue;
 571
 572                 err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
 573                 if (err)
 574                         return err;
 575
 576                 dsa_port_set_tag_protocol(dsa_to_port(ds, port), tag_ops);
 577         }
 578
 579         /* Now that changing the tag protocol can no longer fail, let's update
 580          * the remaining bits which are "duplicated for faster access", and the
 581          * bits that depend on the tagger, such as the MTU.
 582          */
 583         for (port = 0; port < ds->num_ports; port++) {
 584                 if (dsa_is_user_port(ds, port)) {
 585                         struct net_device *slave;
 586
 587                         slave = dsa_to_port(ds, port)->slave;
 588                         dsa_slave_setup_tagger(slave);
 589
 590                         /* rtnl_mutex is held in dsa_tree_change_tag_proto */
 591                         dsa_slave_change_mtu(slave, slave->mtu);
 592                 }
 593         }
 594
 595         return 0;
 596 }
 597
 598 static int dsa_switch_mrp_add(struct dsa_switch *ds,
 599                               struct dsa_notifier_mrp_info *info)
 600 {
 601         if (!ds->ops->port_mrp_add)
 602                 return -EOPNOTSUPP;
 603
 604         if (ds->index == info->sw_index)
 605                 return ds->ops->port_mrp_add(ds, info->port, info->mrp);
 606
 607         return 0;
 608 }
 609
 610 static int dsa_switch_mrp_del(struct dsa_switch *ds,
 611                               struct dsa_notifier_mrp_info *info)
 612 {
 613         if (!ds->ops->port_mrp_del)
 614                 return -EOPNOTSUPP;
 615
 616         if (ds->index == info->sw_index)
 617                 return ds->ops->port_mrp_del(ds, info->port, info->mrp);
 618
 619         return 0;
 620 }
 621
 622 static int
 623 dsa_switch_mrp_add_ring_role(struct dsa_switch *ds,
 624                              struct dsa_notifier_mrp_ring_role_info *info)
 625 {
 626         if (!ds->ops->port_mrp_add)
 627                 return -EOPNOTSUPP;
 628
 629         if (ds->index == info->sw_index)
 630                 return ds->ops->port_mrp_add_ring_role(ds, info->port,
 631                                                        info->mrp);
 632
 633         return 0;
 634 }
 635
 636 static int
 637 dsa_switch_mrp_del_ring_role(struct dsa_switch *ds,
 638                              struct dsa_notifier_mrp_ring_role_info *info)
 639 {
 640         if (!ds->ops->port_mrp_del)
 641                 return -EOPNOTSUPP;
 642
 643         if (ds->index == info->sw_index)
 644                 return ds->ops->port_mrp_del_ring_role(ds, info->port,
 645                                                        info->mrp);
 646
 647         return 0;
 648 }
 649
 650 static int dsa_switch_event(struct notifier_block *nb,
 651                             unsigned long event, void *info)
 652 {
 653         struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
 654         int err;
 655
 656         switch (event) {
 657         case DSA_NOTIFIER_AGEING_TIME:
 658                 err = dsa_switch_ageing_time(ds, info);
 659                 break;
 660         case DSA_NOTIFIER_BRIDGE_JOIN:
 661                 err = dsa_switch_bridge_join(ds, info);
 662                 break;
 663         case DSA_NOTIFIER_BRIDGE_LEAVE:
 664                 err = dsa_switch_bridge_leave(ds, info);
 665                 break;
 666         case DSA_NOTIFIER_FDB_ADD:
 667                 err = dsa_switch_fdb_add(ds, info);
 668                 break;
 669         case DSA_NOTIFIER_FDB_DEL:
 670                 err = dsa_switch_fdb_del(ds, info);
 671                 break;
 672         case DSA_NOTIFIER_HOST_FDB_ADD:
 673                 err = dsa_switch_host_fdb_add(ds, info);
 674                 break;
 675         case DSA_NOTIFIER_HOST_FDB_DEL:
 676                 err = dsa_switch_host_fdb_del(ds, info);
 677                 break;
 678         case DSA_NOTIFIER_HSR_JOIN:
 679                 err = dsa_switch_hsr_join(ds, info);
 680                 break;
 681         case DSA_NOTIFIER_HSR_LEAVE:
 682                 err = dsa_switch_hsr_leave(ds, info);
 683                 break;
 684         case DSA_NOTIFIER_LAG_CHANGE:
 685                 err = dsa_switch_lag_change(ds, info);
 686                 break;
 687         case DSA_NOTIFIER_LAG_JOIN:
 688                 err = dsa_switch_lag_join(ds, info);
 689                 break;
 690         case DSA_NOTIFIER_LAG_LEAVE:
 691                 err = dsa_switch_lag_leave(ds, info);
 692                 break;
 693         case DSA_NOTIFIER_MDB_ADD:
 694                 err = dsa_switch_mdb_add(ds, info);
 695                 break;
 696         case DSA_NOTIFIER_MDB_DEL:
 697                 err = dsa_switch_mdb_del(ds, info);
 698                 break;
 699         case DSA_NOTIFIER_HOST_MDB_ADD:
 700                 err = dsa_switch_host_mdb_add(ds, info);
 701                 break;
 702         case DSA_NOTIFIER_HOST_MDB_DEL:
 703                 err = dsa_switch_host_mdb_del(ds, info);
 704                 break;
 705         case DSA_NOTIFIER_VLAN_ADD:
 706                 err = dsa_switch_vlan_add(ds, info);
 707                 break;
 708         case DSA_NOTIFIER_VLAN_DEL:
 709                 err = dsa_switch_vlan_del(ds, info);
 710                 break;
 711         case DSA_NOTIFIER_MTU:
 712                 err = dsa_switch_mtu(ds, info);
 713                 break;
 714         case DSA_NOTIFIER_TAG_PROTO:
 715                 err = dsa_switch_change_tag_proto(ds, info);
 716                 break;
 717         case DSA_NOTIFIER_MRP_ADD:
 718                 err = dsa_switch_mrp_add(ds, info);
 719                 break;
 720         case DSA_NOTIFIER_MRP_DEL:
 721                 err = dsa_switch_mrp_del(ds, info);
 722                 break;
 723         case DSA_NOTIFIER_MRP_ADD_RING_ROLE:
 724                 err = dsa_switch_mrp_add_ring_role(ds, info);
 725                 break;
 726         case DSA_NOTIFIER_MRP_DEL_RING_ROLE:
 727                 err = dsa_switch_mrp_del_ring_role(ds, info);
 728                 break;
 729         default:
 730                 err = -EOPNOTSUPP;
 731                 break;
 732         }
 733
 734         if (err)
 735                 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
 736                         event, err);
 737
 738         return notifier_from_errno(err);
 739 }
 740
 741 int dsa_switch_register_notifier(struct dsa_switch *ds)
 742 {
 743         ds->nb.notifier_call = dsa_switch_event;
 744
 745         return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
 746 }
 747
 748 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
 749 {
 750         int err;
 751
 752         err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
 753         if (err)
 754                 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
 755 }