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