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