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 <[email protected]>
   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         struct dsa_port *dp;
  21
  22         dsa_switch_for_each_port(dp, ds)
  23                 if (dp->ageing_time && dp->ageing_time < ageing_time)
  24                         ageing_time = dp->ageing_time;
  25
  26         return ageing_time;
  27 }
  28
  29 static int dsa_switch_ageing_time(struct dsa_switch *ds,
  30                                   struct dsa_notifier_ageing_time_info *info)
  31 {
  32         unsigned int ageing_time = info->ageing_time;
  33
  34         if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
  35                 return -ERANGE;
  36
  37         if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
  38                 return -ERANGE;
  39
  40         /* Program the fastest ageing time in case of multiple bridges */
  41         ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
  42
  43         if (ds->ops->set_ageing_time)
  44                 return ds->ops->set_ageing_time(ds, ageing_time);
  45
  46         return 0;
  47 }
  48
  49 static bool dsa_port_mtu_match(struct dsa_port *dp,
  50                                struct dsa_notifier_mtu_info *info)
  51 {
  52         return dp == info->dp || dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp);
  53 }
  54
  55 static int dsa_switch_mtu(struct dsa_switch *ds,
  56                           struct dsa_notifier_mtu_info *info)
  57 {
  58         struct dsa_port *dp;
  59         int ret;
  60
  61         if (!ds->ops->port_change_mtu)
  62                 return -EOPNOTSUPP;
  63
  64         dsa_switch_for_each_port(dp, ds) {
  65                 if (dsa_port_mtu_match(dp, info)) {
  66                         ret = ds->ops->port_change_mtu(ds, dp->index,
  67                                                        info->mtu);
  68                         if (ret)
  69                                 return ret;
  70                 }
  71         }
  72
  73         return 0;
  74 }
  75
  76 static int dsa_switch_bridge_join(struct dsa_switch *ds,
  77                                   struct dsa_notifier_bridge_info *info)
  78 {
  79         int err;
  80
  81         if (info->dp->ds == ds) {
  82                 if (!ds->ops->port_bridge_join)
  83                         return -EOPNOTSUPP;
  84
  85                 err = ds->ops->port_bridge_join(ds, info->dp->index,
  86                                                 info->bridge,
  87                                                 &info->tx_fwd_offload,
  88                                                 info->extack);
  89                 if (err)
  90                         return err;
  91         }
  92
  93         if (info->dp->ds != ds && ds->ops->crosschip_bridge_join) {
  94                 err = ds->ops->crosschip_bridge_join(ds,
  95                                                      info->dp->ds->dst->index,
  96                                                      info->dp->ds->index,
  97                                                      info->dp->index,
  98                                                      info->bridge,
  99                                                      info->extack);
 100                 if (err)
 101                         return err;
 102         }
 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         if (info->dp->ds == ds && ds->ops->port_bridge_leave)
 111                 ds->ops->port_bridge_leave(ds, info->dp->index, info->bridge);
 112
 113         if (info->dp->ds != ds && ds->ops->crosschip_bridge_leave)
 114                 ds->ops->crosschip_bridge_leave(ds, info->dp->ds->dst->index,
 115                                                 info->dp->ds->index,
 116                                                 info->dp->index,
 117                                                 info->bridge);
 118
 119         return 0;
 120 }
 121
 122 /* Matches for all upstream-facing ports (the CPU port and all upstream-facing
 123  * DSA links) that sit between the targeted port on which the notifier was
 124  * emitted and its dedicated CPU port.
 125  */
 126 static bool dsa_port_host_address_match(struct dsa_port *dp,
 127                                         const struct dsa_port *targeted_dp)
 128 {
 129         struct dsa_port *cpu_dp = targeted_dp->cpu_dp;
 130
 131         if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds))
 132                 return dp->index == dsa_towards_port(dp->ds, cpu_dp->ds->index,
 133                                                      cpu_dp->index);
 134
 135         return false;
 136 }
 137
 138 static struct dsa_mac_addr *dsa_mac_addr_find(struct list_head *addr_list,
 139                                               const unsigned char *addr, u16 vid,
 140                                               struct dsa_db db)
 141 {
 142         struct dsa_mac_addr *a;
 143
 144         list_for_each_entry(a, addr_list, list)
 145                 if (ether_addr_equal(a->addr, addr) && a->vid == vid &&
 146                     dsa_db_equal(&a->db, &db))
 147                         return a;
 148
 149         return NULL;
 150 }
 151
 152 static int dsa_port_do_mdb_add(struct dsa_port *dp,
 153                                const struct switchdev_obj_port_mdb *mdb,
 154                                struct dsa_db db)
 155 {
 156         struct dsa_switch *ds = dp->ds;
 157         struct dsa_mac_addr *a;
 158         int port = dp->index;
 159         int err = 0;
 160
 161         /* No need to bother with refcounting for user ports */
 162         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 163                 return ds->ops->port_mdb_add(ds, port, mdb, db);
 164
 165         mutex_lock(&dp->addr_lists_lock);
 166
 167         a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db);
 168         if (a) {
 169                 refcount_inc(&a->refcount);
 170                 goto out;
 171         }
 172
 173         a = kzalloc(sizeof(*a), GFP_KERNEL);
 174         if (!a) {
 175                 err = -ENOMEM;
 176                 goto out;
 177         }
 178
 179         err = ds->ops->port_mdb_add(ds, port, mdb, db);
 180         if (err) {
 181                 kfree(a);
 182                 goto out;
 183         }
 184
 185         ether_addr_copy(a->addr, mdb->addr);
 186         a->vid = mdb->vid;
 187         a->db = db;
 188         refcount_set(&a->refcount, 1);
 189         list_add_tail(&a->list, &dp->mdbs);
 190
 191 out:
 192         mutex_unlock(&dp->addr_lists_lock);
 193
 194         return err;
 195 }
 196
 197 static int dsa_port_do_mdb_del(struct dsa_port *dp,
 198                                const struct switchdev_obj_port_mdb *mdb,
 199                                struct dsa_db db)
 200 {
 201         struct dsa_switch *ds = dp->ds;
 202         struct dsa_mac_addr *a;
 203         int port = dp->index;
 204         int err = 0;
 205
 206         /* No need to bother with refcounting for user ports */
 207         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 208                 return ds->ops->port_mdb_del(ds, port, mdb, db);
 209
 210         mutex_lock(&dp->addr_lists_lock);
 211
 212         a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db);
 213         if (!a) {
 214                 err = -ENOENT;
 215                 goto out;
 216         }
 217
 218         if (!refcount_dec_and_test(&a->refcount))
 219                 goto out;
 220
 221         err = ds->ops->port_mdb_del(ds, port, mdb, db);
 222         if (err) {
 223                 refcount_set(&a->refcount, 1);
 224                 goto out;
 225         }
 226
 227         list_del(&a->list);
 228         kfree(a);
 229
 230 out:
 231         mutex_unlock(&dp->addr_lists_lock);
 232
 233         return err;
 234 }
 235
 236 static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 237                                u16 vid, struct dsa_db db)
 238 {
 239         struct dsa_switch *ds = dp->ds;
 240         struct dsa_mac_addr *a;
 241         int port = dp->index;
 242         int err = 0;
 243
 244         /* No need to bother with refcounting for user ports */
 245         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 246                 return ds->ops->port_fdb_add(ds, port, addr, vid, db);
 247
 248         mutex_lock(&dp->addr_lists_lock);
 249
 250         a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db);
 251         if (a) {
 252                 refcount_inc(&a->refcount);
 253                 goto out;
 254         }
 255
 256         a = kzalloc(sizeof(*a), GFP_KERNEL);
 257         if (!a) {
 258                 err = -ENOMEM;
 259                 goto out;
 260         }
 261
 262         err = ds->ops->port_fdb_add(ds, port, addr, vid, db);
 263         if (err) {
 264                 kfree(a);
 265                 goto out;
 266         }
 267
 268         ether_addr_copy(a->addr, addr);
 269         a->vid = vid;
 270         a->db = db;
 271         refcount_set(&a->refcount, 1);
 272         list_add_tail(&a->list, &dp->fdbs);
 273
 274 out:
 275         mutex_unlock(&dp->addr_lists_lock);
 276
 277         return err;
 278 }
 279
 280 static int dsa_port_do_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 281                                u16 vid, struct dsa_db db)
 282 {
 283         struct dsa_switch *ds = dp->ds;
 284         struct dsa_mac_addr *a;
 285         int port = dp->index;
 286         int err = 0;
 287
 288         /* No need to bother with refcounting for user ports */
 289         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 290                 return ds->ops->port_fdb_del(ds, port, addr, vid, db);
 291
 292         mutex_lock(&dp->addr_lists_lock);
 293
 294         a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db);
 295         if (!a) {
 296                 err = -ENOENT;
 297                 goto out;
 298         }
 299
 300         if (!refcount_dec_and_test(&a->refcount))
 301                 goto out;
 302
 303         err = ds->ops->port_fdb_del(ds, port, addr, vid, db);
 304         if (err) {
 305                 refcount_set(&a->refcount, 1);
 306                 goto out;
 307         }
 308
 309         list_del(&a->list);
 310         kfree(a);
 311
 312 out:
 313         mutex_unlock(&dp->addr_lists_lock);
 314
 315         return err;
 316 }
 317
 318 static int dsa_switch_do_lag_fdb_add(struct dsa_switch *ds, struct dsa_lag *lag,
 319                                      const unsigned char *addr, u16 vid,
 320                                      struct dsa_db db)
 321 {
 322         struct dsa_mac_addr *a;
 323         int err = 0;
 324
 325         mutex_lock(&lag->fdb_lock);
 326
 327         a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db);
 328         if (a) {
 329                 refcount_inc(&a->refcount);
 330                 goto out;
 331         }
 332
 333         a = kzalloc(sizeof(*a), GFP_KERNEL);
 334         if (!a) {
 335                 err = -ENOMEM;
 336                 goto out;
 337         }
 338
 339         err = ds->ops->lag_fdb_add(ds, *lag, addr, vid, db);
 340         if (err) {
 341                 kfree(a);
 342                 goto out;
 343         }
 344
 345         ether_addr_copy(a->addr, addr);
 346         a->vid = vid;
 347         refcount_set(&a->refcount, 1);
 348         list_add_tail(&a->list, &lag->fdbs);
 349
 350 out:
 351         mutex_unlock(&lag->fdb_lock);
 352
 353         return err;
 354 }
 355
 356 static int dsa_switch_do_lag_fdb_del(struct dsa_switch *ds, struct dsa_lag *lag,
 357                                      const unsigned char *addr, u16 vid,
 358                                      struct dsa_db db)
 359 {
 360         struct dsa_mac_addr *a;
 361         int err = 0;
 362
 363         mutex_lock(&lag->fdb_lock);
 364
 365         a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db);
 366         if (!a) {
 367                 err = -ENOENT;
 368                 goto out;
 369         }
 370
 371         if (!refcount_dec_and_test(&a->refcount))
 372                 goto out;
 373
 374         err = ds->ops->lag_fdb_del(ds, *lag, addr, vid, db);
 375         if (err) {
 376                 refcount_set(&a->refcount, 1);
 377                 goto out;
 378         }
 379
 380         list_del(&a->list);
 381         kfree(a);
 382
 383 out:
 384         mutex_unlock(&lag->fdb_lock);
 385
 386         return err;
 387 }
 388
 389 static int dsa_switch_host_fdb_add(struct dsa_switch *ds,
 390                                    struct dsa_notifier_fdb_info *info)
 391 {
 392         struct dsa_port *dp;
 393         int err = 0;
 394
 395         if (!ds->ops->port_fdb_add)
 396                 return -EOPNOTSUPP;
 397
 398         dsa_switch_for_each_port(dp, ds) {
 399                 if (dsa_port_host_address_match(dp, info->dp)) {
 400                         err = dsa_port_do_fdb_add(dp, info->addr, info->vid,
 401                                                   info->db);
 402                         if (err)
 403                                 break;
 404                 }
 405         }
 406
 407         return err;
 408 }
 409
 410 static int dsa_switch_host_fdb_del(struct dsa_switch *ds,
 411                                    struct dsa_notifier_fdb_info *info)
 412 {
 413         struct dsa_port *dp;
 414         int err = 0;
 415
 416         if (!ds->ops->port_fdb_del)
 417                 return -EOPNOTSUPP;
 418
 419         dsa_switch_for_each_port(dp, ds) {
 420                 if (dsa_port_host_address_match(dp, info->dp)) {
 421                         err = dsa_port_do_fdb_del(dp, info->addr, info->vid,
 422                                                   info->db);
 423                         if (err)
 424                                 break;
 425                 }
 426         }
 427
 428         return err;
 429 }
 430
 431 static int dsa_switch_fdb_add(struct dsa_switch *ds,
 432                               struct dsa_notifier_fdb_info *info)
 433 {
 434         int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
 435         struct dsa_port *dp = dsa_to_port(ds, port);
 436
 437         if (!ds->ops->port_fdb_add)
 438                 return -EOPNOTSUPP;
 439
 440         return dsa_port_do_fdb_add(dp, info->addr, info->vid, info->db);
 441 }
 442
 443 static int dsa_switch_fdb_del(struct dsa_switch *ds,
 444                               struct dsa_notifier_fdb_info *info)
 445 {
 446         int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
 447         struct dsa_port *dp = dsa_to_port(ds, port);
 448
 449         if (!ds->ops->port_fdb_del)
 450                 return -EOPNOTSUPP;
 451
 452         return dsa_port_do_fdb_del(dp, info->addr, info->vid, info->db);
 453 }
 454
 455 static int dsa_switch_lag_fdb_add(struct dsa_switch *ds,
 456                                   struct dsa_notifier_lag_fdb_info *info)
 457 {
 458         struct dsa_port *dp;
 459
 460         if (!ds->ops->lag_fdb_add)
 461                 return -EOPNOTSUPP;
 462
 463         /* Notify switch only if it has a port in this LAG */
 464         dsa_switch_for_each_port(dp, ds)
 465                 if (dsa_port_offloads_lag(dp, info->lag))
 466                         return dsa_switch_do_lag_fdb_add(ds, info->lag,
 467                                                          info->addr, info->vid,
 468                                                          info->db);
 469
 470         return 0;
 471 }
 472
 473 static int dsa_switch_lag_fdb_del(struct dsa_switch *ds,
 474                                   struct dsa_notifier_lag_fdb_info *info)
 475 {
 476         struct dsa_port *dp;
 477
 478         if (!ds->ops->lag_fdb_del)
 479                 return -EOPNOTSUPP;
 480
 481         /* Notify switch only if it has a port in this LAG */
 482         dsa_switch_for_each_port(dp, ds)
 483                 if (dsa_port_offloads_lag(dp, info->lag))
 484                         return dsa_switch_do_lag_fdb_del(ds, info->lag,
 485                                                          info->addr, info->vid,
 486                                                          info->db);
 487
 488         return 0;
 489 }
 490
 491 static int dsa_switch_lag_change(struct dsa_switch *ds,
 492                                  struct dsa_notifier_lag_info *info)
 493 {
 494         if (info->dp->ds == ds && ds->ops->port_lag_change)
 495                 return ds->ops->port_lag_change(ds, info->dp->index);
 496
 497         if (info->dp->ds != ds && ds->ops->crosschip_lag_change)
 498                 return ds->ops->crosschip_lag_change(ds, info->dp->ds->index,
 499                                                      info->dp->index);
 500
 501         return 0;
 502 }
 503
 504 static int dsa_switch_lag_join(struct dsa_switch *ds,
 505                                struct dsa_notifier_lag_info *info)
 506 {
 507         if (info->dp->ds == ds && ds->ops->port_lag_join)
 508                 return ds->ops->port_lag_join(ds, info->dp->index, info->lag,
 509                                               info->info);
 510
 511         if (info->dp->ds != ds && ds->ops->crosschip_lag_join)
 512                 return ds->ops->crosschip_lag_join(ds, info->dp->ds->index,
 513                                                    info->dp->index, info->lag,
 514                                                    info->info);
 515
 516         return -EOPNOTSUPP;
 517 }
 518
 519 static int dsa_switch_lag_leave(struct dsa_switch *ds,
 520                                 struct dsa_notifier_lag_info *info)
 521 {
 522         if (info->dp->ds == ds && ds->ops->port_lag_leave)
 523                 return ds->ops->port_lag_leave(ds, info->dp->index, info->lag);
 524
 525         if (info->dp->ds != ds && ds->ops->crosschip_lag_leave)
 526                 return ds->ops->crosschip_lag_leave(ds, info->dp->ds->index,
 527                                                     info->dp->index, info->lag);
 528
 529         return -EOPNOTSUPP;
 530 }
 531
 532 static int dsa_switch_mdb_add(struct dsa_switch *ds,
 533                               struct dsa_notifier_mdb_info *info)
 534 {
 535         int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
 536         struct dsa_port *dp = dsa_to_port(ds, port);
 537
 538         if (!ds->ops->port_mdb_add)
 539                 return -EOPNOTSUPP;
 540
 541         return dsa_port_do_mdb_add(dp, info->mdb, info->db);
 542 }
 543
 544 static int dsa_switch_mdb_del(struct dsa_switch *ds,
 545                               struct dsa_notifier_mdb_info *info)
 546 {
 547         int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
 548         struct dsa_port *dp = dsa_to_port(ds, port);
 549
 550         if (!ds->ops->port_mdb_del)
 551                 return -EOPNOTSUPP;
 552
 553         return dsa_port_do_mdb_del(dp, info->mdb, info->db);
 554 }
 555
 556 static int dsa_switch_host_mdb_add(struct dsa_switch *ds,
 557                                    struct dsa_notifier_mdb_info *info)
 558 {
 559         struct dsa_port *dp;
 560         int err = 0;
 561
 562         if (!ds->ops->port_mdb_add)
 563                 return -EOPNOTSUPP;
 564
 565         dsa_switch_for_each_port(dp, ds) {
 566                 if (dsa_port_host_address_match(dp, info->dp)) {
 567                         err = dsa_port_do_mdb_add(dp, info->mdb, info->db);
 568                         if (err)
 569                                 break;
 570                 }
 571         }
 572
 573         return err;
 574 }
 575
 576 static int dsa_switch_host_mdb_del(struct dsa_switch *ds,
 577                                    struct dsa_notifier_mdb_info *info)
 578 {
 579         struct dsa_port *dp;
 580         int err = 0;
 581
 582         if (!ds->ops->port_mdb_del)
 583                 return -EOPNOTSUPP;
 584
 585         dsa_switch_for_each_port(dp, ds) {
 586                 if (dsa_port_host_address_match(dp, info->dp)) {
 587                         err = dsa_port_do_mdb_del(dp, info->mdb, info->db);
 588                         if (err)
 589                                 break;
 590                 }
 591         }
 592
 593         return err;
 594 }
 595
 596 /* Port VLANs match on the targeted port and on all DSA ports */
 597 static bool dsa_port_vlan_match(struct dsa_port *dp,
 598                                 struct dsa_notifier_vlan_info *info)
 599 {
 600         return dsa_port_is_dsa(dp) || dp == info->dp;
 601 }
 602
 603 /* Host VLANs match on the targeted port's CPU port, and on all DSA ports
 604  * (upstream and downstream) of that switch and its upstream switches.
 605  */
 606 static bool dsa_port_host_vlan_match(struct dsa_port *dp,
 607                                      const struct dsa_port *targeted_dp)
 608 {
 609         struct dsa_port *cpu_dp = targeted_dp->cpu_dp;
 610
 611         if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds))
 612                 return dsa_port_is_dsa(dp) || dp == cpu_dp;
 613
 614         return false;
 615 }
 616
 617 static struct dsa_vlan *dsa_vlan_find(struct list_head *vlan_list,
 618                                       const struct switchdev_obj_port_vlan *vlan)
 619 {
 620         struct dsa_vlan *v;
 621
 622         list_for_each_entry(v, vlan_list, list)
 623                 if (v->vid == vlan->vid)
 624                         return v;
 625
 626         return NULL;
 627 }
 628
 629 static int dsa_port_do_vlan_add(struct dsa_port *dp,
 630                                 const struct switchdev_obj_port_vlan *vlan,
 631                                 struct netlink_ext_ack *extack)
 632 {
 633         struct dsa_switch *ds = dp->ds;
 634         int port = dp->index;
 635         struct dsa_vlan *v;
 636         int err = 0;
 637
 638         /* No need to bother with refcounting for user ports. */
 639         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 640                 return ds->ops->port_vlan_add(ds, port, vlan, extack);
 641
 642         /* No need to propagate on shared ports the existing VLANs that were
 643          * re-notified after just the flags have changed. This would cause a
 644          * refcount bump which we need to avoid, since it unbalances the
 645          * additions with the deletions.
 646          */
 647         if (vlan->changed)
 648                 return 0;
 649
 650         mutex_lock(&dp->vlans_lock);
 651
 652         v = dsa_vlan_find(&dp->vlans, vlan);
 653         if (v) {
 654                 refcount_inc(&v->refcount);
 655                 goto out;
 656         }
 657
 658         v = kzalloc(sizeof(*v), GFP_KERNEL);
 659         if (!v) {
 660                 err = -ENOMEM;
 661                 goto out;
 662         }
 663
 664         err = ds->ops->port_vlan_add(ds, port, vlan, extack);
 665         if (err) {
 666                 kfree(v);
 667                 goto out;
 668         }
 669
 670         v->vid = vlan->vid;
 671         refcount_set(&v->refcount, 1);
 672         list_add_tail(&v->list, &dp->vlans);
 673
 674 out:
 675         mutex_unlock(&dp->vlans_lock);
 676
 677         return err;
 678 }
 679
 680 static int dsa_port_do_vlan_del(struct dsa_port *dp,
 681                                 const struct switchdev_obj_port_vlan *vlan)
 682 {
 683         struct dsa_switch *ds = dp->ds;
 684         int port = dp->index;
 685         struct dsa_vlan *v;
 686         int err = 0;
 687
 688         /* No need to bother with refcounting for user ports */
 689         if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
 690                 return ds->ops->port_vlan_del(ds, port, vlan);
 691
 692         mutex_lock(&dp->vlans_lock);
 693
 694         v = dsa_vlan_find(&dp->vlans, vlan);
 695         if (!v) {
 696                 err = -ENOENT;
 697                 goto out;
 698         }
 699
 700         if (!refcount_dec_and_test(&v->refcount))
 701                 goto out;
 702
 703         err = ds->ops->port_vlan_del(ds, port, vlan);
 704         if (err) {
 705                 refcount_set(&v->refcount, 1);
 706                 goto out;
 707         }
 708
 709         list_del(&v->list);
 710         kfree(v);
 711
 712 out:
 713         mutex_unlock(&dp->vlans_lock);
 714
 715         return err;
 716 }
 717
 718 static int dsa_switch_vlan_add(struct dsa_switch *ds,
 719                                struct dsa_notifier_vlan_info *info)
 720 {
 721         struct dsa_port *dp;
 722         int err;
 723
 724         if (!ds->ops->port_vlan_add)
 725                 return -EOPNOTSUPP;
 726
 727         dsa_switch_for_each_port(dp, ds) {
 728                 if (dsa_port_vlan_match(dp, info)) {
 729                         err = dsa_port_do_vlan_add(dp, info->vlan,
 730                                                    info->extack);
 731                         if (err)
 732                                 return err;
 733                 }
 734         }
 735
 736         return 0;
 737 }
 738
 739 static int dsa_switch_vlan_del(struct dsa_switch *ds,
 740                                struct dsa_notifier_vlan_info *info)
 741 {
 742         struct dsa_port *dp;
 743         int err;
 744
 745         if (!ds->ops->port_vlan_del)
 746                 return -EOPNOTSUPP;
 747
 748         dsa_switch_for_each_port(dp, ds) {
 749                 if (dsa_port_vlan_match(dp, info)) {
 750                         err = dsa_port_do_vlan_del(dp, info->vlan);
 751                         if (err)
 752                                 return err;
 753                 }
 754         }
 755
 756         return 0;
 757 }
 758
 759 static int dsa_switch_host_vlan_add(struct dsa_switch *ds,
 760                                     struct dsa_notifier_vlan_info *info)
 761 {
 762         struct dsa_port *dp;
 763         int err;
 764
 765         if (!ds->ops->port_vlan_add)
 766                 return -EOPNOTSUPP;
 767
 768         dsa_switch_for_each_port(dp, ds) {
 769                 if (dsa_port_host_vlan_match(dp, info->dp)) {
 770                         err = dsa_port_do_vlan_add(dp, info->vlan,
 771                                                    info->extack);
 772                         if (err)
 773                                 return err;
 774                 }
 775         }
 776
 777         return 0;
 778 }
 779
 780 static int dsa_switch_host_vlan_del(struct dsa_switch *ds,
 781                                     struct dsa_notifier_vlan_info *info)
 782 {
 783         struct dsa_port *dp;
 784         int err;
 785
 786         if (!ds->ops->port_vlan_del)
 787                 return -EOPNOTSUPP;
 788
 789         dsa_switch_for_each_port(dp, ds) {
 790                 if (dsa_port_host_vlan_match(dp, info->dp)) {
 791                         err = dsa_port_do_vlan_del(dp, info->vlan);
 792                         if (err)
 793                                 return err;
 794                 }
 795         }
 796
 797         return 0;
 798 }
 799
 800 static int dsa_switch_change_tag_proto(struct dsa_switch *ds,
 801                                        struct dsa_notifier_tag_proto_info *info)
 802 {
 803         const struct dsa_device_ops *tag_ops = info->tag_ops;
 804         struct dsa_port *dp, *cpu_dp;
 805         int err;
 806
 807         if (!ds->ops->change_tag_protocol)
 808                 return -EOPNOTSUPP;
 809
 810         ASSERT_RTNL();
 811
 812         err = ds->ops->change_tag_protocol(ds, tag_ops->proto);
 813         if (err)
 814                 return err;
 815
 816         dsa_switch_for_each_cpu_port(cpu_dp, ds)
 817                 dsa_port_set_tag_protocol(cpu_dp, tag_ops);
 818
 819         /* Now that changing the tag protocol can no longer fail, let's update
 820          * the remaining bits which are "duplicated for faster access", and the
 821          * bits that depend on the tagger, such as the MTU.
 822          */
 823         dsa_switch_for_each_user_port(dp, ds) {
 824                 struct net_device *slave = dp->slave;
 825
 826                 dsa_slave_setup_tagger(slave);
 827
 828                 /* rtnl_mutex is held in dsa_tree_change_tag_proto */
 829                 dsa_slave_change_mtu(slave, slave->mtu);
 830         }
 831
 832         return 0;
 833 }
 834
 835 /* We use the same cross-chip notifiers to inform both the tagger side, as well
 836  * as the switch side, of connection and disconnection events.
 837  * Since ds->tagger_data is owned by the tagger, it isn't a hard error if the
 838  * switch side doesn't support connecting to this tagger, and therefore, the
 839  * fact that we don't disconnect the tagger side doesn't constitute a memory
 840  * leak: the tagger will still operate with persistent per-switch memory, just
 841  * with the switch side unconnected to it. What does constitute a hard error is
 842  * when the switch side supports connecting but fails.
 843  */
 844 static int
 845 dsa_switch_connect_tag_proto(struct dsa_switch *ds,
 846                              struct dsa_notifier_tag_proto_info *info)
 847 {
 848         const struct dsa_device_ops *tag_ops = info->tag_ops;
 849         int err;
 850
 851         /* Notify the new tagger about the connection to this switch */
 852         if (tag_ops->connect) {
 853                 err = tag_ops->connect(ds);
 854                 if (err)
 855                         return err;
 856         }
 857
 858         if (!ds->ops->connect_tag_protocol)
 859                 return -EOPNOTSUPP;
 860
 861         /* Notify the switch about the connection to the new tagger */
 862         err = ds->ops->connect_tag_protocol(ds, tag_ops->proto);
 863         if (err) {
 864                 /* Revert the new tagger's connection to this tree */
 865                 if (tag_ops->disconnect)
 866                         tag_ops->disconnect(ds);
 867                 return err;
 868         }
 869
 870         return 0;
 871 }
 872
 873 static int
 874 dsa_switch_disconnect_tag_proto(struct dsa_switch *ds,
 875                                 struct dsa_notifier_tag_proto_info *info)
 876 {
 877         const struct dsa_device_ops *tag_ops = info->tag_ops;
 878
 879         /* Notify the tagger about the disconnection from this switch */
 880         if (tag_ops->disconnect && ds->tagger_data)
 881                 tag_ops->disconnect(ds);
 882
 883         /* No need to notify the switch, since it shouldn't have any
 884          * resources to tear down
 885          */
 886         return 0;
 887 }
 888
 889 static int
 890 dsa_switch_master_state_change(struct dsa_switch *ds,
 891                                struct dsa_notifier_master_state_info *info)
 892 {
 893         if (!ds->ops->master_state_change)
 894                 return 0;
 895
 896         ds->ops->master_state_change(ds, info->master, info->operational);
 897
 898         return 0;
 899 }
 900
 901 static int dsa_switch_event(struct notifier_block *nb,
 902                             unsigned long event, void *info)
 903 {
 904         struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
 905         int err;
 906
 907         switch (event) {
 908         case DSA_NOTIFIER_AGEING_TIME:
 909                 err = dsa_switch_ageing_time(ds, info);
 910                 break;
 911         case DSA_NOTIFIER_BRIDGE_JOIN:
 912                 err = dsa_switch_bridge_join(ds, info);
 913                 break;
 914         case DSA_NOTIFIER_BRIDGE_LEAVE:
 915                 err = dsa_switch_bridge_leave(ds, info);
 916                 break;
 917         case DSA_NOTIFIER_FDB_ADD:
 918                 err = dsa_switch_fdb_add(ds, info);
 919                 break;
 920         case DSA_NOTIFIER_FDB_DEL:
 921                 err = dsa_switch_fdb_del(ds, info);
 922                 break;
 923         case DSA_NOTIFIER_HOST_FDB_ADD:
 924                 err = dsa_switch_host_fdb_add(ds, info);
 925                 break;
 926         case DSA_NOTIFIER_HOST_FDB_DEL:
 927                 err = dsa_switch_host_fdb_del(ds, info);
 928                 break;
 929         case DSA_NOTIFIER_LAG_FDB_ADD:
 930                 err = dsa_switch_lag_fdb_add(ds, info);
 931                 break;
 932         case DSA_NOTIFIER_LAG_FDB_DEL:
 933                 err = dsa_switch_lag_fdb_del(ds, info);
 934                 break;
 935         case DSA_NOTIFIER_LAG_CHANGE:
 936                 err = dsa_switch_lag_change(ds, info);
 937                 break;
 938         case DSA_NOTIFIER_LAG_JOIN:
 939                 err = dsa_switch_lag_join(ds, info);
 940                 break;
 941         case DSA_NOTIFIER_LAG_LEAVE:
 942                 err = dsa_switch_lag_leave(ds, info);
 943                 break;
 944         case DSA_NOTIFIER_MDB_ADD:
 945                 err = dsa_switch_mdb_add(ds, info);
 946                 break;
 947         case DSA_NOTIFIER_MDB_DEL:
 948                 err = dsa_switch_mdb_del(ds, info);
 949                 break;
 950         case DSA_NOTIFIER_HOST_MDB_ADD:
 951                 err = dsa_switch_host_mdb_add(ds, info);
 952                 break;
 953         case DSA_NOTIFIER_HOST_MDB_DEL:
 954                 err = dsa_switch_host_mdb_del(ds, info);
 955                 break;
 956         case DSA_NOTIFIER_VLAN_ADD:
 957                 err = dsa_switch_vlan_add(ds, info);
 958                 break;
 959         case DSA_NOTIFIER_VLAN_DEL:
 960                 err = dsa_switch_vlan_del(ds, info);
 961                 break;
 962         case DSA_NOTIFIER_HOST_VLAN_ADD:
 963                 err = dsa_switch_host_vlan_add(ds, info);
 964                 break;
 965         case DSA_NOTIFIER_HOST_VLAN_DEL:
 966                 err = dsa_switch_host_vlan_del(ds, info);
 967                 break;
 968         case DSA_NOTIFIER_MTU:
 969                 err = dsa_switch_mtu(ds, info);
 970                 break;
 971         case DSA_NOTIFIER_TAG_PROTO:
 972                 err = dsa_switch_change_tag_proto(ds, info);
 973                 break;
 974         case DSA_NOTIFIER_TAG_PROTO_CONNECT:
 975                 err = dsa_switch_connect_tag_proto(ds, info);
 976                 break;
 977         case DSA_NOTIFIER_TAG_PROTO_DISCONNECT:
 978                 err = dsa_switch_disconnect_tag_proto(ds, info);
 979                 break;
 980         case DSA_NOTIFIER_TAG_8021Q_VLAN_ADD:
 981                 err = dsa_switch_tag_8021q_vlan_add(ds, info);
 982                 break;
 983         case DSA_NOTIFIER_TAG_8021Q_VLAN_DEL:
 984                 err = dsa_switch_tag_8021q_vlan_del(ds, info);
 985                 break;
 986         case DSA_NOTIFIER_MASTER_STATE_CHANGE:
 987                 err = dsa_switch_master_state_change(ds, info);
 988                 break;
 989         default:
 990                 err = -EOPNOTSUPP;
 991                 break;
 992         }
 993
 994         if (err)
 995                 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
 996                         event, err);
 997
 998         return notifier_from_errno(err);
 999 }
1000
1001 int dsa_switch_register_notifier(struct dsa_switch *ds)
1002 {
1003         ds->nb.notifier_call = dsa_switch_event;
1004
1005         return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
1006 }
1007
1008 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
1009 {
1010         int err;
1011
1012         err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
1013         if (err)
1014                 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
1015 }